AWS IoT Greengrass - Entwicklerhandbuch · AWS IoT Greengrass Entwicklerhandbuch Was ist AWS IoT...

AWS IoT GreengrassEntwicklerhandbuch

AWS IoT Greengrass Entwicklerhandbuch

AWS IoT Greengrass: EntwicklerhandbuchCopyright © 2019 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsWas ist AWS IoT Greengrass? ............................................................................................................. 1

AWS IoT Greengrass Core-Software ............................................................................................. 2AWS IoT Greengrass Core-Versionen .................................................................................... 2

AWS IoT Greengrass-Gruppen ..................................................................................................... 6Geräte in AWS IoT Greengrass .................................................................................................... 8SDKs ........................................................................................................................................ 9Unterstützte Plattformen und Anforderungen ................................................................................. 12AWS IoT Greengrass-Downloads ................................................................................................ 15

AWS IoT Greengrass Core-Software .................................................................................... 15AWS IoT Greengrass Snap Software ................................................................................... 18AWS IoT Greengrass Docker-Software ................................................................................. 20AWS IoT Greengrass Core-SDK-Software ............................................................................ 21AWS IoT Greengrass Machine Learning-Laufzeiten und vorkompilierte Bibliotheken ..................... 21AWS IoT Greengrass ML SDK Software .............................................................................. 22

Bitte geben Sie uns Feedback .................................................................................................... 23AWS IoT Greengrass-Core ......................................................................................................... 23

AWS IoT Greengrass-Core-Konfigurationsdatei ...................................................................... 23Endpunkte müssen dem Zertifikattyp entsprechen .................................................................. 48Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy ....................................... 49Schreibverzeichnis ............................................................................................................ 55Nachrichtenqualität des Service .......................................................................................... 58MQTT-Nachrichtenwarteschlange ........................................................................................ 58Client-IDs für MQTT-Verbindungen mit AWS IoT ................................................................... 61Aktivieren der automatischen IP-Erkennung .......................................................................... 63Ausführen von Greengrass bei Systemstart ........................................................................... 66Archivieren einer Core-Software-Installation .......................................................................... 66Weitere Informationen finden Sie auch unter: ........................................................................ 68

Erste Schritte mit AWS IoT Greengrass ............................................................................................... 69Voraussetzungen ...................................................................................................................... 69Erstellen eines AWS-Kontos ....................................................................................................... 70Modul 1: Umgebungseinrichtung für Greengrass ............................................................................ 70

Einrichten eines Raspberry Pi ............................................................................................. 70Einrichten einer Amazon EC2-Instance ................................................................................ 75Einrichten anderer Geräte .................................................................................................. 80

Modul 2: Installieren der AWS IoT Greengrass Core-Software .......................................................... 81Konfigurieren von AWS IoT Greengrass auf AWS IoT ............................................................. 82Starten von AWS IoT Greengrass auf dem Core-Gerät ........................................................... 86

Modul 3 (Teil 1): Lambda-Funktionen auf AWS IoT Greengrass ........................................................ 89Erstellen und Verpacken einer Lambda-Funktion ................................................................... 90Konfigurieren der Lambda-Funktion für AWS IoT Greengrass ................................................... 94Bereitstellen von Cloud-Konfigurationen für ein Core-Gerät .................................................... 100Überprüfen Sie, ob die Lambda-Funktion auf dem Gerät ausgeführt wird .................................. 101

Modul 3 (Teil 2): Lambda-Funktionen auf AWS IoT Greengrass ...................................................... 103Erstellen und Verpacken der Lambda-Funktion .................................................................... 104Konfigurieren langlebiger Lambda-Funktionen für AWS IoT Greengrass ................................... 106Testen von langlebigen Lambda-Funktionen ........................................................................ 107Testen von On-Demand-Lambda-Funktionen ....................................................................... 112

Modul 4: Interaktion mit Geräten in einer AWS IoT Greengrass-Gruppe ........................................... 116Erstellen von AWS IoT-Geräten in einer AWS IoT Greengrass-Gruppe .................................... 117Konfigurieren von Abonnements ........................................................................................ 121Installieren der AWS IoT-Geräte-SDK für Python .................................................................. 122Testen der Kommunikation ............................................................................................... 126

Modul 5: Interaktion mit Geräteschatten ...................................................................................... 129Konfigurieren von Geräten und Abonnements ...................................................................... 130

iii


Download der benötigten Dateien ...................................................................................... 134Testen der Kommunikation (Gerätesynchronisierungen deaktiviert) .......................................... 134Testen der Kommunikation (Gerätesynchronisierungen aktiviert) ............................................. 137

Modul 6: Zugriff auf andere AWS-Services .................................................................................. 139Konfigurieren der Gruppenrolle .......................................................................................... 141Erstellen und Konfigurieren der Lambda-Funktion ................................................................. 143Konfigurieren von Abonnements ........................................................................................ 148Testen der Kommunikation ............................................................................................... 149

Modul 7: Simulation der Hardware-Sicherheitsintegration ............................................................... 151Installieren von SoftHSM .................................................................................................. 152Konfigurieren von SoftHSM ............................................................................................... 152Importieren des privaten Schlüssels ................................................................................... 153Konfigurieren des Greengrass-Cores .................................................................................. 154Testen der Konfiguration .................................................................................................. 156Weitere Informationen finden Sie auch unter: ...................................................................... 157

OTA-Updates der AWS IoT Greengrass Core-Software ......................................................................... 158Greengrass OTA-Update-Agent ................................................................................................. 159Integration mit Init-Systemen ..................................................................................................... 162

OTA-Selbstaktualisierung mit Managed Respawn ................................................................. 162AWS IoT Greengrass Core-Aktualisierung mit Managed Respawn .......................................... 163

Selbstaktualisierung des OTA-Update-Agenten ............................................................................ 163Greengrass Core-Softwareaktualisierung ..................................................................................... 163

Zurücksetzen von Bereitstellungen ..................................................................................................... 164Weitere Informationen finden Sie auch unter: .............................................................................. 165

Erstellen von Sammelbereitstellungen für Gruppen ............................................................................... 166Voraussetzungen ..................................................................................................................... 166Erstellen und Hochladen der Eingabedatei für die Sammelbereitstellung .......................................... 166Erstellen und Konfigurieren einer IAM-Ausführungsrolle ................................................................. 168Ihrer Ausführungsrolle den Zugriff auf Ihren S3-Bucket ermöglichen ................................................ 170Bereitstellen der Gruppen ......................................................................................................... 171Testen der Bereitstellung .......................................................................................................... 172Fehlerbehebung bei Sammelbereitstellungen ............................................................................... 173

Fehlerbehebung bei Fehlern in der Eingabedatei .................................................................. 174Auf gleichzeitige Sammelbereitstellungen prüfen. ................................................................. 174ErrorDetails überprüfen .................................................................................................... 175Das AWS IoT Greengrass Core-Protokoll überprüfen ............................................................ 175

Weitere Ressourcen ............................................................................................................... 175Lokale Lambda-Funktionen ausführen ................................................................................................ 176

SDKs ..................................................................................................................................... 176Migrieren von cloudbasierten Lambda-Funktionen ................................................................ 178

Funktionsaliasse und -versionen ................................................................................................ 178Steuern der Greengrass Lambda-Funktionsausführung ................................................................. 179

Ausführen einer Lambda-Funktion als Root ......................................................................... 181Überlegungen bei der Auswahl der Containerisierung von Lambda-Funktionen .......................... 182Festlegen der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe ......................... 185Festlegen der Standard-Containerisierung für Lambda-Funktionen in einer Gruppe .................... 186

Kommunikationsströme ............................................................................................................ 186Kommunikation über MQTT-Nachrichten ............................................................................. 186Andere Kommunikationsströme ......................................................................................... 187

Abrufen des Eingabe-Themas (oder -Betreffs) ............................................................................. 187Lebenszykluskonfiguration ........................................................................................................ 189Ausführbare Lambda-Dateien .................................................................................................... 190

Erstellen einer ausführbaren Lambda-Datei ......................................................................... 191Ausführen von AWS IoT Greengrass in einem Docker-Container .................................................... 192

Voraussetzungen ............................................................................................................. 193Anfordern des AWS IoT Greengrass-Container-Image von Amazon ECR ................................. 193Erstellen und Konfigurieren von Greengrass-Gruppe und -Core .............................................. 196

iv


Lokales Ausführen von AWS IoT Greengrass ...................................................................... 196Konfigurieren der "No container (Kein Container)"-Containerisierung für die Gruppe ................... 200Bereitstellen von Lambda-Funktionen für den Docker-Container .............................................. 200(Optional) Bereitstellen von Geräten, die mit der Greengrass-Ausführung im Docker-Containerinteragieren .................................................................................................................... 201Anhalten des AWS IoT Greengrass-Docker-Containers ......................................................... 201Fehlerbehebung bei AWS IoT Greengrass in einem Docker-Container ..................................... 201

Zugriff auf lokale Ressourcen ............................................................................................................ 204Unterstützte Ressourcentypen ................................................................................................... 204Voraussetzungen ..................................................................................................................... 205

Volume-Ressourcen im /proc-Verzeichnis ............................................................................ 205Dateizugriffsberechtigungen des Gruppenbesitzers ....................................................................... 206

Weitere Informationen finden Sie auch unter: ...................................................................... 206Verwenden der CLI ................................................................................................................. 206

Erstellen lokaler Ressourcen ............................................................................................. 207Erstellen der Greengrass-Funktion ..................................................................................... 208Hinzufügen der Lambda-Funktion zur Gruppe ...................................................................... 209Fehlersuche .................................................................................................................... 210

Über die Konsole .................................................................................................................... 211Voraussetzungen ............................................................................................................. 212Erstellen eines Bereitstellungspakets für eine Lambda-Funktion .............................................. 212Erstellen und Veröffentlichen einer Lambda-Funktion ............................................................ 213Hinzufügen der Lambda-Funktion zur Gruppe ...................................................................... 215Hinzufügen einer lokalen Ressource zur Gruppe .................................................................. 218Hinzufügen von Abonnements zur Gruppe .......................................................................... 220Bereitstellen der Gruppe ................................................................................................... 222Testen des lokalen Ressourcenzugriffs ............................................................................... 224

Durchführen von Machine Learning-Inferenzen .................................................................................... 227Wie AWS IoT Greengrass-ML-Inferenz funktioniert ....................................................................... 227Machine Learning-Ressourcen .................................................................................................. 228

Unterstützte Modellquellen ................................................................................................ 228Voraussetzungen ..................................................................................................................... 230Laufzeiten und vorkompilierte Framework-Bibliotheken für ML-Inferenz ............................................ 230

Amazon SageMaker Neo Deep Learning Runtime ................................................................ 231MXNet-Versioning ............................................................................................................ 231MXNet auf Raspberry Pi .................................................................................................. 231TensorFlow-Modellbereitstellungsbeschränkungen auf dem Raspberry Pi ................................. 231

So konfigurieren Sie Machine Learning-Inferenz ........................................................................... 232Voraussetzungen ............................................................................................................. 232Konfigurieren des Raspberry Pi ......................................................................................... 233Installieren des MXNet Framework ..................................................................................... 234Erstellen eines Modellpakets ............................................................................................. 235Erstellen und Veröffentlichen einer Lambda-Funktion ............................................................ 235Hinzufügen der Lambda-Funktion zur Gruppe ...................................................................... 239Hinzufügen von Ressourcen zur Gruppe ............................................................................. 241Hinzufügen eines Abonnements zur Gruppe ........................................................................ 245Bereitstellen der Gruppe ................................................................................................... 247Testen der Anwendung .................................................................................................... 248Nächste Schritte .............................................................................................................. 251Konfigurieren eines NVIDIA Jetson TX2 .............................................................................. 251

So konfigurieren Sie Optimized Machine Learning-Inferenz ............................................................ 252Voraussetzungen ............................................................................................................. 232Konfigurieren des Raspberry Pi ......................................................................................... 253Installieren der Neo Deep Learning Runtime ....................................................................... 254Erstellen einer Lambda-Inferenzfunktion .............................................................................. 255Hinzufügen der Lambda-Funktion zur Gruppe ...................................................................... 259Hinzufügen Neo-optimierter Modellressource zur Gruppe ....................................................... 260

v


Hinzufügen Ihrer Kamerageräte-Ressource zur Gruppe ......................................................... 261Hinzufügen von Abonnements zur Gruppe .......................................................................... 264Bereitstellen der Gruppe ................................................................................................... 265Testen des Beispiels ....................................................................................................... 248Konfigurieren eines Intel Atom .......................................................................................... 268Konfigurieren eines NVIDIA Jetson TX2 .............................................................................. 269Fehlerbehebung bei AWS IoT Greengrass-ML-Inferenz ......................................................... 250Nächste Schritte .............................................................................................................. 273

Secrets für Core bereitstellen ............................................................................................................ 274Secrets Verschlüsselung .......................................................................................................... 275Voraussetzungen ..................................................................................................................... 276Angeben des privaten Schlüssels für die Verschlüsselung von Secrets ............................................ 276AWS IoT Greengrass den Zugriff auf Secret-Werte erlauben .......................................................... 277Weitere Informationen finden Sie auch unter: .............................................................................. 278Arbeiten mit Secret-Ressourcen ................................................................................................ 278

Erstellen und Verwalten von Secrets .................................................................................. 279Verwenden von lokalen Secrets ........................................................................................ 282

Erstellen einer Secret-Ressource (Konsole) ................................................................................. 284Voraussetzungen ............................................................................................................. 285Erstellen eines Secrets Manager-Secrets ............................................................................ 285Hinzufügen einer geheimen Ressource zu einer Gruppe ....................................................... 287Erstellen eines Bereitstellungspakets für eine Lambda-Funktion .............................................. 288Erstellen Sie eine Lambda-Funktion ................................................................................... 289Hinzufügen der Funktion zur Gruppe .................................................................................. 291Verknüpfen der Secret-Ressource mit der Funktion .............................................................. 291Hinzufügen von Abonnements zur Gruppe .......................................................................... 292Bereitstellen der Gruppe ................................................................................................... 293Testen der Funktion ........................................................................................................ 294Weitere Informationen finden Sie auch unter: ...................................................................... 296

Integrieren von Services und Protokollen mit Konnektoren ..................................................................... 297Voraussetzungen ..................................................................................................................... 298Verwenden von AWS IoT Greengrass-Konnektoren ...................................................................... 298Konfigurationsparameter ........................................................................................................... 300

Parameter für den Zugriff auf Gruppenressourcen ................................................................ 300Aktualisieren von Konnektor-Parametern ............................................................................. 300

Inputs und Outputs .................................................................................................................. 301Input-Themen ................................................................................................................. 301

Protokollierung ........................................................................................................................ 302Von AWS bereitgestellte Greengrass-Konnektoren ....................................................................... 302

CloudWatch-Metriken ....................................................................................................... 303Device Defender ............................................................................................................. 310Bildklassifikation .............................................................................................................. 313IoT Analytics .................................................................................................................. 324Kinesis Firehose ............................................................................................................. 332Modbus-RTU-Protokolladapter ........................................................................................... 340Raspberry Pi GPIO ......................................................................................................... 352Serial Stream ................................................................................................................. 357ServiceNow MetricBase-Integration .................................................................................... 365SNS .............................................................................................................................. 371Splunk-Integration ............................................................................................................ 376Twilio-Benachrichtigungen ................................................................................................ 382

Beginnen Sie mit Konnektoren (Konsole) .................................................................................... 390.................................................................................................................................... 390

Voraussetzungen ............................................................................................................. 391Erstellen eines Secrets Manager-Secrets ............................................................................ 391Hinzufügen einer geheimen Ressource zu einer Gruppe ....................................................... 393Hinzufügen eines Konnektors zur Gruppe ........................................................................... 394

vi


Erstellen eines Bereitstellungspakets für eine Lambda-Funktion .............................................. 394Erstellen Sie eine Lambda-Funktion ................................................................................... 396Hinzufügen einer Funktion zur Gruppe ............................................................................... 397Hinzufügen von Abonnements zur Gruppe .......................................................................... 398Bereitstellen der Gruppe ................................................................................................... 399Testen der Lösung .......................................................................................................... 400Weitere Informationen finden Sie auch unter: ...................................................................... 401

Beginnen Sie mit Konnektoren (CLI) .......................................................................................... 401.................................................................................................................................... 401

Voraussetzungen ............................................................................................................. 403Erstellen eines Secrets Manager-Secrets ............................................................................ 404Erstellen einer Ressourcendefinition und -version ................................................................. 404Erstellen einer Konnektordefinition und -version ................................................................... 405Erstellen eines Bereitstellungspakets für eine Lambda-Funktion .............................................. 406Erstellen Sie eine Lambda-Funktion ................................................................................... 407Erstellen einer Funktionsdefinition und -version .................................................................... 408Erstellen einer Abonnementdefinition und -version ................................................................ 409Erstellen einer Gruppenversion .......................................................................................... 410Erstellen einer Bereitstellung ............................................................................................. 411Testen der Lösung .......................................................................................................... 412Weitere Informationen finden Sie auch unter: ...................................................................... 413

RESTful-API für Greengrass Discovery ............................................................................................... 414Anforderung ............................................................................................................................ 414Antwort .................................................................................................................................. 415Autorisierung .......................................................................................................................... 415Beispieldokumente für Discovery-Antwort .................................................................................... 415

Greengrass OPC-UA ....................................................................................................................... 418Übersicht über die Architektur ................................................................................................... 418Einrichten eines OPC-UA-Testservers ........................................................................................ 419Stellen Sie sicher, dass Ihre Greengrass-Gruppe bereit ist. ............................................................ 420Verwenden Sie Greengrass OPC-UA für Interaktionen mit Ihrem OPC-UA-Server. ............................. 420Stellen Sie sicher, dass Ihre Lambda-Funktion OPC-UA-Veröffentlichungen erhält und sie aufGreengrass postet. .................................................................................................................. 422Nächste Schritte ...................................................................................................................... 423

AWS IoT Greengrass Sicherheit ........................................................................................................ 424Konfigurieren der Greengrass-Sicherheit ..................................................................................... 425

Minimale AWS IoT-Richtlinie für das AWS IoT Greengrass Core-Gerät .................................... 426Sicherheitsprinzipale ................................................................................................................ 428Geräteverbindung – Workflow .................................................................................................... 430Greengrass-Messaging – Workflow ............................................................................................ 430Zertifikatrotation auf dem MQTT-Core-Server ............................................................................... 430AWS IoT Greengrass Cipher Suites ........................................................................................... 431Greengrass-Servicerolle ........................................................................................................... 432

Servicerolle abrufen ......................................................................................................... 432Die Servicerolle erstellen .................................................................................................. 433Servicerollen entfernen ..................................................................................................... 434Weitere Informationen finden Sie auch unter: ...................................................................... 434

Hardware-Sicherheit ................................................................................................................ 435Voraussetzungen ............................................................................................................. 435Hardware-Sicherheitskonfiguration ..................................................................................... 436Bereitstellungspraktiken ................................................................................................... 439Unterstützte Verschlüsselungs-Suiten ................................................................................. 442Konfigurieren von OTA-Updates ........................................................................................ 442Abwärtskompatibilität ....................................................................................................... 443Hardware ohne PKCS#11-Unterstützung ............................................................................. 443Weitere Informationen finden Sie auch unter: ...................................................................... 443

Überwachung ................................................................................................................................. 444

vii


CloudWatch Logs .................................................................................................................... 444Dateisystemprotokolle .............................................................................................................. 445Standardkonfiguration für die Protokollierung ............................................................................... 445Konfigurieren der Protokollierung für AWS IoT Greengrass ............................................................ 446

Konfigurieren der Protokollierung (Konsole) ......................................................................... 446Protokollierung konfigurieren (API) ..................................................................................... 447Konfigurationsbeispiel ...................................................................................................... 448

Einschränkungen für die Protokollierung ..................................................................................... 448Transaktionen pro Sekunde .............................................................................................. 448Arbeitsspeicher ............................................................................................................... 449Taktversatz ..................................................................................................................... 449Festplattennutzung .......................................................................................................... 449Protokollverlust ............................................................................................................... 449

Protokollieren von AWS IoT Greengrass-API-Aufrufen mit AWS CloudTrail ....................................... 449AWS IoT Greengrass-Informationen in CloudTrail ................................................................. 450Grundlagen zu AWS IoT Greengrass-Protokolldateieinträgen ................................................. 450

CloudTrail-Protokolle ................................................................................................................ 453Markieren Ihrer Greengrass-Ressourcen ............................................................................................. 454

Grundlagen zu Tags ................................................................................................................ 454Markierungsunterstützung in der AWS IoT Greengrass-API .................................................... 454

Verwenden von Tags mit IAM-Richtlinien .................................................................................... 455IAM-Beispielrichtlinien ...................................................................................................... 456

Tag-Einschränkungen .............................................................................................................. 457AWS CloudFormation-Unterstützung für AWS IoT Greengrass ............................................................... 459

Erstellen von Ressourcen ......................................................................................................... 459Ressourcen bereitstellen .......................................................................................................... 460Beispielvorlage ........................................................................................................................ 460

Verwendung des AWS IoT Device Testers für AWS IoT Greengrass ....................................................... 470AWS IoT Device Tester für AWS IoT Greengrass-Versionen .......................................................... 471

Frühere IDT-Versionen für AWS IoT Greengrass .................................................................. 471Voraussetzungen ..................................................................................................................... 473

Laden Sie die neueste Version von AWS IoT Device Tester für AWS IoT Greengrass herunter. .... 473Erstellen und Konfigurieren eines AWS-Kontos .................................................................... 473Verwenden von IDT für Greengrass 1.6.1 und frühere Versionen ............................................ 475Konfigurieren Ihres Geräts ................................................................................................ 476

Festlegen der Konfiguration zum Ausführen der AWS IoT Greengrass Qualification Suite .................... 478Konfigurieren Ihrer AWS-Anmeldeinformationen ................................................................... 479Gerätekonfiguration ......................................................................................................... 480

Ausführen von Tests ................................................................................................................ 483Befehle für AWS IoT Device Tester für AWS IoT Greengrass ................................................. 483

Verstehen der Ergebnisse und Protokolle ................................................................................... 483Anzeigen der Ergebnisse .................................................................................................. 484

Beschreibung der Testgruppen .................................................................................................. 486Fehlerbehebung in IDT für AWS IoT Greengrass ......................................................................... 488

Fehlercodes .................................................................................................................... 488Beseitigen von Fehlern in IDT für AWS IoT Greengrass ........................................................ 496

Fehlersuche .................................................................................................................................... 500Probleme mit AWS IoT Greengrass Core .................................................................................... 500

Fehler: In der Konfigurationsdatei fehlt CaPath, CertPath oder KeyPath. Der Greengrass-Daemon-Prozess mit [pid = <pid>] ist abgestürzt. ................................................................. 501Fehler: Fehler beim Analysieren von /<greengrass-root>/config/config.json. .............................. 501Fehler: Laufzeit konnte nicht gestartet werden: Es konnten keine Worker gestartet werden:Zeitüberschreitung für den Container-Test. .......................................................................... 502Fehler: Aufruf von PutLogEvents in lokaler Cloudwatch-Installation nicht möglich, logGroup: /GreengrassSystem/connection_manager, error: RequestError: send request failed causedby: Post http://<path>/cloudwatch/logs/: dial tcp <address>: getsockopt: connection refused,response: { }. .................................................................................................................. 502

viii


Fehler: Server konnte nicht erstellt werden: Folgende Gruppe konnte nicht geladenwerden: chmod /<greengrass-root>/ggc/deployment/lambda/arn:aws:lambda:<region>:<account-id>:function:<function-name>:<version>/<file-name>: no such file or directory. ........................... 503Die AWS IoT Greengrass Core-Software wird nicht gestartet, nachdem Sie von der Ausführungohne Containerisierung zur Ausführung in einem Greengrass-Container gewechselt sind. ............ 503Fehler: Spulengröße sollte mindestens 262144 Bytes betragen. .............................................. 503Fehler: container_linux.go:344: Start des Container-Prozesses verursachte„process_linux.go:424: container init caused \"rootfs_linux.go:64: mounting \\\"/greengrass/ggc/socket/greengrass_ipc.sock\\\" to rootfs \\\"/greengrass/ggc/packages/<version>/rootfs/merged\\\" at \\\"/greengrass_ipc.sock\\\" caused \\\"stat /greengrass/ggc/socket/greengrass_ipc.sock:permission denied\\\"\"“. .................................................................................................... 504Fehler: Greengrass-Daemon wird mit folgender PID ausgeführt: <process-id>. EinigeSystemkomponenten konnten nicht gestartet werden. Überprüfen Sie die Datei „'runtime.log“ aufFehler. ........................................................................................................................... 504Der Geräteschatten wird nicht mit der Cloud synchronisiert. ................................................... 504Die AWS IoT Greengrass Core-Software wird auf Raspberry Pi nicht ausgeführt, da derBenutzer-Namespace nicht aktiviert ist. .............................................................................. 505FEHLER: TCP-Verbindung kann nicht angenommen werden. accept tcp [::]:8000: accept4: zuviele geöffnete Dateien. .................................................................................................... 505Fehler: Laufzeit-Ausführungsfehler: Lambda-Container kann nicht gestartet werden.container_linux.go:259: starting container process caused "process_linux.go:345: container initcaused \"rootfs_linux.go:50: preparing rootfs caused \\\"permission denied\\\"\"". ........................ 505Warnung: [WARN]-[5]GK Remote: Fehler beim Abrufen von Daten zu öffentlichen Schlüsseln.ErrPrincipalNotConfigured: Kein privater Schlüssel für MqttCertificate festgelegt. ....................... 506Fehler: Berechtigung abgelehnt für Verwendung der Rolle arn:aws:iam::<account-id>:role/<role-name> to access s3 url https://<region>-greengrass-updates.s3.<region>.amazonaws.com/core/<architecture>/greengrass-core-<distribution-version>.tar.gz. .................................................. 506Das AWS IoT Greengrass-Core ist so konfiguriert, dass ein Netzwerk-Proxy verwendet wird undIhre Lambda-Funktion kann keine ausgehenden Verbindungen herstellen. ................................ 506Der Core befindet sich in einer unendlichen Verbinden-Trennen-Schleife. Die Datei „runtime.log“enthält eine fortlaufende Reihe von Verbinden- und Trennen-Einträgen. ................................... 507

Bereitstellungsprobleme ............................................................................................................ 507Für die Bereitstellung wird der Fehler „403 Forbidden” in den Protokollen angezeigt. .................. 508Der Fehler „ConcurrentDeployment“ tritt auf, wenn Sie den Befehl create-deployment zum erstenMal ausführen. ................................................................................................................ 508Fehler: Greengrass ist nicht zur Übernahme der Servicerolle berechtigt, die mit diesem Kontoverknüpft ist; oder derFehler: Fehlgeschlagen: TES-Servicerolle ist nicht mit diesem Kontoverknüpft. ....................................................................................................................... 508Die Bereitstellung wird nicht abgeschlossen. ....................................................................... 509Die Bereitstellung wird nicht fertiggestellt und „runtime.log“ enthält mehrere Einträge für„1 Sekunde auf Anhalten des Containers gewartet“. .............................................................. 509Fehler: Bereitstellung <guid> of type NewDeployment for group <guid> fehlgeschlagen; Fehler:Fehler beim Verarbeiten. Gruppenkonfiguration ist ungültig: 112 oder [119 0] besitzen keineLese- und Schreibberechtigungen für die Datei: <path>. ........................................................ 509Fehler: <list-of-function-arns> ist für die Ausführung als Stamm konfiguriert; Greengrass istjedoch nicht für die Ausführung von Lambda-Funktionen mit Root-Berechtigungen konfiguriert. ..... 510Fehler: Bereitstellung <deployment-id> des Typs NewDeployment für Gruppe <group-id>fehlgeschlagen; Fehler: Verarbeitungsstart fehlgeschlagen: container_linux.go:259: Start desContainer-Prozesses verursachte „process_linux.go:250: running exec setns process for initcaused \"wait: no child processes\"“. .................................................................................. 510

Probleme beim Erstellen der Gruppe oder Funktion ...................................................................... 510Fehler: Die „IsolationMode“-Konfiguration für die Gruppe ist ungültig. ....................................... 511Fehler: Die „IsolationMode“-Konfiguration für die Funktion mit dem ARN <function-arn> istungültig. ......................................................................................................................... 511Fehler: MemorySize-Konfiguration für die Funktion mit dem ARN <function-arn> ist inIsolationMode=NoContainer nicht zulässig. .......................................................................... 511

ix


Fehler: Der Zugriff auf die Sysfs-Konfiguration ist für die Funktion mit dem ARN <function-arn> inIsolationMode=NoContainer nicht zulässig. .......................................................................... 511Fehler: Die MemorySize-Konfiguration für die Funktion mit dem ARN <function-arn> ist inIsolationMode=GreengrassContainer erforderlich. ................................................................. 512Fehler: Funktion <function-arn> bezieht sich auf eine Ressource des Typs <resource-type>, diein IsolationMode=NoContainer nicht zulässig ist. .................................................................. 512Fehler: Die Ausführungskonfiguration für die Funktion mit dem ARN <function-arn> ist nichtzulässig. ........................................................................................................................ 512

AWS IoT Greengrass Probleme mit Core in Docker ...................................................................... 512Fehler: Unbekannte Optionen: -no-include-email .................................................................. 201Warnung: IPv4 ist deaktiviert. Das Netzwerk wird nicht funktionieren. ....................................... 201Fehler: Eine Firewall blockiert die Freigabe von Dateien zwischen Fenstern und den Containern. .. 202Fehler: Container kann für den Greengrass-Service nicht erstellt werden: Konflikt. DerContainername „/ aws-iot-greengrass“ wird bereits verwendet. ................................................ 513Fehler: [FATAL] -Fehler beim Zurücksetzen des Mount-Namespace des Threads aufgrund einesunerwarteten Fehlers: „Vorgang nicht zulässig“. Zur Sicherstellung der Konsistenz wird GGCabstürzen und manuell neu gestartet werden. ...................................................................... 514

Fehlerbehebung mit Protokollen ................................................................................................ 514Fehlerbehebung bei Speicherproblemen ..................................................................................... 515Fehlerbehebung für Nachrichten ................................................................................................ 515Beheben von Timeout-Problemen während der Schattensynchronisierung ........................................ 515Sehen Sie im AWS IoT Greengrass-Forum nach ......................................................................... 516

Dokumentverlauf ............................................................................................................................. 517Frühere Aktualisierungen .......................................................................................................... 520

x


Was ist AWS IoT Greengrass?AWS IoT Greengrass ist Software, mit der sich Cloud-Fähigkeiten auf lokale Geräte übertragen lassen.So können Geräte Daten näher an der Informationsquelle sammeln und analysieren, autonom auf lokaleEreignisse reagieren und sicher miteinander in lokalen Netzwerken kommunizieren. AWS IoT Greengrass-Entwickler können mit AWS Lambda-Funktionen und vordefinierten Konnektoren (p. 297) serverloseAnwendungen erstellen, die auf Geräten zur lokalen Ausführung bereitgestellt werden.

Das folgende Diagramm zeigt die grundlegende Architektur von AWS IoT Greengrass.

AWS IoT Greengrass ermöglicht es Kunden, IoT-Geräte und Anwendungslogik aufzubauen. Konkret bietetAWS IoT Greengrass eine Cloud-basierte Verwaltung der Anwendungslogik, die auf Geräten läuft. Lokalbereitgestellte Lambda-Funktionen und Konnektoren werden durch lokale Ereignisse, Nachrichten von derCloud oder anderen Quellen ausgelöst.

In AWS IoT Greengrass kommunizieren Geräte sicher in einem lokalen Netzwerk und tauschenNachrichten miteinander aus, ohne eine Verbindung zur Cloud herstellen zu müssen. AWS IoT Greengrassstellt einen lokalen Manager für Pub-/Sub-Nachrichten bereit, der Nachrichten auf intelligente Weise puffernkann, wenn die Verbindung getrennt wurde, sodass die in die Cloud eingehenden und aus der Cloudausgehenden Nachrichten erhalten bleiben.

AWS IoT Greengrass schützt Benutzerdaten:

• Durch die sichere Authentifizierung und Autorisierung von Geräten.• Durch sichere Verbindungen im lokalen Netzwerk.• Zwischen lokalen Geräte und der Cloud.

Sicherheitsanmeldeinformationen für Geräte funktionieren innerhalb einer Gruppe, bis sie aufgehobenwerden, auch wenn die Konnektivität mit der Cloud unterbrochen wird, sodass die Geräte weiterhin sicherlokal kommunizieren können.

AWS IoT Greengrass stellt sichere Over-The-Air-Softwareupdates von Lambda-Funktionen bereit.

AWS IoT Greengrass besteht aus Folgendem:

• Software-Verteilungen• AWS IoT Greengrass Core-Software• AWS IoT Greengrass-Core-SDK

• Cloud-Service

1

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Core-Software

• AWS IoT Greengrass-API• Funktionen

• Lambda-Laufzeit• Shadows-Implementierung• Nachrichtenmanager• Gruppenmanagement• Discovery Service• Over-The-Air-Update-Agent• Zugriff auf lokale Ressourcen• Lokale Machine Learning-Inferenz• Manager lokaler Secrets• Verbindungen mit werkseitiger Integration mit Services, Protokollen und Software

AWS IoT Greengrass Core-SoftwareDie AWS IoT Greengrass Core-Software bietet folgende Funktionalität:

• Bereitstellung und lokale Ausführung von Connectors und Lambda-Funktionen.• Sichere, verschlüsselte Speicherung lokaler Geheimnisse und kontrollierter Zugriff durch Connectors und

Lambda-Funktionen.• MQTT-Messaging über das lokale Netzwerk zwischen Geräten, Connectors und Lambda-Funktionen

unter Verwendung verwalteter Abonnements.• MQTT-Messaging zwischen dem AWS IoT und Geräten, Connectors und Lambda-Funktionen unter

Verwendung verwalteter Abonnements.• Sichere Verbindungen zwischen Geräten und der Cloud durch Geräteauthentifizierung und Autorisierung.• Lokale Shadow-Synchronisierung von Geräten. Schatten können so konfiguriert werden, dass sie mit der

Cloud synchronisiert sind.• Kontrollierter Zugriff auf lokale Geräte- und Volume-Ressourcen.• Bereitstellung von Modellen für das maschinelle Lernen, die in der Cloud geschult werden, für die

Ausführung lokaler Inferenzen.• Automatische Erkennung von IP-Adressen, die Geräte in die Lage versetzt, das Greengrass Core-Gerät

zu erkennen.• Zentrale Bereitstellung neuer oder aktualisierter Gruppenkonfigurationen. Nach dem Download der

Konfigurationsdaten wird das Core-Gerät automatisch neu gestartet.• Sichere Over-the-Air Software-Updates von benutzerdefinierten Lambda-Funktionen.

AWS IoT Greengrass-Core-Instances werden über AWS IoT Greengrass-APIs konfiguriert, die AWS IoTGreengrass-Gruppendefinitionen erstellen und aktualisieren, die in der Cloud gespeichert werden.

AWS IoT Greengrass Core-VersionenAuf den folgenden Registerkarten werden die Neuerungen und Änderungen in den AWS IoT GreengrassCore-Softwareversionen beschrieben.

GGC v1.9

1.9.2 - Aktuelle Version

Neue Funktionen:

2

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Core-Versionen

• Unterstützung für OpenWrt. Die AWS IoT Greengrass Core-Software v1.9.2 kann auf OpenWrt-Verteilungen mit ARMv8- (AArch64-) und ARMv7l-Architekturen installiert werden. Derzeitunterstützt OpenWrt die ML-Inferenz nicht.

1.9.1

Fehlerbehebungen und Verbesserungen:• Es wird ein in v1.9.0 eingeführter Fehler behoben, der Nachrichten aus cloud entfernt, die im

Thema Platzhalterzeichen enthalten.1.9.0

Neue Funktionen:• Unterstützung für Lambda-Laufzeiten Python 3.7 und Node.js 8.10. Lambda-Funktionen mit

Laufzeiten Python 3.7 und Node.js 8.10 können jetzt auf AWS IoT Greengrass-Core ausgeführtwerden. (AWS IoT Greengrass unterstützt weiterhin die Laufzeiten Python 2.7 und Node.js6.10.)

• Optimierte MQTT-Verbindungen. Der Greengrass Core baut weniger Verbindungen mit demAWS IoT Core auf. Diese Änderung kann Betriebskosten hinsichtlich Gebühren, die auf derAnzahl der Verbindungen basieren, senken.

• Elliptic Curve (EC)-Schlüssel für den lokalen MQTT-Server. Der lokale MQTT-Server unterstütztEC-Schlüssel zusätzlich zu den RSA-Schlüsseln. (Das MQTT-Serverzertifikat verfügt über eineSHA-256-RSA-Signatur, unabhängig vom Schlüsseltyp.) Weitere Informationen finden Sie unterthe section called “Sicherheitsprinzipale” (p. 428).

Fehlerbehebungen und Verbesserungen:• Allgemeine Leistungssteigerungen und Bugfixes.

GGC v1.8

1.8.3

Allgemeine Leistungssteigerungen und Bugfixes.1.8.2



Neue Funktionen:• Konfigurierbare Standardzugriffsidentität für Lambda-Funktionen in der Gruppe. Diese

Einstellung auf Gruppenlevel bestimmt die Standardberechtigungen, die zum Ausführen vonLambda-Funktionen verwendet werden. Sie können die Benutzer-ID, Gruppen-ID oder beidesfestlegen. Einzelne Lambda-Funktionen können die Standardzugriffsidentität ihrer Gruppeüberschreiben. Weitere Informationen finden Sie unter the section called “Festlegen derStandardzugriffsidentität für Lambda-Funktionen in einer Gruppe” (p. 185).

• HTTPS-Datenverkehr über Port 443. HTTPS-Kommunikation kann so konfiguriert werden, dasssie über Port 443 anstatt über Standard-Port 8443 ausgeführt wird. Dies ergänzt die AWS IoTGreengrass-Unterstützung für die Application Layer Protocol Network (ALPN) TLS-Erweiterungund ermöglicht dem gesamten Greengrass-Messaging-Datenverkehr – MQTT und HTTPS– die Verwendung von Port 443. Weitere Informationen finden Sie unter the section called“Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy” (p. 49).

• Client-IDs mit vorhersagbarem Namen für AWS IoT Verbindungen. Diese Änderungermöglicht die Unterstützung für Lebenszyklus-Ereignisse AWS IoT Device Defender und

3

https://openwrt.org/

https://docs.aws.amazon.com/iot/latest/developerguide/life-cycle-events.html


AWS IoT, damit Sie Benachrichtigungen für Verbindungs-, Abmelde-, Abonnement- undAbonnementbeendungsereignisse erhalten. Die vorhersehbare erleichtert auch die das Erstellenvon Logik zu Verbindungs-IDs (z. B. zum Erstellen von Vorlagen für eine Abonnieren-Richtliniebasierend auf Zertifikatattributen). Weitere Informationen finden Sie unter the section called“Client-IDs für MQTT-Verbindungen mit AWS IoT” (p. 61).


GGC v1.7

1.7.1

Neue Funktionen:• Greengrass-Konnektoren, die eine eingebaute Integration mit der lokalen Infrastruktur,

Geräteprotokollen, AWS und anderen Cloud-Services ermöglichen. Weitere Informationenfinden Sie unter Integrieren von Services und Protokollen mit Konnektoren (p. 297).

• AWS IoT Greengrass erweitert AWS Secrets Manager auf Core-Geräte, wodurch IhrePasswörter, Token und andere Secrets Konnektoren und Lambda-Funktionen zur Verfügungstehen. Secrets werden während der Übertragung und im Ruhezustand verschlüsselt. WeitereInformationen finden Sie unter Secrets für Core bereitstellen (p. 274).

• Unterstützung für eine Hardware-Root of Trust Sicherheitsoption. Weitere Informationen findenSie unter the section called “Hardware-Sicherheit” (p. 435).

• Isolations- und Berechtigungseinstellungen, die es Lambda-Funktionen ermöglichen, ohneGreengrass-Container zu arbeiten und die Berechtigungen eines bestimmten Benutzers undeiner bestimmten Gruppe zu verwenden. Weitere Informationen finden Sie unter the sectioncalled “Steuern der Greengrass Lambda-Funktionsausführung” (p. 179).

• Sie können AWS IoT Greengrass in einem Docker-Container (unter Windows, macOS oderLinux) ausführen, indem Sie Ihre Greengrass-Gruppe für die Ausführung ohne Containerisierungkonfigurieren. Weitere Informationen finden Sie unter the section called “Ausführen von AWSIoT Greengrass in einem Docker-Container” (p. 192).

• MQTT-Messaging auf Port 443 mit Application Layer Protocol Negotiation (ALPN) oder dieVerbindung über einen Netzwerk-Proxy. Weitere Informationen finden Sie unter the sectioncalled “Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy” (p. 49).

• Die Amazon SageMaker Neo Deep Learning-Laufzeit, die Machine-Learning-Modelleunterstützt, die durch den Amazon SageMaker Neo Deep Learning-Compiler optimiert wurden.Weitere Informationen zur Neo Deep Learning-Laufzeit finden Sie unter the section called“Laufzeiten und vorkompilierte Framework-Bibliotheken für ML-Inferenz” (p. 230).

• Unterstützung für Raspbian Stretch (2018-06-27) auf Raspberry Pi Core Geräten.


Darüber hinaus sind mit dieser Version die folgenden Funktionen verfügbar:• Der AWS IoT Device Tester für AWS IoT Greengrass, mit dem Sie überprüfen können, ob Ihre

CPU-Architektur, Kernel-Konfiguration und Treiber mit AWS IoT Greengrass funktionieren.Weitere Informationen finden Sie unter Verwendung des AWS IoT Device Testers für AWS IoTGreengrass (p. 470).

• Die AWS IoT Greengrass Core-Software und die AWS IoT GreengrassCore-SDK- und AWS IoTGreengrass Machine Learning SDK-Pakete sind zum Herunterladen über Amazon CloudFrontverfügbar. Weitere Informationen finden Sie unter the section called “AWS IoT Greengrass-Downloads” (p. 15).

4


https://docs.aws.amazon.com/iot/latest/developerguide/pub-sub-policy.html#pub-sub-policy-cert


Earlier versions

1.6.1

Neue Funktionen:• Ausführbare Lambda-Dateien, die Binärcode auf dem Greengrass-Core ausführen. Verwenden

Sie die neue AWS IoT Greengrass Core-SDK für C zum Schreiben von Ausführbare Lambda-Dateien in C und C++. Weitere Informationen finden Sie unter the section called “AusführbareLambda-Dateien” (p. 190).

• Optionaler Nachrichten-Cache im lokalen Speicher, der einen Neustart überdauert. Sie könnendie Speichereinstellungen für MQTT-Nachrichten konfigurieren, die in der Warteschlange aufdie Verarbeitung warten. Weitere Informationen finden Sie unter the section called “MQTT-Nachrichtenwarteschlange” (p. 58).

• Das konfigurierbare maximale Verbindungswiederholungsintervall bei getrenntem Core-Gerät.Weitere Informationen finden Sie unter der mqttMaxConnectionRetryInterval-Eigenschaftin the section called “AWS IoT Greengrass-Core-Konfigurationsdatei” (p. 23).

• Der lokale Ressourcenzugriff auf das /proc-Verzeichnis des Hosts. Weitere Informationen findenSie unter Zugriff auf lokale Ressourcen (p. 204).

• Konfigurierbares Schreibverzeichnis. Die AWS IoT Greengrass Core-Software kannin schreibgeschützten und Lese-/Schreibspeicherorten bereitgestellt werden. WeitereInformationen finden Sie unter the section called “Schreibverzeichnis” (p. 55).

Fehlerbehebungen und Verbesserungen:• Leistungsverbesserung zur Veröffentlichung von Nachrichten innerhalb des Greengrass-Cores

und zwischen Geräten und dem Core.• Verringerung der Datenverarbeitungsressourcen, die zur Verarbeitung von Protokollen

erforderlich sind, die von benutzerdefinierten Lambda-Funktionen erzeugt werden.1.5.0

Neue Funktionen:• AWS IoT GreengrassDie Machine Learning (ML)-Inferenz ist allgemein verfügbar. Sie können

ML-Inferenz lokal auf AWS IoT Greengrass-Geräten mithilfe von Modellen durchführen, die inder Cloud erstellt und trainiert werden. Weitere Informationen finden Sie unter Durchführen vonMachine Learning-Inferenzen (p. 227).

• Greengrass-Lambda-Funktionen unterstützen jetzt binäre Daten als Eingabenutzlast,zusätzlich zu JSON. Um diese Funktion zu verwenden, müssen Sie ein Upgrade auf AWS IoTGreengrass Core SDK Version 1.1.0 durchführen, das von der Seite AWS IoT GreengrassCore-SDK (p. 21)-Downloads heruntergeladen werden kann.

Fehlerbehebungen und Verbesserungen:• Verringerung des allgemeinen Speicherbedarfs.• Leistungsverbesserungen für das Senden von Nachrichten in die Cloud.• Leistungs- und Stabilitätsverbesserungen für den Download-Agenten, Device-Certificate-

Manager und OTA-Update-Agenten.• Kleinere Fehlerbehebungen.

1.3.0

Neue Funktionen:• Der Over-The-Air (OTA)-Update-Agent kann in der Cloud bereitgestellte Greengrass-

Aktualisierungsaufträge verarbeiten. Den Agenten finden Sie im neuen /greengrass/ota-Verzeichnis. Weitere Informationen finden Sie unter OTA-Updates der AWS IoT GreengrassCore-Software (p. 158).

• Mit der Funktion für den Zugriff auf lokale Ressourcen können Greengrass Lambda-Funktionen auf lokale Ressourcen, wie Peripheriegeräte und Volumes, zugreifen. Weitere

5

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass-Gruppen

Informationen finden Sie unter Zugriff auf lokale Ressourcen mit Lambda-Funktionen undKonnektoren (p. 204).

1.1.0

Neue Funktionen:• Bereitgestellte AWS IoT Greengrass-Gruppen können zurückgesetzt werden, indem Sie die

Lambda-Funktionen, -Abonnements und -Konfigurationen löschen. Weitere Informationen findenSie unter Zurücksetzen von Bereitstellungen (p. 164).

• Unterstützung von Node.js 6.10 und Java 8 Lambda-Laufzeitumgebungen zusätzlich zu Python2.7.

So migrieren Sie von einer früheren AWS IoT Greengrass-Core-Version:• Kopieren Sie die Zertifikate aus dem Ordner /greengrass/configuration/certs in den

Ordner /greengrass/certs.• Kopieren Sie /greengrass/configuration/config.json in /greengrass/config/config.json.

• Führen Sie /greengrass/ggc/core/greengrassd statt /greengrass/greengrassdaus.

• Stellen Sie die Gruppe auf dem neuen Core bereit.1.0.0

Erste Version

Sie können aktuelle Versionen der AWS IoT Greengrass-Core-Software von der Seite the section called“AWS IoT Greengrass Core-Software” (p. 15) herunterladen.

AWS IoT Greengrass-GruppenEine AWS IoT Greengrass-Gruppe ist eine Sammlung von Einstellungen und Komponenten, z. B.ein AWS IoT Greengrass-Core, Geräte und Abonnements. Gruppen werden verwendet, um einenInteraktionsbereich definieren. Beispiel: Eine Gruppe kann ein Stockwerk eines Gebäudes, einen LKWoder eine ganze Mine repräsentieren. Das folgende Diagramm zeigt die Komponenten, aus denen eineGreengrass-Gruppe bestehen kann.

6

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass-Gruppen

Im vorhergehenden Diagramm:

A: AWS IoT Greengrass-Gruppendefinition

Eine Sammlung von Informationen über die AWS IoT Greengrass-Gruppe.B: AWS IoT Greengrass-Gruppeneinstellungen

Dazu zählen:• AWS IoT Greengrass-Gruppe -Rolle.• Zertifizierungsstelle und Konfiguration der lokalen Verbindung.• AWS IoT Greengrass-Core-Verbindungsinformationen.• Standard-Lambda-Laufzeitumgebung. Weitere Informationen finden Sie unter the section called

“Festlegen der Standard-Containerisierung für Lambda-Funktionen in einer Gruppe” (p. 186).• Konfiguration von CloudWatch- und lokalen Protokollen. Weitere Informationen finden Sie unter

Überwachung (p. 444).C: AWS IoT Greengrass-Core

Das AWS IoT-Objekt, das die AWS IoT Greengrass-Core repräsentiert. Weitere Informationen findenSie unter the section called “AWS IoT Greengrass-Core” (p. 23).

D: Lambda-Funktionsdefinition

Eine Liste von Lambda-Funktionen, die lokal auf dem Core ausgeführt werden, mit zugehörigenKonfigurationsdaten. Weitere Informationen finden Sie unter Lokale Lambda-Funktionenausführen (p. 176).

E: Abonnementdefinition

Eine Liste der Abonnements, die die Kommunikation mit MQTT-Nachrichten aktivieren. Mit einemAbonnement wird Folgendes definiert:• Eine Nachrichtenquelle und ein Nachrichtenziel. Dabei kann es sich um Geräte, Lambda-

Funktionen, Konnektoren, AWS IoT und den Service des lokalen Schattens handeln.

7

AWS IoT Greengrass EntwicklerhandbuchGeräte in AWS IoT Greengrass

• Ein Thema; das ein MQTT-Thema oder ein Themenfilter zum Filtern von Nachrichtendaten seinkann.

Weitere Informationen finden Sie unter the section called “Greengrass-Messaging –Workflow” (p. 430).

F: Konnektordefinition

Eine Liste von Konnektoren, die lokal auf dem Core ausgeführt werden, mit zugehörigenKonfigurationsdaten. Weitere Informationen finden Sie unter Integrieren von Services und Protokollenmit Konnektoren (p. 297).

G: Gerätedefinition

Eine Liste von AWS IoT-Objekten (Geräten), die Mitglieder einer AWS IoT Greengrass-Gruppe sind,mit zugehörigen Konfigurationsdaten. Weitere Informationen finden Sie unter the section called “Gerätein AWS IoT Greengrass” (p. 8).

H: Ressourcendefinition

Eine Liste der lokalen Ressourcen, maschinellen Lernressourcen und geheimen Ressourcen aufdem AWS IoT Greengrass-Core, mit den zugehörigen Konfigurationsdaten. Weitere Informationenfinden Sie unter Zugriff auf lokale Ressourcen (p. 204), Durchführen von Machine Learning-Inferenzen (p. 227) und Secrets für Core bereitstellen (p. 274).

Bei der Bereitstellung werden die AWS IoT Greengrass-Gruppe-Definition, die Lambda-Funktionen,Konnektoren, Ressourcen und die Abonnementtabelle zu einem AWS IoT Greengrass-Core-Gerät kopiert.

Geräte in AWS IoT GreengrassEine AWS IoT Greengrass-Gruppe kann zwei Arten von Geräten enthalten:

AWS IoT Greengrass-Core

Bei einem Core handelt es sich um ein AWS IoT-Gerät, auf dem die AWS IoT GreengrassCore-Software ausgeführt wird, mit der es direkt mit den AWS IoT- und AWS IoT Greengrass-Cloud-Services kommunizieren kann. Ein Core verfügt über ein eigenes Zertifikat, das für dieAuthentifizierung bei AWS IoT verwendet wird. Es hat einen Geräteschatten und befindet sichin der AWS IoT-Geräteregistrierung. AWS IoT Greengrass-Cores führen eine lokale Lambda-Laufzeitumgebung, einen Bereitstellungsagenten und einen IP-Adressen-Tracker aus, derInformationen zur IP-Adresse an den AWS IoT Greengrass-Cloud-Service sendet, damit Greengrass-Geräte ihre Gruppe und Core-Verbindungsinformationen automatisch erkennen können. WeitereInformationen finden Sie unter the section called “AWS IoT Greengrass-Core” (p. 23).

Note

Eine Greengrass-Gruppe muss genau einen Kern enthalten.AWS IoT-Gerät verbunden mit einem Greengrass-Kern

Verbundene Geräte (auch als Greengrass-Geräte bezeichnet) können eine Verbindung mit einemKern in derselben Greengrass-Gruppe herstellen. Greengrass-Geräte führen Amazon FreeRTOSaus oder verwenden das AWS IoT Geräte-SDK (p. 10) oder die AWS IoT Greengrass DiscoveryAPI (p. 414), um die Verbindungsinformationen für den Kern abzurufen. Geräte verfügen über eigeneZertifikate für die Authentifizierung, Geräteschatten und Einträge im AWS IoT Geräte-Registry. WeitereInformationen finden Sie unter the section called “Modul 4: Interaktion mit Geräten in einer AWS IoTGreengrass-Gruppe” (p. 116).

In einer Greengrass-Gruppe können Sie Abonnements erstellen, mit denen die Geräte über MQTTmit Lambda-Funktionen, Konnektoren und anderen Geräten in der Gruppe und mit AWS IoT oder

8

https://docs.aws.amazon.com/freertos/latest/userguide/freertos-lib-gg-connectivity.html

AWS IoT Greengrass EntwicklerhandbuchSDKs

dem Service des lokalen Schattens kommunizieren können. MQTT-Nachrichten werden über denKern geleitet. Wenn das Core-Gerät Konnektivität mit der Cloud verliert, können die Geräte weiterhinüber das lokale Netzwerk kommunizieren. Geräte können in der Größe variieren – von kleineren, aufMicrocontrollern basierenden Geräten bis hin zu großen Appliances ist alles vertreten.

Note

Derzeit kann eine Greengrass-Gruppe bis zu 200 Geräte enthalten.

Die folgende Tabelle zeigt, wie diese Gerätetypen verknüpft sind.

Das AWS IoT Greengrass-Core-Gerät speichert Zertifikate an zwei Orten:

• Das Core-Gerätezertifikat unter /greengrass/certs – Das Core-Gerätezertifikat wird als hash.cert.pembenannt (zum Beispiel 86c84488a5.cert.pem). Dieses Zertifikat wird zum Authentifizieren des Coresverwendet, wenn eine Verbindung zu den AWS IoT- oder AWS IoT Greengrass-Services hergestellt wird.

• MQTT Core-Serverzertifikat unter /greengrass-root/ggc/var/state/server – Das MQTTCore-Serverzertifikat wird als server.crt benannt. Dieses Zertifikat wird für die gegenseitigeAuthentifizierung zwischen dem lokalen MQTT-Service (der sich im Greengrass Core befindet) undGreengrass-Geräten verwendet, bevor Nachrichten ausgetauscht werden.

SDKsDie folgenden von AWS bereitgestellten SDKs werden für die Arbeit mit AWS IoT Greengrass verwendet:

9


GGC 1.9

AWS SDK

Mit dem AWS-SDK können Sie Anwendungen erstellen, die mit allen AWS-Services interagieren,einschließlich Amazon S3, Amazon DynamoDB, AWS IoT, AWS IoT Greengrass und mehr.Im Kontext von AWS IoT Greengrass können Sie die im AWS-SDK bereitgestellten Lambda-Funktionen verwenden, um alle AWS-Services direkt aufzurufen. Weitere Informationen finden Sieunter AWS-SDKs (p. 177).

AWS IoT-Geräte-SDK

Die AWS IoT-Geräte-SDK helfen den Geräten, sich mit AWS IoT- oder AWS IoT Greengrass-Services zu verbinden. Die Geräte müssen wissen, zu welcher AWS IoT Greengrass-Gruppe siegehören und die IP-Adresse der AWS IoT Greengrass-Core kennen, mit dem sie sich verbindensollen.

Obwohl Sie alle AWS IoT-Geräte-SDK-Plattformen verwenden können, um eine Verbindung miteinem AWS IoT Greengrass-Core herzustellen, stellen nur die C++- und Python-SDKs AWS IoTGreengrass-spezifische Funktionalität bereit, wie Zugriff auf den AWS IoT Greengrass-DiscoveryService und AWS IoT Greengrass-Core-Stamm-CA-Downloads. Weitere Informationen finden Sieunter AWS IoT Device SDK.

AWS IoT GreengrassCore-SDK

Das AWS IoT Greengrass Core SDK ermöglicht Lambda-Funktionen, mit dem GreengrassCore zu interagieren, Nachrichten im AWS IoT zu veröffentlichen, mit dem Service für lokaleSchatten zu interagieren, andere bereitgestellte Lambda-Funktionen aufzurufen und auf Secret-Ressourcen zuzugreifen. Dieses SDK wird von Lambda-Funktionen genutzt, die auf einemAWS IoT Greengrass-Core ausgeführt werden. Weitere Informationen finden Sie unter AWS IoTGreengrassCore-SDK (p. 177).

AWS IoT Greengrass Machine Learning SDK

Das AWS IoT Greengrass Machine Learning SDK ermöglicht es Lambda-Funktionen, dieMachine-Learning-Modelle zu nutzen, die für den Greengrass Core als Machine Learning-Ressourcen bereitgestellt werden. Dieses SDK wird von Lambda-Funktionen genutzt, die aufeinem AWS IoT Greengrass-Core ausgeführt werden und mit dem lokalen Inferenz-Serviceinteragieren. Weitere Informationen finden Sie unter AWS IoT Greengrass Machine LearningSDK (p. 177).

GGC 1.8

AWS SDK


AWS IoT-Geräte-SDK


Obwohl Sie alle AWS IoT-Geräte-SDK-Plattformen verwenden können, um eine Verbindung miteinem AWS IoT Greengrass-Core herzustellen, stellen nur die C++- und Python-SDKs AWS IoTGreengrass-spezifische Funktionalität bereit, wie Zugriff auf den AWS IoT Greengrass-Discovery

10

https://aws.amazon.com/iot-core/resources/#AWS_IoT_Device_SDKs


Service und AWS IoT Greengrass-Core-Stamm-CA-Downloads. Weitere Informationen finden Sieunter AWS IoT Device SDK.





GGC 1.7

AWS SDK


AWS IoT-Geräte-SDK


Obwohl Sie alle AWS IoT-Geräte-SDK-Plattformen verwenden können, um eine Verbindung miteinem AWS IoT Greengrass-Core herzustellen, stellen nur die C++- und Python-SDKs AWS IoTGreengrass-spezifische Funktionalität bereit, wie Zugriff auf den AWS IoT Greengrass-DiscoveryService und AWS IoT Greengrass-Core-Stamm-CA-Downloads. Weitere Informationen finden Sieunter AWS IoT Device SDK.





11



AWS IoT Greengrass EntwicklerhandbuchUnterstützte Plattformen und Anforderungen

Unterstützte Plattformen und AnforderungenDie folgenden Registerkarten listen die unterstützten Plattformen und Anforderungen für die AWS IoTGreengrass Core-Software auf.

Note

Sie können die AWS IoT Greengrass Core-Software von AWS IoT Greengrass-Core-Software (p. 15)-Downloads herunterladen.

GGC v1.9

Unterstützte Plattformen:

• Architektur: ARMv7l• OS: Linux; Verteilung: Raspbian Stretch, 2018-06-29. AWS IoT Greengrass funktioniert

möglicherweise mit anderen Verteilungen für einen Raspberry Pi, aber wir empfehlen Raspbian,da es sich dabei um die offiziell unterstützte Verteilung handelt.

• OS: Linux; Verteilung: OpenWrt• Architektur: ARMv8 (AArch64)

• OS: Linux; Verteilung: Arch Linux• OS: Linux; Verteilung: OpenWrt

• Architektur: x86_64• OS: Linux; Verteilung: Amazon Linux (amzn2-ami-hvm-2.0.20190313-x86_64-gp2), Ubuntu 18.04

• Windows-, macOS- und Linux-Plattformen können AWS IoT Greengrass in einem Docker-Containerausführen. Weitere Informationen finden Sie unter the section called “Ausführen von AWS IoTGreengrass in einem Docker-Container” (p. 192).

Voraussetzungen:

• Mindestens 128 MB RAM, zugewiesen zum AWS IoT Greengrass-Core-Gerät.• Linux-Kernel Version 4.4 oder höher: Es können zwar frühere Versionen mit AWS IoT Greengrass

funktionieren, für optimale Sicherheit und Leistung empfehlen wir jedoch Version 4.4 oder höher. Diemindestens erforderliche Version ist 3.17.

• GNU-C-Bibliothek (glibc) Version 2.14 oder höher. OpenWrt-Distributionen benötigen die musl-C-Bibliothek ab Version 1.1.16.

• Das Verzeichnis /var/run muss auf dem Gerät vorhanden sein.• Die Dateien /dev/stdin, /dev/stdout und /dev/stderr müssen verfügbar sein.• Der Hard- und Softlink-Schutz muss auf dem Gerät aktiviert sein. Andernfalls kann AWS IoT

Greengrass nur im unsicheren Modus mit dem Flag -i ausgeführt werden.• Die folgenden Linux-Kernel-Konfigurationen müssen auf dem Gerät aktiviert sein:

• Namespace: CONFIG_IPC_NS, CONFIG_UTS_NS, CONFIG_USER_NS, CONFIG_PID_NS.• Cgroups: CONFIG_CGROUP_DEVICE, CONFIG_CGROUPS, CONFIG_MEMCG. Der

Kernel muss cgroups unterstützen. Für die Ausführung von AWS IoT Greengrass mitContainern (p. 186) gelten folgende Anforderungen:• Die Speicher-cgroup muss aktiviert und gemountet sein, damit AWS IoT Greengrass die

Speichergrenze für Lambda-Funktionen festlegen kann.• Die Geräte-cgroup muss aktiviert und gemountet sein, wenn Lambda-Funktionen mit Local

Resource Access (p. 204) zum Öffnen von Dateien auf dem AWS IoT Greengrass-Core-Gerätverwendet werden.

12

https://downloads.raspberrypi.org/raspbian/images/raspbian-2018-06-29/


https://www.archlinux.org/


https://www.gnu.org/software/libc/

https://www.musl-libc.org/download.html

https://www.musl-libc.org/download.html

https://en.wikipedia.org/wiki/Cgroups


• Sonstiges: CONFIG_POSIX_MQUEUE, CONFIG_OVERLAY_FS,CONFIG_HAVE_ARCH_SECCOMP_FILTER, CONFIG_SECCOMP_FILTER, CONFIG_KEYS,CONFIG_SECCOMP

• Das Stammzertifikat für Amazon S3 und AWS IoT muss im vertrauenswürdigen Speicher desSystems vorhanden sein.

• Bibliotheken, die den AWS Lambda runtime unterstützen, der von den Lambda-Funktionenbenötigt wird, die Sie lokal ausführen möchten. Erforderliche Bibliotheken müssen auf dem Coreinstalliert und zur PATH-Umgebungsvariablen hinzugefügt werden. Auf einem Core können mehrereBibliotheken installiert werden.• Python Version 2.7 für Funktionen, die die Laufzeit Python 2.7 verwenden.• Python Version 3.7 für Funktionen, die die Laufzeit Python 3.7 verwenden.• Node.js Version 6.10 oder höher für Funktionen, die die Laufzeit Node.js 6.10 verwenden.• Node.js Version 8.10 oder höher für Funktionen, die die Laufzeit Node.js 8.10 verwenden.• Java Version 8 oder höher für Funktionen, die die Laufzeit Java 8 verwenden.

Note

Das Ausführen von Java auf einer OpenWrt-Verteilung wird offiziell nicht unterstützt.Wenn Ihr OpenWrt-Build jedoch über Java-Support verfügt, sind Sie möglicherweise inder Lage, in Java erstellte Lambda-Funktionen auf Ihren OpenWrt-Geräten auszuführen.

• Die folgenden Shell-Befehle (nicht die BusyBox-Varianten) werden vom Over the Air (OTA)-Update-Agent (p. 159) erfordert: wget, realpath, bash, tar, readlink, basename, dirname, pidof,df, grep und umount.

GGC v1.8

• Unterstützte Plattformen:• Architektur: ARMv7l; Betriebssystem: Linux; Verteilung: Raspbian Stretch, 2018-06-29. Andere

Versionen funktionieren zwar mit AWS IoT Greengrass, diese wird jedoch als offiziell unterstützteVerteilung empfohlen.

• Architektur: x86_64; Betriebssystem: Linux; Verteilung: Amazon Linux (amzn-ami-hvm-2016.09.1.20170119-x86_64-ebs), Ubuntu 14.04 – 16.04

• Architektur: ARMv8 (AArch64); Betriebssystem: Linux; Verteilung: Arch Linux• Windows-, macOS- und Linux-Plattformen können AWS IoT Greengrass in einem Docker-

Container ausführen. Weitere Informationen finden Sie unter the section called “Ausführen vonAWS IoT Greengrass in einem Docker-Container” (p. 192).

• Linux-Plattformen können AWS IoT Greengrass mithilfe von Greengrass Snap miteingeschränkten Funktionen ausführen, das über Snapcraft verfügbar ist. Weitere Informationenfinden Sie unter the section called “AWS IoT Greengrass Snap Software” (p. 18).

• Die folgenden Elemente sind erforderlich:• Mindestens 128 MB RAM, zugewiesen zum AWS IoT Greengrass-Core-Gerät.• Linux-Kernel Version 4.4 oder höher: Es können zwar frühere Versionen mit AWS IoT Greengrass

funktionieren, für optimale Sicherheit und Leistung empfehlen wir jedoch Version 4.4 oder höher.Die mindestens erforderliche Version ist 3.17.

• GNU-C-Bibliothek (glibc) Version 2.14 oder höher.• Das Verzeichnis /var/run muss auf dem Gerät vorhanden sein.• Die Dateien /dev/stdin, /dev/stdout und /dev/stderr müssen verfügbar sein.• Der Hard- und Softlink-Schutz muss auf dem Gerät aktiviert sein. Andernfalls kann AWS IoT

Greengrass nur im unsicheren Modus mit dem Flag -i ausgeführt werden.• Die folgenden Linux-Kernel-Konfigurationen müssen auf dem Gerät aktiviert sein:

• Namespace: CONFIG_IPC_NS, CONFIG_UTS_NS, CONFIG_USER_NS, CONFIG_PID_NS.13

https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html

https://www.python.org/


https://www.nodejs.org/


http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html


https://snapcraft.io/aws-iot-greengrass



• Cgroups: CONFIG_CGROUP_DEVICE, CONFIG_CGROUPS, CONFIG_MEMCG. DerKernel muss cgroups unterstützen. Für die Ausführung von AWS IoT Greengrass mitContainern (p. 186) gelten folgende Anforderungen:• Die Speicher-cgroup muss aktiviert und gemountet sein, damit AWS IoT Greengrass die

Speichergrenze für Lambda-Funktionen festlegen kann.• Die Geräte-cgroup muss aktiviert und gemountet sein, wenn Lambda-Funktionen mit Local

Resource Access (p. 204) zum Öffnen von Dateien auf dem AWS IoT Greengrass-Core-Gerät verwendet werden.

• Sonstiges: CONFIG_POSIX_MQUEUE, CONFIG_OVERLAY_FS,CONFIG_HAVE_ARCH_SECCOMP_FILTER, CONFIG_SECCOMP_FILTER, CONFIG_KEYS,CONFIG_SECCOMP

• Das Stammzertifikat für Amazon S3 und AWS IoT muss im vertrauenswürdigen Speicher desSystems vorhanden sein.

• Die folgenden Elemente sind zwingend erforderlich:• Bibliotheken, die den AWS Lambda runtime unterstützen, der von den Lambda-Funktionen

benötigt wird, die Sie lokal ausführen möchten. Erforderliche Bibliotheken müssen auf dem Coreinstalliert und zur PATH-Umgebungsvariablen hinzugefügt werden. Auf einem Core könnenmehrere Bibliotheken installiert werden.• Python Version 2.7 für Funktionen, die die Laufzeit Python 2.7 verwenden.• Node.js Version 6.10 oder höher für Funktionen, die die Laufzeit Node.js 6.10 verwenden.• Java Version 8 oder höher für Funktionen, die die Laufzeit Java 8 verwenden.

• Die folgenden Shell-Befehle (nicht die BusyBox-Varianten) werden vom Over the Air (OTA)-Update-Agent (p. 159) erfordert: wget, realpath, tar, readlink, basename, dirname,pidof, df, grep und umount.

GGC v1.7

• Unterstützte Plattformen:• Architektur: ARMv7l; Betriebssystem: Linux; Verteilung: Raspbian Stretch, 2018-06-29. Mit AWS

IoT Greengrass können zwar mehrere Versionen verwendet werden, dies wird jedoch als offiziellunterstützte Verteilung empfohlen.

• Architektur: x86_64; Betriebssystem: Linux; Verteilung: Amazon Linux (amzn-ami-hvm-2016.09.1.20170119-x86_64-ebs), Ubuntu 14.04 – 16.04

• Architektur: ARMv8 (AArch64); Betriebssystem: Linux; Verteilung: Arch Linux• Windows-, macOS- und Linux-Plattformen können AWS IoT Greengrass in einem Docker-

Container ausführen. Weitere Informationen finden Sie unter the section called “Ausführen vonAWS IoT Greengrass in einem Docker-Container” (p. 192).

• Die folgenden Elemente sind erforderlich:• Mindestens 128 MB RAM, zugewiesen zum AWS IoT Greengrass-Core-Gerät.• Linux-Kernel Version 4.4 oder höher: Es können zwar verschiedene Versionen mit AWS IoT

Greengrass funktionieren, für optimale Sicherheit und Leistung empfehlen wir jedoch Version 4.4oder höher. Die mindestens erforderliche Version ist 3.17.

• Glibc-Bibliothek, Version 2.14 oder höher.• Das Verzeichnis /var/run muss auf dem Gerät vorhanden sein.• AWS IoT Greengrass erfordert die Aktivierung des Hardlink- und Softlink-Schutzes auf dem Gerät.

Ohne diesen kann AWS IoT Greengrass nur im unsicheren Modus mit dem Marker -i ausgeführtwerden.

• Die Benutzer ggc_user und die Gruppe ggc_group müssen beide auf dem Gerät vorhandensein.

• Die folgenden Linux-Kernel-Konfigurationen müssen auf dem Gerät aktiviert sein:14


https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html






AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass-Downloads

• Namespace: CONFIG_IPC_NS, CONFIG_UTS_NS, CONFIG_USER_NS, CONFIG_PID_NS• CGroups: CONFIG_CGROUP_DEVICE, CONFIG_CGROUPS, CONFIG_MEMCG• Sonstiges: CONFIG_POSIX_MQUEUE, CONFIG_OVERLAY_FS,

CONFIG_HAVE_ARCH_SECCOMP_FILTER, CONFIG_SECCOMP_FILTER, CONFIG_KEYS,CONFIG_SECCOMP

• /dev/stdin, /dev/stdout und /dev/stderr müssen aktiviert sein.• Der Linux-Kernel muss cgroups unterstützen.• Der Speicher cgroup muss aktiviert und gemountet sein, damit AWS IoT Greengrass die

Speichergrenze für Lambda-Funktionen festlegen kann.• Das Stammzertifikat für Amazon S3 und AWS IoT muss im vertrauenswürdigen Speicher des

Systems vorhanden sein.• Die folgenden Elemente sind optional:

• Die Geräte cgroup müssen aktiviert und gemountet sein, wenn Lambda-Funktionen mit LocalResource Access (LRA) (p. 204) zum Öffnen von Dateien auf dem AWS IoT Greengrass-Core-Gerät verwendet werden.

• Python Version 2.7 ist erforderlich, wenn Python Lambda-Funktionen verwendet werden. Wenndies der Fall ist, stellen Sie sicher, dass es Ihrer PATH-Umgebungsvariablen hinzugefügt ist.

• NodeJS Version 6.10 oder höher ist erforderlich, wenn Node.JS Lambda-Funktionen verwendetwerden. Wenn dies der Fall ist, stellen Sie sicher, dass es Ihrer PATH-Umgebungsvariablenhinzugefügt ist.

• Java Version 8 oder höher ist erforderlich, wenn Java Lambda-Funktionen verwendet werden.Wenn dies der Fall ist, stellen Sie sicher, dass es Ihrer PATH-Umgebungsvariablen hinzugefügt ist.

• Die folgenden Befehle sind für Greengrass OTA-Update-Agent (p. 159) erforderlich: wget,realpath, tar, readlink, basename, dirname, pidof, df, grep und umount.

AWS IoT Greengrass-DownloadsSie können die folgenden Informationen zum Suchen und Herunterladen von Software für die Verwendungmit AWS IoT Greengrass einsehen.

AWS IoT Greengrass Core-SoftwareDie AWS IoT Greengrass Core-Software überträgt die AWS-Funktionalität auf ein AWS IoT Greengrass-Core-Gerät, damit lokale Geräte lokal mit den von ihnen generierten Daten agieren können.

v1.9.2

Neue Funktionen in Version 1.9:

• Unterstützung für Lambda-Laufzeiten Python 3.7 und Node.js 8.10. Lambda-Funktionen mitLaufzeiten Python 3.7 und Node.js 8.10 können jetzt auf AWS IoT Greengrass-Core ausgeführtwerden. (AWS IoT Greengrass unterstützt weiterhin die Laufzeiten Python 2.7 und Node.js 6.10.)

• Optimierte MQTT-Verbindungen. Der Greengrass Core baut weniger Verbindungen mit dem AWSIoT Core auf. Diese Änderung kann Betriebskosten hinsichtlich Gebühren, die auf der Anzahl derVerbindungen basieren, senken.

• Elliptic Curve (EC)-Schlüssel für den lokalen MQTT-Server. Der lokale MQTT-Server unterstütztEC-Schlüssel zusätzlich zu den RSA-Schlüsseln. (Das MQTT-Serverzertifikat verfügt über eineSHA-256-RSA-Signatur, unabhängig vom Schlüsseltyp.) Weitere Informationen finden Sie unter thesection called “Sicherheitsprinzipale” (p. 428).

• Unterstützung für OpenWrt. Die AWS IoT Greengrass Core-Software v1.9.2 kann auf OpenWrt-Verteilungen mit ARMv8- (AArch64-) und ARMv7l-Architekturen installiert werden. Derzeit unterstütztOpenWrt die ML-Inferenz nicht.

15







Zum Installieren der AWS IoT Greengrass Core-Software auf Ihrem Core-Gerät laden Sie das Paketfür Ihre Architektur, Verteilung und Ihr Betriebssystem (OS) herunter und führen dann die Schritte imHandbuch Erste Schritte (p. 69) aus.

Architektur Verteilung OS Link

ARMv8 (AArch64) Ubuntu 18.04 Linux Herunterladen

ARMv8 (AArch64) OpenWrt Linux Herunterladen

ARMv7l Raspbian Linux Herunterladen

ARMv7l OpenWrt Linux Herunterladen

x86_64 Linux Linux Herunterladen

v1.8.3

• Neue Funktionen:• Konfigurierbare Standardzugriffsidentität für Lambda-Funktionen in der Gruppe. Diese Einstellung

auf Gruppenlevel bestimmt die Standardberechtigungen, die zum Ausführen von Lambda-Funktionen verwendet werden. Sie können die Benutzer-ID, Gruppen-ID oder beides festlegen.Einzelne Lambda-Funktionen können die Standardzugriffsidentität ihrer Gruppe überschreiben.Weitere Informationen finden Sie unter the section called “Festlegen der Standardzugriffsidentitätfür Lambda-Funktionen in einer Gruppe” (p. 185).

• HTTPS-Datenverkehr über Port 443. HTTPS-Kommunikation kann so konfiguriert werden, dasssie über Port 443 anstatt über Standard-Port 8443 ausgeführt wird. Dies ergänzt die AWS IoTGreengrass-Unterstützung für die Application Layer Protocol Network (ALPN) TLS-Erweiterungund ermöglicht dem gesamten Greengrass-Messaging-Datenverkehr – MQTT und HTTPS– die Verwendung von Port 443. Weitere Informationen finden Sie unter the section called“Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy” (p. 49).

• Client-IDs mit vorhersagbarem Namen für AWS IoT Verbindungen. Diese Änderungermöglicht die Unterstützung für Lebenszyklus-Ereignisse AWS IoT Device Defender undAWS IoT, damit Sie Benachrichtigungen für Verbindungs-, Abmelde-, Abonnement- undAbonnementbeendungsereignisse erhalten. Die vorhersehbare erleichtert auch die das Erstellenvon Logik zu Verbindungs-IDs (z. B. zum Erstellen von Vorlagen für eine Abonnieren-Richtliniebasierend auf Zertifikatattributen). Weitere Informationen finden Sie unter the section called“Client-IDs für MQTT-Verbindungen mit AWS IoT” (p. 61).




ARMv8 (AArch64) Ubuntu 14.04 – 16.04 Linux Herunterladen



16

https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/greengrass-linux-aarch64-1.9.2.tar.gz

https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/greengrass-openwrt-aarch64-1.9.2.tar.gz

https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/greengrass-linux-armv7l-1.9.2.tar.gz

https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/greengrass-openwrt-armv7l-1.9.2.tar.gz

https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/greengrass-linux-x86-64-1.9.2.tar.gz








v1.7.1

• Neue Funktionen:• Greengrass-Konnektoren, die eine eingebaute Integration mit der lokalen Infrastruktur,

Geräteprotokollen, AWS und anderen Cloud-Services ermöglichen. Weitere Informationen findenSie unter Integrieren von Services und Protokollen mit Konnektoren (p. 297).

• AWS IoT Greengrass erweitert AWS Secrets Manager auf Core-Geräte, wodurch Ihre Passwörter,Token und andere Secrets Konnektoren und Lambda-Funktionen zur Verfügung stehen. Secretswerden während der Übertragung und im Ruhezustand verschlüsselt. Weitere Informationenfinden Sie unter Secrets für Core bereitstellen (p. 274).

• Unterstützung für eine Hardware-Root of Trust Sicherheitsoption. Weitere Informationen finden Sieunter the section called “Hardware-Sicherheit” (p. 435).

• Isolations- und Berechtigungseinstellungen, die es Lambda-Funktionen ermöglichen, ohneGreengrass-Container zu arbeiten und die Berechtigungen eines bestimmten Benutzers und einerbestimmten Gruppe zu verwenden. Weitere Informationen finden Sie unter the section called“Steuern der Greengrass Lambda-Funktionsausführung” (p. 179).

• Sie können AWS IoT Greengrass in einem Docker-Container (unter Windows, macOS oderLinux) ausführen, indem Sie Ihre Greengrass-Gruppe für die Ausführung ohne Containerisierungkonfigurieren. Weitere Informationen finden Sie unter the section called “Ausführen von AWS IoTGreengrass in einem Docker-Container” (p. 192).

• MQTT-Messaging auf Port 443 mit Application Layer Protocol Negotiation (ALPN) oder dieVerbindung über einen Netzwerk-Proxy. Weitere Informationen finden Sie unter the section called“Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy” (p. 49).

• Die Amazon SageMaker Neo Deep Learning-Laufzeit, die Machine-Learning-Modelle unterstützt,die durch den Amazon SageMaker Neo Deep Learning-Compiler optimiert wurden. WeitereInformationen zur Neo Deep Learning-Laufzeit finden Sie unter the section called “Laufzeiten undvorkompilierte Framework-Bibliotheken für ML-Inferenz” (p. 230).

• Unterstützung für Raspbian Stretch (2018-06-27) auf Raspberry Pi Core Geräten.


Darüber hinaus sind mit dieser Version die folgenden Funktionen verfügbar:• Der AWS IoT Device Tester für AWS IoT Greengrass, mit dem Sie überprüfen können, ob Ihre

CPU-Architektur, Kernel-Konfiguration und Treiber mit AWS IoT Greengrass funktionieren.Weitere Informationen finden Sie unter Verwendung des AWS IoT Device Testers für AWS IoTGreengrass (p. 470).

• Die AWS IoT Greengrass Core-Software und die AWS IoT GreengrassCore-SDK- und AWS IoTGreengrass Machine Learning SDK-Pakete sind zum Herunterladen über Amazon CloudFrontverfügbar. Weitere Informationen finden Sie unter the section called “AWS IoT Greengrass-Downloads” (p. 15).



ARMv8 (AArch64) Ubuntu 14.04 – 16.04 Linux Herunterladen



17




AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Snap Software

Indem Sie diese Software herunterladen, stimmen Sie der Lizenzvereinbarung für die Greengrass Core-Software zu.

AWS IoT Greengrass Snap SoftwareDerzeit ist die AWS IoT Greengrass Snap-Software nur für die AWS IoT Greengrass-Core-Version 1.8verfügbar.

Der AWS IoT Greengrass Snap Software-Download ermöglicht Ihnen die Ausführung mit eingeschränktemFunktionsumfang von AWS IoT Greengrass in Linux-Cloud-, Desktop- und IoT-Umgebungen überpraktische Softwarepakete in Containern. Diese Pakete oder Snaps enthalten die AWS IoT Greengrass-Software und die zugehörigen Abhängigkeiten. Sie können diese Pakete herunterladen und in Ihrer Linux-Umgebung wie gewohnt verwenden.

AWS IoT Greengrass Snap wird automatisch mit neuen Versionen der AWS IoT Greengrass-Core-Softwareund den zugehörigen Abhängigkeiten aktualisiert. Sie können diese automatischen Updates jederzeitdeaktivieren.

Note

Der AWS IoT Greengrass-Snap ermöglicht Ihnen das Ausführen einer Version von AWS IoTGreengrass mit eingeschränkten Funktionen in Ihren Linux-Umgebungen. Derzeit werden Java,Node.js und native Lambda-Funktionen nicht unterstützt. Machine Learning Inferenz, Konnektorenund nicht containerisierte Lambda-Funktionen werden ebenfalls nicht unterstützt.

Erste Schritte mit AWS IoT Greengrass SnapDa die vorgefertigte AWS IoT Greengrass Snap-Software so konzipiert ist, dass sie Systemstandardwerteverwendet, müssen Sie möglicherweise diese anderen Schritte ausführen:

• Die AWS IoT Greengrass Snap-Software ist so konfiguriert, dass standardmäßige Greengrass-Benutzer- und Gruppenkonfigurationen verwendet werden. Auf diese Weise können Sie einfach mitGreengrass-Gruppen oder Lambda-Funktionen arbeiten, die als root ausgeführt werden. Falls SieGreengrass-Gruppen oder Lambda-Funktionen verwenden müssen, die nicht als root ausgeführt werden,aktualisieren Sie diese Konfigurationen und fügen Sie sie Ihrem System hinzu.

• AWS IoT Greengrass Snap verwendet viele Schnittstellen, die verbunden sein müssen, damit dieSoftware normal ausgeführt werden kann. Diese Schnittstellen werden während der Einrichtungautomatisch verbunden. Wenn Sie andere Optionen verwenden, während Sie Snap einrichten, müssenSie diese Schnittstellen möglicherweise manuell verbinden.

Weitere Informationen über AWS IoT Greengrass Snap und diese Änderungen finden Sie unter GreengrassSnap Release Notes.

1. Installieren und aktualisieren Sie Snap, indem Sie den folgenden Befehl im Terminal Ihres Gerätsausführen:

sudo apt-get update && sudo apt-get upgrade snapd

2. Falls Sie Greengrass-Gruppen oder Lambda-Funktionen verwenden müssen, die nicht als Rootausgeführt werden, aktualisieren Sie Ihren standardmäßigen Greengrass-Benutzer und die Gruppen-Konfigurationen und fügen diese Ihrem System hinzu. Weitere Informationen zum Aktualisieren vonBenutzer- und Gruppen-Konfigurationen mit AWS IoT Greengrass finden Sie unter ??? (p. 185).

• Für das Ubuntu Core-System:

18

https://s3-us-west-2.amazonaws.com/greengrass-release-license/greengrass-license-v1.pdf


https://assets.ubuntu.com/v1/15d52dd3-greengrass-snap-release-notes.pdf


AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Snap Software

• Um den ggc_user-Benutzer hinzuzufügen, verwenden Sie:

sudo adduser --extrausers --system ggc_user

• Um die ggc_group-Gruppe hinzuzufügen, verwenden Sie:

sudo addgroup --extrausers --system ggc_group

• Für das Ubuntu Classic-System:• Zum Hinzufügen des ggc_user-Benutzers zu einem klassischen Ubuntu-System lassen Sie das

Flag --extrausers aus und verwenden:

sudo adduser --system ggc_user

• Zum Hinzufügen des ggc_group-Benutzers zu einem klassischen Ubuntu-System lassen Sie dasFlag --extrausers aus und verwenden:

sudo addgroup --system ggc_group

3. Führen Sie in Ihrem Terminal den folgenden Befehl zum Installieren des Greengrass-Snap aus:

sudo snap install aws-iot-greengrass

Note

Sie können auch den AWS IoT Greengrass-Snap-Download-Link verwenden, um GreengrassSnap lokal zu installieren. Bei lokaler Installation von dieser Datei aus ohne die zugehörigenAussagen verwenden Sie das Flag --dangerous:

sudo snap install --dangerous aws-iot-greengrass*.snap

Das Flag --dangerous beeinträchtigt die AWS IoT Greengrass Snap-Verbindung miterforderlichen Schnittstellen. Wenn Sie dieses Flag verwenden, müssen Sie die erforderlichenSchnittstellen manuell über den Befehl snap connect verbinden. Weitere Informationen findenSie unter Greengrass Snap Release Notes.

4. Nach der Installation von Snap führen Sie den folgenden Befehl aus, um Ihr Greengrass-Zertifikat undKonfigurationsdateien hinzuzufügen:

sudo snap set aws-iot-greengrass gg-certs=/path-to-the-certs/22e592db.tgz

Note

Falls erforderlich, können Sie Probleme mithilfe der AWS IoT Greengrass-Core-Protokollebeheben, insbesondere runtime.log. Sie können den Inhalt von runtime.log auf IhremTerminal ausgeben, indem Sie den folgenden Befehl ausführen:

sudo cat /var/snap/aws-iot-greengrass/current/ggc-writable/var/log/system/runtime.log

5. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihre Einrichtung korrekt funktioniert:

$ snap services aws-iot-greengrass

Sie sollten die folgende Antwort sehen: 19


AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Docker-Software

Service Startup Current Notesaws-iot-greengrass.greengrassd enabled active -

Ihre Greengrass-Einrichtung ist jetzt abgeschlossen. Sie können jetzt die AWS IoT Greengrass-Konsole,AWS-REST-API oder AWS CLI verwenden, um die Greengrass-Gruppen bereitzustellen, die diesemSnap zugeordnet sind. Informationen zur Verwendung der Konsole zum Bereitstellen einer Greengrass-Gruppe finden Sie unter Bereitstellen von Cloud-Konfigurationen für ein AWS IoT Greengrass Core-Gerät.Informationen zur Verwendung der CLI- oder REST-API zum Bereitstellen einer Greengrass-Gruppe findenSie unter CreateDeployment in der AWS IoT Greengrass-API-Referenz.

Weitere Informationen zum Konfigurieren des Zugriffs auf lokale Ressourcen mit Snap AppArmor-Einschränkung unter Verwendung der snapd-REST-API und zum Konfigurieren von Snap-Schnittstellenfinden Sie unter Greengrass Snap Release Notes.

AWS IoT Greengrass Docker-SoftwareAWS stellt ein Dockerfile und Docker-Image zur Verfügung, mit deren Hilfe Sie AWS IoT Greengrassleichter in einem Docker-Container ausführen können.

Dockerfile

Der Quellcode zum Erstellen benutzerdefinierter AWS IoT Greengrass-Container-Images. Das Abbildkann so geändert werden, dass es auf unterschiedlichen Plattformarchitekturen ausgeführt werdenkann. Es kann auch verkleinert werden. Weitere Anweisungen finden Sie in der README-Datei.

Wählen Sie die AWS IoT Greengrass Core-Software-Version.v1.9.2

• Docker v1.9.2.v1.8.1

• Docker v1.8.1.v1.7.1

• Docker v1.7.1.

Docker-Image

Docker-Image, auf dem AWS IoT Greengrass Core-Software und Abhängigkeiten installiert sind.Vorkonfigurierte Images können Ihnen die ersten Schritte erleichtern und dabei helfen, mit AWS IoTGreengrass zu experimentieren.• Docker-Image von Docker Hub.• Docker-Image von Amazon Elastic Container Registry (Amazon ECR). Weitere Informationen

finden Sie unter the section called “Ausführen von AWS IoT Greengrass in einem Docker-Container” (p. 192).

Indem Sie diese Software herunterladen, stimmen Sie der Lizenzvereinbarung für die Greengrass Core-Software zu.

20

https://docs.aws.amazon.com/greengrass/latest/developerguide/configs-core.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createdeployment-post.html


https://d1onfpft10uf5o.cloudfront.net/greengrass-core/downloads/1.9.2/aws-greengrass-docker-1.9.2.tar.gz



https://hub.docker.com/r/amazon/aws-iot-greengrass



AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Core-SDK-Software

AWS IoT Greengrass Core-SDK-SoftwareLambda-Funktionen verwenden das AWS IoT GreengrassCore-SDK zur lokalen Interaktion mit dem AWSIoT Greengrass-Core. Dies ermöglicht bereitgestellten Lambda-Funktionen Folgendes:

• Austauschen von MQTT-Nachrichten mit AWS IoT.• Austauschen von MQTT-Nachrichten mit Konnektoren, Geräten und anderen Lambda-Funktionen in der

Greengrass-Gruppe.• Interagieren mit dem lokalen Shadow-Service.• Aufrufen von anderen lokalen Lambda-Funktionen.• Zugreifen auf geheime Ressourcen (p. 274).

Herunterladen des AWS IoT GreengrassCore-SDK für Ihre Sprache oder Plattform von GitHub.

• AWS IoT GreengrassCore-SDK für Java• AWS IoT GreengrassCore-SDK für Node.js• AWS IoT Greengrass-Core-SDK für Python• AWS IoT Greengrass Core-SDK für C

Wenn Sie Python-Lambda-Funktionen ausführen, können Sie auch pip verwenden, um das AWS IoTGreengrass-Core-SDK für Python auf dem Core-Gerät zu installieren. Anschließend können Sie IhreFunktionen bereitstellen, ohne das SDK im Lambda-Funktionsbereitstellungspaket einschließen zumüssen. Weitere Informationen finden Sie unter greengrasssdk.

Note

Um pip zum Installieren des Python SDK zu verwenden, führen Sie in Ihrem Core-Geräte-Terminal den folgenden Befehl aus.

pip install greengrasssdk

AWS IoT Greengrass Machine Learning-Laufzeitenund vorkompilierte BibliothekenLaufzeiten und Bibliotheken für das Machine Learning sind erforderlich, damit Ihre ML-Modelle Inferenz aufGreengrass-Geräten durchführen können.

Laden Sie den Modelltyp für Ihre Plattform herunter.

Raspberry Pi

Wählen Sie den Download-Link für Ihren Modelltyp aus.

Mit dem Herunterladen dieser Software erklären Sie sich mit der zugehörigen Lizenz einverstanden.

Modelltyp Version License Link

MXNet 1.2.1 Apache License 2.0 Herunterladen

TensorFlow 1.4.0 Apache License 2.0 Herunterladen

21

https://github.com/aws/aws-greengrass-core-sdk-java/

https://github.com/aws/aws-greengrass-core-sdk-js/

https://github.com/aws/aws-greengrass-core-sdk-python/

https://github.com/aws/aws-greengrass-core-sdk-c/

https://pypi.org/project/pip/

https://pypi.org/project/greengrasssdk/

https://www.apache.org/licenses/LICENSE-2.0

https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/mxnet/ggc-mxnet-v1.2.1-python-raspi.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/tf/greengrass_ML@Edge_TF_v1_4_0_installer_cp27_raspi3_armv7.tar.gz

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass ML SDK Software


Deep LearningRuntime

1.0.0 Greengrass License Herunterladen

Chainer 4.0.0 MIT-Lizenz Herunterladen

Nvidia Jetson TX2









Intel Atom









AWS IoT Greengrass ML SDK SoftwareDas AWS IoT Greengrass Machine Learning SDK (p. 177) ermöglicht es den von Ihnen erstelltenLambda-Funktionen, das auf dem Gerät verfügbare Machine Learning-Modell zu nutzen.

v1.0.0

• Python 2.7.

22


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/dlr/dlr-1.0-py2-armv7l.tar.gz

https://github.com/chainer/chainer/blob/master/LICENSE

https://s3.amazonaws.com/chainer-greengrass-packages/chainer-installer-for-raspi-v4.0.0.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/mxnet/ggc-mxnet-v1.2.1-cu90-python-nvidia-tx2.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/tf/greengrass_ML@Edge_TF_v1_10_1_installer_cp27_cu90_aarch64_nvidia_jetson_tx2.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/dlr/dlr-1.0-py2-cuda90-aarch64.tar.gz


https://s3.amazonaws.com/chainer-greengrass-packages/chainer-installer-for-jetson-v4.0.0.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/mxnet/ggc-mxnet-v1.2.1-python-intel.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/tf/greengrass_ML@Edge_TF_v1_4_0_installer_cp27_intel_mkl_x86_64.tar.gz


https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-installers/dlr/dlr-1.0-py2-opencl-x86_64.tar.gz


https://s3.amazonaws.com/chainer-greengrass-packages/chainer-installer-for-intel-v4.0.0.tar.gz

https://d1onfpft10uf5o.cloudfront.net/greengrass-ml-sdk/downloads/python/2.7/greengrass-machine-learning-python-sdk-1.0.0.tar.gz

AWS IoT Greengrass EntwicklerhandbuchBitte geben Sie uns Feedback

Bitte geben Sie uns FeedbackWir freuen uns über Ihr Feedback. Um Kontakt mit uns aufzunehmen, besuchen Sie das AWS IoTGreengrass-Forum.

Konfigurieren des AWS IoT Greengrass-CoreEin AWS IoT Greengrass-Core ist ein AWS IoT-Objekt (Gerät). Wie andere AWS IoT-Geräte, ist ein Corein der Registrierung vorhanden, verfügt über einen Geräteschatten und verwendet ein Gerätezertifikat,um sich gegenüber AWS IoT zu autorisieren. Das Core-Gerät führt die AWS IoT Greengrass-Core-Software aus. So kann es die lokalen Prozesse für Greengrass-Gruppen verwalten, z. B. Kommunikation,Schattensynchronisierung und Austausch des Tokens.

Die AWS IoT Greengrass Core-Software bietet folgende Funktionalität:



unter Verwendung verwalteter Abonnements.• MQTT-Messaging zwischen dem AWS IoT und Geräten, Connectors und Lambda-Funktionen unter

Verwendung verwalteter Abonnements.• Sichere Verbindungen zwischen Geräten und der Cloud durch Geräteauthentifizierung und Autorisierung.• Lokale Shadow-Synchronisierung von Geräten. Schatten können so konfiguriert werden, dass sie mit der





AWS IoT Greengrass-Core-KonfigurationsdateiDie Konfigurationsdatei für die AWS IoT Greengrass Core-Software ist config.json. Sie befindet sich imVerzeichnis /greengrass-root/config.

Note

greengrass-root steht für den Pfad, unter dem die AWS IoT Greengrass Core-Software aufIhrem Gerät installiert ist. Falls Sie die Software anhand des im Tutorial Erste Schritte (p. 69)beschriebenen Verfahrens installiert haben, handelt es sich hierbei um das Verzeichnis /greengrass.Wenn Sie die Option Easy group creation (Einfache Gruppenerstellung) der AWS IoT Greengrass-Konsole verwenden, wird die Datei config.json auf dem Core-Gerät in einem funktionierendemZustand bereitgestellt.

Sie können den Inhalt dieser Datei mit folgendem Befehl überprüfen:

23

https://forums.aws.amazon.com/forum.jspa?forumID=254


AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass-Core-Konfigurationsdatei

cat /greengrass-root/config/config.json

Im Folgenden sehen Sie ein Beispiel für eine config.json-Datei. Dies ist die Version, die generiert wird,wenn Sie den Core aus AWS IoT Greengrass-Konsole erstellen.

GGC v1.9

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "hash.cert.pem", "keyPath" : "hash.private.key", "thingArn" : "arn:partition:iot:Region:account-id:thing/core-thing-name", "iotHost" : "host-prefix-ats.iot.Region.amazonaws.com", "ggHost" : "greengrass-ats.iot.Region.amazonaws.com", "keepAlive" : 600 }, "runtime" : { "cgroup" : { "useSystemd" : "yes" } }, "managedRespawn" : false, "crypto" : { "principals" : { "SecretsManager" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key" }, "IoTCertificate" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key", "certificatePath" : "file:///greengrass/certs/hash.cert.pem" } }, "caPath" : "file:///greengrass/certs/root.ca.pem" }}

Die config.json-Datei unterstützt die folgenden Eigenschaften:

coreThing

Feld Beschreibung Hinweise

caPath Der Pfad zum AWS IoT-Root-CA, relativ zum Verzeichnis/greengrass-root/certs.

Für Abwärtskompatibilitätmit Versionen vor 1.7.0.Diese Eigenschaft wird beiVorhandensein des Objektscrypto ignoriert.

Note

Stellen Sie sicher,dass Ihre EndpunkteIhrem Zertifikatstypenentsprechen (p. 48).

certPath Der Pfad zum Core-Gerätezertifikat, relativ zumVerzeichnis /greengrass-root/certs.

Für Abwärtskompatibilitätmit Versionen vor 1.7.0.Diese Eigenschaft wird bei

24


Feld Beschreibung HinweiseVorhandensein des Objektscrypto ignoriert.

keyPath Der Pfad zum privatenCore-Schlüssel, relativ zumVerzeichnis /greengrass-root/certs.


thingArn Der Amazon-Ressourcenname(ARN) des AWS IoT-Objekts,das vom AWS IoT Greengrass-Core-Gerät repräsentiert wird.

Sie finden ihn für Ihren Corein der AWS IoT Greengrass-Konsole unter Cores (Kerne)oder mithilfe des awsgreengrass get-core-definition-version CLI-Befehls.

iotHost Ihr AWS IoT-Endpunkt. Sie finden ihn in der AWS IoT-Konsole unter Settings(Einstellungen) oder mithilfedes aws iot describe-endpoint --endpoint-type iot:Data-ATS-CLI-Befehls.

Dieser Befehl gibt den AmazonTrust Services (ATS) Endpunktzurück. Weitere Informationenfinden Sie in der DokumentationServer-Authentifizierung inAWS IoT Core.

Note

Stellen Sie sicher,dass Ihre EndpunkteIhrem Zertifikatstypenentsprechen (p. 48).Stellen Sie sicher,dass Ihre EndpunkteIhrer Regionentsprechen.

25

https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-core-definition-version.html



https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html



https://docs.aws.amazon.com/iot/latest/developerguide/managing-device-certs.html#server-authentication


https://docs.aws.amazon.com/general/latest/gr/rande.html#greengrass_region





ggHost Ihr AWS IoT Greengrass-Endpunkt.

Das ist Ihr iotHost-Endpunkt mit dem durchgreengrass ersetzten Host-Präfix (z. B. greengrass-ats.iot.region.amazonaws.com).Verwenden Sie dieselbe AWS-Region wie iotHost.

Note

Stellen Sie sicher,dass Ihre EndpunkteIhrem Zertifikatstypenentsprechen (p. 48).Stellen Sie sicher,dass Ihre EndpunkteIhrer Regionentsprechen.

iotMqttPort Optional. Die Portnummer fürdie MQTT-Kommunikation mitAWS IoT.

Gültige Werte sind8883 oder 443. DerStandardwert ist 8883. WeitereInformationen finden Sie unterVerbindungsherstellung auf Port443 oder über einen Netzwerk-Proxy (p. 49).

iotHttpPort Optional. Die zum Erstellen vonHTTPS-Verbindungen mit AWSIoT verwendete Portnummer.


ggHttpPort Optional. Die zum Erstellen vonHTTPS-Verbindungen mit demAWS IoT Greengrass-Serviceverwendete Portnummer.


keepAlive Optional. Der MQTT-ZeitraumKeepAlive in Sekunden.

Der gültige Bereich liegtzwischen 30 und 1200Sekunden. Der Standardwert ist600.

networkProxy Optional. Ein Objekt, das einenProxy-Server definiert, mit demeine Verbindung hergestelltwerden soll.

Dabei kann es sich umeinen HTTP- oder HTTPS-Proxy handeln. WeitereInformationen finden Sie unterVerbindungsherstellung auf Port443 oder über einen Netzwerk-Proxy (p. 49).

26





runtime


postStartHealthCheckTimeoutOptional. Die Zeit (inMillisekunden), die derGreengrass-Daemon nachdem Start wartet, bis dieZustandsprüfung beendet ist.

Das Standard-Timeout beträgt30 Sekunden (30.000 ms).

cgroup

useSystemd Gibt an, ob Ihr Gerät systemdverwendet.

Gültige Werte sind yesoder no. Führen Sie dascheck_ggc_dependencies-Skript in Modul 1 (p. 70) aus,um festzustellen, ob Ihr Gerätsystemd verwendet.

crypto

Das crypto-Objekt wurde in v1.7.0 hinzugefügt. Es führt Eigenschaften ein, die die Speicherungprivater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS#11 und lokalegeheime Speicher unterstützen. Weitere Informationen finden Sie unter the section called“Sicherheitsprinzipale” (p. 428), the section called “Hardware-Sicherheit” (p. 435) und Secrets fürCore bereitstellen (p. 274). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder imDateisystem werden unterstützt.


caPath Der absolute Pfad zur AWS IoTRoot CA.

Muss ein Datei-URI imfolgenden Format sein:file:///absolute/path/to/file.

Note


PKCS11

OpenSSLEngine Optional. Der absolute Pfad zurOpenSSL-Engine .so-Datei,um die PKCS#11-Unterstützungunter OpenSSL zu aktivieren.

Muss ein Pfad zu einer Datei imDateisystem sein.

Diese Eigenschaft isterforderlich, wenn Sieden Greengrass-OTA-Aktualisierungsagentmit Hardware-Sicherheitverwenden. WeitereInformationen finden Sie unterthe section called “Konfigurierenvon OTA-Updates” (p. 442).

27

https://en.wikipedia.org/wiki/Systemd



P11Provider Der absolute Pfad zur libdl-ladbaren Bibliothek derPKCS#11-Implementierung.


slotLabel Das Slot-Label, daszur Identifizierung desHardwaremoduls verwendetwird.

Muss den PKCS#11 Label-Spezifikationen entsprechen.

slotUserPin Der Benutzer-Pin, mit demGreengrass Core gegenüberdem Modul authentifiziert wird.

Muss über ausreichendeBerechtigungen verfügen, umC_Sign mit den konfiguriertenprivaten Schlüsselnauszuführen.

principals

IoTCertificate Das Zertifikat und der private Schlüssel, die Core verwendet, umAnfragen AWS IoT zu stellen.

IoTCertificate .privateKeyPath

Der Pfad zum privaten Core-Schlüssel.

Muss für denDateisystemspeicher ein Datei-URI im folgenden Format sein:file:///absolute/path/to/file.

Muss für einen HSM-Speicher ein RFC 7512PKCS#11-Pfad sein, der eineObjektbezeichnung angibt.

IoTCertificate .certificatePath

Der absolute Pfad zum Core-Gerätezertifikat.


MQTTServerCertificate Optional. Der private Schlüssel, den der Kern in Kombination mitdem Zertifikat verwendet, um als MQTT-Server oder Gateway zufungieren.

28

https://tools.ietf.org/html/rfc7512




MQTTServerCertificate .privateKeyPath

Der Pfad zum privatenSchlüssel des lokalen MQTT-Servers.

Verwenden Sie diesen Wert,um einen eigenen privatenSchlüssel für den lokalenMQTT-Server anzugeben.



Wenn diese Eigenschaftweggelassen wird, rotiertAWS IoT Greengrass denSchlüssel basierend auf IhrenRotationseinstellungen. Sofernangegeben, ist der Kunde fürdas Rotieren des Schlüsselsverantwortlich.

SecretsManager Der private Schlüssel, der den für die Verschlüsselungverwendeten Datenschlüssel schützt. Weitere Informationenfinden Sie unter Secrets für Core bereitstellen (p. 274).

SecretsManager .privateKeyPath

Der Pfad zum privatenSchlüssel des lokalen SecretsManagers.

Nur ein RSA-Schlüssel wirdunterstützt.


Muss für einen HSM-Speicher ein RFC 7512PKCS#11-Pfad sein, der eineObjektbezeichnung angibt.Der private Schlüssel musserstellt werden, indem Sieden PKCS#1 v1.5-Padding-Mechanismus verwenden.

Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt:


mqttMaxConnectionRetryIntervalOptional. Das Maximalintervall(in Sekunden) zwischen MQTT-

Geben Sie diesen Wert alsGanzzahl ohne Vorzeichen an.Der Standardwert ist 60.

29







Feld Beschreibung HinweiseVerbindungsversuchen, wenndie Verbindung getrennt wird.

managedRespawn Optional. Gibt an, dass derOTA-Agent vor einem Updateeinen benutzerdefinierten Codeausführen muss.

Gültige Werte sind true oderfalse. Weitere Informationenfinden Sie unter OTA-Updatesder AWS IoT Greengrass Core-Software (p. 158).

writeDirectory Optional. DasSchreibverzeichnis, in demAWS IoT Greengrass alle Lese-Schreib-Ressourcen erstellt.

Weitere Informationen findenSie unter Konfigurieren einesSchreibverzeichnisses für AWSIoT Greengrass (p. 55).

GGC v1.8

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "hash.cert.pem", "keyPath" : "hash.private.key", "thingArn" : "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost" : "host-prefix-ats.iot.Region.amazonaws.com", "ggHost" : "greengrass-ats.iot.Region.amazonaws.com", "keepAlive" : 600 }, "runtime" : { "cgroup" : { "useSystemd" : "yes" } }, "managedRespawn" : false, "crypto" : { "principals" : { "SecretsManager" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key" }, "IoTCertificate" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key", "certificatePath" : "file:///greengrass/certs/hash.cert.pem" } }, "caPath" : "file:///greengrass/certs/root.ca.pem" }}


coreThing




30



Note










Note

Stellen Sie sicher,dass Ihre EndpunkteIhrem Zertifikatstypenentsprechen (p. 48).Stellen Sie sicher,dass Ihre EndpunkteIhrer AWS-Regionentsprechen.

31















Note




iotHttpPort Optional. Die zum Erstellen vonHTTPS-Verbindungen mit AWSIoT verwendete Portnummer.


ggHttpPort Optional. Die zum Erstellen vonHTTPS-Verbindungen mit demAWS IoT Greengrass-Serviceverwendete Portnummer.






32




runtime


cgroup



crypto

Das crypto-Objekt wurde in v1.7.0 hinzugefügt. Es führt Eigenschaften ein, die die Speicherungprivater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS#11 und lokalegeheime Speicher unterstützen. Weitere Informationen finden Sie unter the section called“Sicherheitsprinzipale” (p. 428), the section called “Hardware-Sicherheit” (p. 435) und Secrets fürCore bereitstellen (p. 274). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder imDateisystem werden unterstützt.




Note


PKCS11






slotLabel Das Slot-Label, daszur Identifizierung des


33



Feld Beschreibung HinweiseHardwaremoduls verwendetwird.



principals










34



















mqttMaxConnectionRetryIntervalOptional. Das Maximalintervall(in Sekunden) zwischen MQTT-


35







Feld Beschreibung HinweiseVerbindungsversuchen, wenndie Verbindung getrennt wird.





GGC v1.7

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "hash.cert.pem", "keyPath" : "hash.private.key", "thingArn" : "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost" : "host-prefix-ats.iot.Region.amazonaws.com", "ggHost" : "greengrass-ats.iot.Region.amazonaws.com", "keepAlive" : 600 }, "runtime" : { "cgroup" : { "useSystemd" : "yes" } }, "managedRespawn" : false, "crypto" : { "principals" : { "SecretsManager" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key" }, "IoTCertificate" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key", "certificatePath" : "file:///greengrass/certs/hash.cert.pem" } }, "caPath" : "file:///greengrass/certs/root.ca.pem" }}


coreThing




36



Note










Note


37















Note








runtime


cgroup



crypto

38





Das in v1.7.0 hinzugefügte crypto-Objekt führt Eigenschaften ein, die die Speicherung privaterSchlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS#11 und lokale geheimeSpeicher unterstützen. Weitere Informationen finden Sie unter the section called “Hardware-Sicherheit” (p. 435) und Secrets für Core bereitstellen (p. 274). Konfigurationen für die Speicherungprivater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.




Note


PKCS11






slotLabel Das Slot-Label, daszur Identifizierung desHardwaremoduls verwendetwird.




principals




Muss für denDateisystemspeicher ein Datei-URI im folgenden Format sein:

39


Feld Beschreibung Hinweisefile:///absolute/path/to/file.













40














mqttMaxConnectionRetryIntervalOptional. Das Maximalintervall(in Sekunden) zwischen MQTT-Verbindungsversuchen, wenndie Verbindung getrennt wird.






GGC v1.6

{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost": "host-prefix.iot.Region.amazonaws.com", "ggHost": "greengrass.iot.Region.amazonaws.com", "keepAlive": 600, "mqttMaxConnectionRetryInterval": 60 }, "runtime": { "cgroup": { "useSystemd": "yes|no" }

41





}, "managedRespawn": true, "writeDirectory": "/write-directory"}

Note

Wenn Sie die Option Easy group creation (Einfache Gruppenerstellung) des AWS IoTGreengrass-Konsole verwenden, wird die Datei config.json in einem funktionierendenZustand bereitgestellt, die die Standardkonfiguration angibt.



caPath Der Pfad zum AWS IoT RootCA, relativ zum Verzeichnis/greengrass-root/certs.

Speichern Sie die Datei unter/greengrass-root/certs.

certPath Der Pfad zum AWS IoTGreengrass-Core-Zertifikat,relativ zum Verzeichnis/greengrass-root/certs.


keyPath Der Pfad zum privaten AWS IoTGreengrass-Core-Schlüssel,relativ zum Verzeichnis/greengrass-root/certs.




iotHost Ihr AWS IoT-Endpunkt. Sie finden ihn in der AWS IoT-Konsole unter Settings(Einstellungen) oder mithilfedes aws iot describe-endpoint-CLI-Befehls.


Für diesen Wert wird dasgreengrass.iot.region.amazonaws.com-Format verwendet. VerwendenSie dieselbe Region wieiotHost.

keepAlive Der MQTT-ZeitraumKeepAlive in Sekunden.

Dies ist ein optionaler Wert. DerStandardwert ist 600.

mqttMaxConnectionRetryIntervalDas Maximalintervall (inSekunden) zwischen MQTT-Verbindungsversuchen, wenndie Verbindung getrennt wird.

Geben Sie diesen Wert alsGanzzahl ohne Vorzeichen an.Dies ist ein optionaler Wert. DerStandardwert ist 60.


Gültige Werte sind yesoder no. Führen Sie das

42










Feld Beschreibung Hinweisecheck_ggc_dependencies-Skript in Modul 1 (p. 70) aus,um festzustellen, ob Ihr Gerätsystemd verwendet.

managedRespawn Eine optionale Over-The-Air (OTA)-Updatefunktion;diese gibt an, dass der OTA-Agent vor einem Updatebenutzerdefinierten Codeausführen muss.


writeDirectory Das Schreibverzeichnis, in demAWS IoT Greengrass alle Lese-Schreib-Ressourcen erstellt.

Dies ist ein optionaler Wert.Weitere Informationen findenSie unter Konfigurieren einesSchreibverzeichnisses für AWSIoT Greengrass (p. 55).

GGC v1.5.0

{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost": "host-prefix.iot.Region.amazonaws.com", "ggHost": "greengrass.iot.Region.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }, "managedRespawn": true}

Die Datei config.json befindet sich in /greengrass-root/config und enthält die folgendenParameter:


caPath Der Pfad zum AWS IoTRoot CA, relativ zum Ordner/greengrass-root/certs.

Speichern Sie die Datei imOrdner /greengrass-root/certs.

certPath Der Pfad zum AWSIoT Greengrass-Core-Zertifikat, relativ zum Ordner/greengrass-root/certs.


keyPath Der Pfad zum privatenAWS IoT Greengrass-Core-Schlüssel, relativ zum Ordner/greengrass-root/certs.


43







iotHost Ihr AWS IoT-Endpunkt. Sie finden ihn in der AWS IoT-Konsole unter Settings(Einstellungen) oder durchAusführen des Befehls awsiot describe-endpoint.


Für diesen Wert wird dasgreengrass.iot.region.amazonaws.com-Format verwendet. VerwendenSie dieselbe Region wieiotHost.


Dies ist ein optionaler Wert. DerStandardwert ist 600 Sekunden.




Weitere Informationen findenSie unter OTA-Updates derAWS IoT Greengrass Core-Software (p. 158).

GGC v1.3

{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost": "host-prefix.iot.Region.amazonaws.com", "ggHost": "greengrass.iot.Region.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }, "managedRespawn": true}

44
















thingArn Der Amazon-Ressourcenname(ARN) des AWS IoT-Objekts,das das AWS IoT Greengrass-Core repräsentiert.

Sie finden diesen Wert in derAWS IoT Greengrass-Konsoleunter der Definition für Ihr AWSIoT-Objekt.

iotHost Ihr AWS IoT-Endpunkt. Sie finden diesen Wert inder AWS IoT-Konsole unterSettings (Einstellungen).


Sie finden diesen Wert inder AWS IoT-Konsole unterSettings (Einstellungen) mitvorgestelltem greengrass..



useSystemd Ein Binär-Marker, wenn IhrGerät systemd verwendet.

Die Werte sind yes oderno. Verwenden Sie dasAbhängigkeitenskript inModul 1 (p. 70), umfestzustellen, ob Ihr Gerätsystemd verwendet.


Weitere Informationen findenSie unter OTA-Updates derAWS IoT Greengrass Core-Software (p. 158).

GGC v1.1

{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "arn:aws:iot:Region:account-id:thing/core-thing-name",

45





"iotHost": "host-prefix.iot.Region.amazonaws.com", "ggHost": "greengrass.iot.Region.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }}

















Die Werte sind yes oderno. Verwenden Sie dasAbhängigkeitenskript inModul 1 (p. 70), umfestzustellen, ob Ihr Gerätsystemd verwendet.

GGC v1.0

In AWS IoT Greengrass Core v1.0 wird config.json für greengrass-root/configurationbereitgestellt.

46





{ "coreThing": { "caPath": "root-ca-pem", "certPath": "cloud-pem-crt", "keyPath": "cloud-pem-key", "thingArn": "arn:aws:iot:Region:account-id:thing/core-thing-name", "iotHost": "host-prefix.iot.Region.amazonaws.com", "ggHost": "greengrass.iot.Region.amazonaws.com", "keepAlive": 600 }, "runtime": { "cgroup": { "useSystemd": "yes|no" } }}

Die Datei config.json befindet sich in /greengrass-root/configuration und enthält diefolgenden Parameter:


caPath Der Pfad zum AWS IoTRoot CA, relativ zum Ordner/greengrass-root/configuration/certs.

Speichern Sie die Datei imOrdner /greengrass-root/configuration/certs.

certPath Der Pfad zum AWSIoT Greengrass-Core-Zertifikat, relativ zum Ordner/greengrass-root/configuration/certs.


keyPath Der Pfad zum privatenAWS IoT Greengrass-Core-Schlüssel, relativ zum Ordner/greengrass-root/configuration/certs.










Die Werte sind yes oderno. Verwenden Sie dasAbhängigkeitenskript in

47




AWS IoT Greengrass EntwicklerhandbuchEndpunkte müssen dem Zertifikattyp entsprechen

Feld Beschreibung HinweiseModul 1 (p. 70), umfestzustellen, ob Ihr Gerätsystemd verwendet.

Endpunkte müssen dem Zertifikattyp entsprechenIhre AWS IoT- und AWS IoT Greengrass-Endpunkte müssen dem Zertifikattyp des Stamm-CA-Zertifikatsauf Ihrem Gerät entsprechen.

Wenn Sie ein Amazon Trust Services (ATS)-CA-Stammzertifikat (bevorzugt) verwenden, müssen Sie ATS-Endpunkte verwenden. ATS-Endpunkte beinhalten das ats-Segment, wie in der folgenden Syntax für denAWS IoT-Endpunkt angezeigt.

prefix-ats.iot.Region.amazonaws.com

In einigen AWS-Regionen unterstützt AWS IoT Greengrass derzeit auch Legacy-Verisign-Endpunkteund CA-Stammzertifikate zwecks Abwärtskompatibilität. Weitere Informationen finden Sie unter AWS IoTGreengrass im Allgemeine Amazon Web Services-Referenz.

Wenn Sie ein veraltetes Verisign-CA-Stammzertifikat verwenden, empfehlen wir, dass Sie stattdesseneinen ATS-Endpunkt erstellen und ein ATS-CA-Stammzertifikat verwenden. Weitere Informationen findenSie unter Server-Authentifizierung in der AWS IoT-Entwicklerhandbuch. Andernfalls stellen Sie sicher, dassSie die entsprechenden Legacy-Endpunkte verwenden. Beispiel: Die folgende Syntax wird für Legacy-AWSIoT-Endpunkte verwendet:

prefix.iot.Region.amazonaws.com

Wenn Ihre Endpunkte und der Zertifikatstyp nicht übereinstimmen, schlagen die Authentifizierungsversuchezwischen AWS IoT und AWS IoT Greengrass fehl.

Endpunkte in config.jsonAuf einem AWS IoT Greengrass-Core-Gerät sind in der config.json (p. 23)-Datei die EndpunkteAWS IoT und AWS IoT Greengrass im Objekt coreThing angegeben. Die iotHost-Eigenschaft stehtfür den AWS IoT-Endpunkt. Die ggHost-Eigenschaft steht für den AWS IoT Greengrass-Endpunkt. Imfolgenden Beispiel für einen Ausschnitt legen diese Eigenschaften ATS-Endpunkte fest.

{ "coreThing" : { ... "iotHost" : "abcde1234uwxyz-ats.iot.us-west-2.amazonaws.com", "ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com", ... },

AWS IoT-Endpunkt

Sie erhalten Ihren AWS IoT-Endpunkt, indem Sie den CLI-Befehl aws iot describe-endpoint mit dementsprechenden --endpoint-type-Parameter ausführen.• Um einen ATS-signierten Endpunkt zurückzugeben, führen Sie Folgendes aus.

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

• Um einen veralteten Verisign-signierten Endpunkt zurückzugeben, führen Sie Folgendes aus.

48





AWS IoT Greengrass EntwicklerhandbuchVerbindungsherstellung auf Port 443

oder über einen Netzwerk-Proxy

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

AWS IoT Greengrass-Endpunkt

Für Ihren AWS IoT Greengrass-Endpunkt wird das Host-Präfix Ihres iotHost-Endpunktsdurch greengrass ersetzt. Zum Beispiel lautet der signierte ATS-Endpunkt greengrass-ats.iot.Region.amazonaws.com. Dieser verwendet die gleiche Region wie Ihr AWS IoT-Endpunkt.

Verbindungsherstellung auf Port 443 oder über einenNetzwerk-ProxyDiese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

AWS IoT Greengrass kommuniziert mit AWS IoT unter Verwendung des MQTT-Messaging-Protokollsmit TLS-Client-Authentifizierung. Standardmäßig verwendet MQTT über TLS den Port 8883. Doch alsSicherheitsmaßnahme können restriktive Umgebungen den ein- und ausgehenden Datenverkehr aufeinen kleinen Bereich von TCP-Ports einschränken. Zum Beispiel könnte eine Unternehmens-Firewall Port443 für HTTPS-Datenverkehr öffnen, andere Ports, die für weniger geläufige Protokolle genutzt werden,wie z. B. Port 8883, für MQTT-Datenverkehr schließen. Bei anderen restriktiven Umgebungen muss dergesamte Datenverkehr möglicherweise über einen HTTP-Proxy laufen, der mit dem Internet verbunden ist.

Um die Kommunikation in solchen Fällen zu ermöglichen, erlaubt AWS IoT Greengrass die folgendenKonfigurationen:

• MQTT mit TLS-Client-Authentifizierung über Port 443. Wenn Ihr Netzwerk Verbindungen über Port 443zulässt, können Sie den Core so konfigurieren, dass er anstelle des Standard-Ports 8883 Port 443 fürMQTT-Datenverkehr verwendet. Dabei kann es sich um eine direkte Verbindung mit Port 443 oder eineVerbindung über einen Netzwerk-Proxy-Server handeln.

AWS IoT Greengrass ermöglicht diese Verbindung mittels der Application Layer Protocol Network(ALPN) TLS-Erweiterung. Wie bei der Standardkonfiguration verwendet MQTT über TLS auf Port 443eine zertifikatbasierte Client-Authentifizierung.

• HTTPS-Kommunikation über Port 443. AWS IoT Greengrass sendet HTTPS-Datenverkehrstandardmäßig über Port 8443. Sie können ihn jedoch so konfigurieren, dass er Port 443 verwendet.

• Verbindung über einen Netzwerk-Proxy. Sie können einen Netzwerk-Proxy-Server so konfigurieren,dass er als Vermittler beim Herstellen der Verbindung mit dem AWS IoT Greengrass-Core fungiert. Nurgrundlegende Authentifizierung und HTTP- und HTTPS-Proxys werden unterstützt.

Die Proxy-Konfiguration wird über die Umgebungsvariablen http_proxy, https_proxy undno_proxy an benutzerdefinierte Lambda-Funktionen übergeben. Benutzerdefinierte Lambda-Funktionenmüssen diese übergebenen Einstellungen verwenden, um eine Verbindung über den Proxy herzustellen.Gängige Bibliotheken, die von Lambda-Funktionen verwendet werden, um Verbindungen (wie z. B. boto3oder cURL und Python-requests-Pakete) herzustellen, verwenden diese Umgebungsvariablen in derRegel standardmäßig. Wenn eine Lambda-Funktion auch dieselben Umgebungsvariablen angibt, werdensie von AWS IoT Greengrass nicht außer Kraft gesetzt.

Important

Greengrass-Cores, die so konfiguriert sind, dass sie einen Netzwerk-Proxy verwenden,unterstützen keine Over-the-Air-Aktualisierungen (p. 158).

So konfigurieren Sie MQTT über Port 443

Diese Funktion erfordert AWS IoT Greengrass v1.7 or later.

49




Dieses Verfahren ermöglicht dem Core, Port 443 für MQTT-Messaging zu verwenden.

1. Führen Sie den folgenden Befehl aus, um den AWS IoT Greengrass-Daemon zu beenden:

cd /greengrass-root/ggc/core/ sudo ./greengrassd stop

2. Öffnen Sie greengrass-root/config/config.json zur Bearbeitung als su-Benutzer.3. Fügen Sie im Objekt coreThing die Eigenschaft iotMqttPort hinzu und setzen Sie den Wert auf

443, wie im folgenden Beispiel gezeigt.

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "12345abcde.cert.pem", "keyPath" : "12345abcde.private.key", "thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name", "iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com", "iotMqttPort" : 443, "ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com", "keepAlive" : 600 }, ...}

4. Starten Sie den -Daemon.

cd /greengrass-root/ggc/core/ sudo ./greengrassd start

So konfigurieren Sie HTTPS über Port 443


Dieses Verfahren konfiguriert den Kern so, dass er Port 443 für die HTTPS-Kommunikation verwendet.



2. Öffnen Sie greengrass-root/config/config.json zur Bearbeitung als su-Benutzer.3. Fügen Sie im Objekt coreThing die Eigenschaften iotHttpPort und ggHttpPort hinzu, wie im

folgenden Beispiel dargestellt.

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "12345abcde.cert.pem", "keyPath" : "12345abcde.private.key", "thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name", "iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com", "iotHttpPort" : 443, "ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com", "ggHttpPort" : 443, "keepAlive" : 600 }, ...}

50





So konfigurieren Sie einen Netzwerk-Proxy


Dieses Verfahren ermöglicht AWS IoT Greengrass, eine Internetverbindung über einen HTTP- oderHTTPS-Netzwerk-Proxy herzustellen.



2. Öffnen Sie greengrass-root/config/config.json zur Bearbeitung als su-Benutzer.3. Fügen Sie im Objekt coreThing das Objekt networkProxy (p. 51) hinzu, wie im folgenden Beispiel

gezeigt.

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "12345abcde.cert.pem", "keyPath" : "12345abcde.private.key", "thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name", "iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com", "ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com", "keepAlive" : 600, "networkProxy": { "noProxyAddresses" : "http://128.12.34.56,www.mywebsite.com", "proxy" : { "url" : "https://my-proxy-server:1100", "username" : "Mary_Major", "password" : "pass@word1357" } } }, ...}



networkProxy-Objekt

Geben Sie mithilfe des networkProxy-Objekts Informationen zum Netzwerk-Proxy an. Dieses Objekt hatdie folgenden Eigenschaften.

Feld Beschreibung

noProxyAddresses Optional. Eine durch Komma getrennte Liste vonIP-Adressen oder Host-Namen, die vom Proxyausgeschlossen sind.

51



Feld Beschreibung

proxy Der Proxy, mit dem die Verbindung hergestelltwerden soll. Ein Proxy hat die folgendenEigenschaften.

• url Die URL des Proxy-Servers im Formatscheme://userinfo@host:port.• scheme Das Schema. Es muss sich entweder

um http oder https handeln.• userinfo Optional. Der Benutzername

und die Passwortinformationen. Die Felderusername und password werden ignoriert,sofern angegeben.

• host Der Hostname oder die IP-Adresse desProxy-Servers.

• port Optional. Die Port-Nummer. Wennnicht angegeben, werden die folgendenStandardwerte verwendet:• http: 80• https: 443

• username Optional. Der Benutzername, mitdem die Authentifizierung gegenüber dem Proxy-Server erfolgt.

• password Optional. Das Passwort, das zurAuthentifizierung am Proxy-Server verwendetwird.

Whitelists zu EndpunktenDie Kommunikation zwischen Greengrass-Geräten und AWS IoT oder AWS IoT Greengrass mussauthentifiziert werden. Diese Authentifizierung basiert auf registrierten X.509-Gerätezertifikaten undkryptografischen Schlüsseln. Damit authentifizierte Anfragen ohne zusätzliche Verschlüsselung Proxysdurchlaufen können, müssen Sie die folgenden Endpunkte auf eine Whitelist setzen.

Endpunkt Port Beschreibung

greengrass.Region.amazonaws.com 443 FürOperationenaufSteuerebenefür dieGruppenverwaltung

prefix-ats.iot.Region.amazonaws.com

oder

prefix.iot.Region.amazonaws.com

MQTT: 8883 oder 443

HTTPS: 8443 oder 443

FürOperationenaufDatenebenefür dasGerätemanagement,wie z. B.Schattensynchronisierung

52



Endpunkt Port BeschreibungSetzenSie einenoder beideEndpunkte aufeine Whitelist,je nachdem,ob Ihr Core-und dieverbundenenGeräteAmazon TrustServices-CA-Stammzertifikate(bevorzugt),Legacy-CA-Stammzertfikateoder beidesverwenden.WeitereInformationenfinden Sieunter thesection called“Endpunktemüssen demZertifikattypentsprechen” (p. 48).

53



Endpunkt Port Beschreibung

greengrass-ats.iot.Region.amazonaws.com

oder

greengrass.iot.Region.amazonaws.com

8443 oder 443 FürGeräteerkennungsoperationen

SetzenSie einenoder beideEndpunkte aufeine Whitelist,je nachdem,ob Ihr Core-und dieverbundenenGeräteAmazon TrustServices-CA-Stammzertifikate(bevorzugt),Legacy-CA-Stammzertfikateoder beidesverwenden.WeitereInformationenfinden Sieunter thesection called“Endpunktemüssen demZertifikattypentsprechen” (p. 48).

Note

Clients,dieeineVerbindungaufPort 443einrichten,müssendieTLS-ErweiterungApplicationLayerProtocolNegotiation(ALPN)implementierenundx-amzn-http-ca als

54






AWS IoT Greengrass EntwicklerhandbuchSchreibverzeichnis

Endpunkt Port BeschreibungProtocolNameinProtocolNameListübergeben.WeitereInformationenfindenSieunterProtokolleimAWSIoT-Entwicklerhandbuch.

*.s3.amazonaws.com 443 FürBereitstellungsoperationenund Over-the-Air-Updates.Dieses Formatenthält dasZeichen *, daEndpunktpräfixeinternkontrolliertwerden undsich jederzeitändern können.

logs.Region.amazonaws.com 443 Erforderlich,wenn dieGreengrass-Gruppe sokonfiguriert ist,dass Protokollein CloudWatchgeschriebenwerden.

Konfigurieren eines Schreibverzeichnisses für AWSIoT GreengrassDiese Funktion ist für AWS IoT Greengrass Core v1.6 und höher verfügbar.

Standardmäßig wird die AWS IoT Greengrass Core-Software unter einem einzigen Stammverzeichnisbereitgestellt, in dem AWS IoT Greengrass alle Lese- und Schreiboperationen ausführt. Sie könnenAWS IoT Greengrass allerdings so konfigurieren, dass ein separater Ordner für alle Schreiboperationen,einschließlich der Erstellung von Verzeichnissen und Dateien, verwendet wird. In diesem Fall verwendetAWS IoT Greengrass zwei Top-Level-Verzeichnisse:

• Das greengrass-root-Verzeichnis, das Sie für Lese-/Schreibvorgänge oder optional schreibgeschütztverwenden können. Darin sind die AWS IoT Greengrass Core-Software und andere kritische

55

https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html


3. Fügen Sie writeDirectory als einen Parameter hinzu und geben Sie, wie im folgenden Beispiel,den Pfad zum Zielverzeichnis an.

{ "coreThing": { "caPath": "root-CA.pem", "certPath": "hash.pem.crt", ... }, ... "writeDirectory" : "/write-directory"}

Note

Sie können die writeDirectory-Einstellung so oft aktualisieren, wie Sie möchten.Nachdem die Einstellung aktualisiert wurde, verwendet AWS IoT Greengrass das neuangegebene Schreibverzeichnis beim nächsten Start. Allerdings wird kein Inhalt aus demvorherigen Schreibverzeichnis migriert.

4. Nachdem Ihr Schreibverzeichnis konfiguriert ist, können Sie optional das greengrass-root-Verzeichnis auf schreibgeschützt einstellen. Anweisungen finden Sie unter So wird das Greengrass-Stammverzeichnis auf schreibgeschützt eingestellt (p. 57).

Andernfalls starten Sie den AWS IoT Greengrass-Daemon:

cd /greengrass-root/ggc/core/sudo ./greengrassd start

So aktivieren Sie den Schreibschutz für das Greengrass-Stammverzeichnis

Führen Sie diese Schritte nur aus, wenn das Greengrass-Stammverzeichnis schreibgeschützt sein soll.Das Schreibverzeichnis muss vor Beginn konfiguriert werden.

1. Erteilen Sie Zugriffsberechtigungen für erforderliche Verzeichnisse:

a. Dem config.json-Besitzer Lese- und Schreibberechtigung erteilen.

sudo chmod 0600 /greengrass-root/config/config.json

b. Machen Sie ggc_user zum Besitzer der Zertifikate und System-Lambda-Verzeichnisse.

sudo chown -R ggc_user:ggc_group /greengrass-root/certs/sudo chown -R ggc_user:ggc_group /greengrass-root/ggc/packages/1.9.3/lambda/

Note

Die Konten „ggc_user“ und „ggc_group“ werden standardmäßig zur Ausführung vonLambda-Systemfunktionen verwendet. Wenn Sie die Standardzugriffsidentität (p. 185)auf Gruppenebene konfiguriert haben, um verschiedene Konten zu verwenden, solltenSie stattdessen dem Benutzer (UID) und der Gruppe (GID) Berechtigungen erteilen.

2. Stellen Sie mit Ihrem bevorzugten Mechanismus den Schreibschutz für das greengrass-root-Verzeichnis ein.

57

AWS IoT Greengrass EntwicklerhandbuchNachrichtenqualität des Service

Note

Sie können den Schreibschutz für das greengrass-root-Verzeichnis einstellen, indemSie das Verzeichnis als schreibgeschützt mounten. Zur Anwendung von Over-The-Air (OTA)-Updates für die AWS IoT Greengrass Core-Software in einem aufgespieltenVerzeichnis, muss das Mounting des Verzeichnisses allerdings zunächst aufgehoben undnach der Aktualisierung neu gemountet werden. Sie können diese umount- und mount-Operationen für die ota_pre_update- und ota_post_update-Skripts hinzufügen. WeitereInformationen über OTA-Updates finden Sie unter the section called “Greengrass OTA-Update-Agent” (p. 159) und the section called “AWS IoT Greengrass Core-Aktualisierungmit Managed Respawn” (p. 163).



Wenn die Berechtigungen aus Schritt 1 nicht korrekt festgelegt wurden, wird der Daemon nichtgestartet.

Nachrichtenqualität des ServiceIn der AWS IoT Greengrass-Umgebung können lokale Geräte, Lambda-Funktionen, Konnektoren undSystemkomponenten miteinander und mit der Cloud kommunizieren. Die gesamte Kommunikation läuftüber den Kern. Nachrichten, die für lokale Ziele bestimmt sind, verwenden eine Quality of Service (QoS)-Ebene, die sich von Nachrichten für die Cloud unterscheidet.

• Nachrichten mit lokalen Zielen verwenden QoS 0. Der Kern macht einen Versuch, eine Nachricht an seinZiel zu senden. Es werden keine Nachrichten gespeichert oder die Zustellung bestätigt. Nachrichtenkönnen überall zwischen den Komponenten gelöscht werden.

Note

Obwohl die direkte Kommunikation zwischen Lambda-Funktionen kein MQTT-Messagingverwendet, ist das Verhalten identisch.

• Nachrichten mit Cloud-Zielen verwenden QoS 1. Der Kern sendet diese Nachrichten an die Spooler-Systemkomponente, die sie über QoS 1 an die Cloud sendet. Dies ermöglicht es dem Spooler,die MQTT Nachrichtenwarteschlange (p. ) zu verwalten. Wenn Nachrichtenzustellung nichtdurch AWS IoT bestätigt wird, wird die Nachricht gespoolt, um sie später erneut zu senden (es seidenn, die Warteschlange ist voll). Weitere Informationen finden Sie unter the section called “MQTT-Nachrichtenwarteschlange” (p. 58).

Note

Obwohl QoS 1 intern zur Verwaltung der Warteschlange verwendet wird, könnenNachrichtenverteiler MQTT-Nachrichten nur mit QoS 0 senden.

MQTT-NachrichtenwarteschlangeDie MQTT-Nachrichten für Cloudziele werden bis zur Verarbeitung in die Warteschlange verschoben.Nachrichten in der Warteschlange werden in der FIFO (First-in-First-out)-Reihenfolge verarbeitet. Nachdemeine Nachricht verarbeitet und in der Cloud veröffentlicht wurde, wird sie aus der Warteschlange entfernt.AWS IoT Greengrass verwaltet die Warteschlange mit einer GGCloudSpooler Lambda-Systemfunktion.

58

AWS IoT Greengrass EntwicklerhandbuchMQTT-Nachrichtenwarteschlange

Konfigurieren der MQTT-NachrichtenwarteschlangeDiese Funktion ist für AWS IoT Greengrass Core v1.6 und höher verfügbar.

Sie können AWS IoT Greengrass so konfigurieren, dass nicht verarbeitete Nachrichten im Arbeitsspeicheroder in einem lokalen Speicher-Cache gespeichert werden. Im Gegensatz zu speicherinternem Speicherüberdauert der lokale Speicher-Cache einen Neustart (z. B. nach der Bereitstellung einer Gruppe oder einGeräteneustart), sodass AWS IoT Greengrass die Nachrichten weiter verarbeiten kann. Sie können auchdie Speichergröße konfigurieren.

Note

Versionen 1.5.0 und früher verwenden speicherinternen Speicher mit einer Warteschlangengrößevon 2,5 MB. Sie können keine Speichereinstellungen für frühere Versionen konfigurieren.

Die folgenden Umgebungsvariablen für die GGCloudSpooler Lambda-Funktion werden für die Definitionvon Speichereinstellungen verwendet.

• GG_CONFIG_STORAGE_TYPE. Der Speicherort der Nachrichtenwarteschlange. Die folgenden Wertesind gültig:• FileSystem Speichern Sie nicht verarbeitete Nachrichten im lokalen Speicher-Cache. Wenn der

Core neu gestartet wird, werden Nachrichten in der Warteschlange für die Verarbeitung beibehalten.Nachrichten werden nach der Verarbeitung entfernt.

• Memory (default). Speichern Sie nicht verarbeitete Nachrichten im Arbeitsspeicher. Wenn der Coreneu gestartet wird, gehen Nachrichten in der Warteschlange verloren.

Diese Option sind für Geräte mit eingeschränkten Hardwaremöglichkeiten optimiert. Wenn Sie dieseKonfiguration verwenden, sollten Sie Gruppen bereitstellen oder das Gerät neu starten, wenn dieServiceunterbrechung möglichst gering ist.

• GG_CONFIG_MAX_SIZE_BYTES. Die Speichergröße in Bytes. Dieser Wert kann eine beliebige nichtnegative Ganzzahl größer oder gleich 262144 (256 KB) sein. Eine kleinere Größe verhindert, dass dieAWS IoT Greengrass Core-Software gestartet wird. Die Standardgröße ist 2.5 MB. Wenn die maximaleGröße erreicht ist, werden die ältesten Nachrichten in der Warteschlange durch neue Nachrichtenersetzt.

So speichern Sie Nachrichten im lokalen Speicher

Wenn Sie AWS IoT Greengrass so konfigurieren, dass Nachrichten im Dateisystem zwischengespeichertwerden, damit sie einen Core-Neustart überdauern, erstellen Sie eine Version der Funktionsdefinition,bei der die GGCloudSpooler-Funktion den FileSystem-Speichertyp angibt. Sie müssen den lokalenSpeicher-Cache mit der AWS IoT Greengrass-API konfigurieren. Sie können dies von der Konsole auserledigen.

Im folgenden Verfahren wird mit dem CLI-Befehl create-function-definition-version derSpooler so konfiguriert, dass Nachrichten in der Warteschlange im Dateisystem gespeichert werden.Außerdem wird damit eine Warteschlange mit einer Größe von 2,6 MB konfiguriert.

Note

Bei diesem Verfahren wird davon ausgegangen, dass Sie die Konfiguration auf die neuesteGruppenversion einer vorhandenen Gruppe aktualisieren.

1. Rufen Sie die IDs der Greengrass-Zielgruppen und die Gruppenversion ab.

aws greengrass list-groups

59

https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html

AWS IoT Greengrass EntwicklerhandbuchMQTT-Nachrichtenwarteschlange

Note

Der list-groups Befehl gibt jeweils nur 50 Gruppen zurück. Wenn Sie über mehr als50 Gruppen verfügen, geben Sie in der max-results-Option die gewünschte Anzahl derErgebnisse an (z. B. 100), sodass Sie Ihre Gruppe finden:

aws greengrass list-groups --max-results 100

Note

In der AWS IoT-Konsole finden Sie auch die Gruppen-ID auf der Seite Settings(Einstellungen) und Gruppen-Versions-IDs auf der Seite Deployments (Bereitstellungen).

2. Kopieren Sie die Eigenschaften Id und LatestVersion Ihrer Zielgruppe aus der Ausgabe.3. Rufen Sie die neueste Gruppenversion ab.

• Ersetzen Sie group-id durch die kopierte Id.• Ersetzen Sie latest-group-version-id durch die kopierte LatestVersion.

aws greengrass get-group-version \--group-id group-id \--group-version-id latest-group-version-id

4. Kopieren Sie aus dem Objekt Definition in der Ausgabe den CoreDefinitionVersionArn unddie ARNs aller anderen Gruppenkomponenten außer FunctionDefinitionVersionArn. DieseWerte verwenden Sie, wenn Sie eine neue Gruppenversion erstellen.

5. Kopieren Sie die ID der Funktionsdefinition aus FunctionDefinitionVersionArn. Bei der IDhandelt es sich um die GUID nach dem functions-Segment im ARN.

Note

Sie können optional eine Funktionsdefinition mit dem create-function-definition-Befehl erstellen, und anschließend die ID aus der Ausgabe kopieren.

6. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.

• Ersetzen Sie function-definition-id durch den aus der Funktionsdefinition kopierten Id.• Ersetzen Sie arbitrary-function-id durch einen Namen für die Funktion, wie etwa spooler-function.

• Fügen Sie alle Lambda-Funktionen hinzu, die Sie in diese Version für das functions-Array einschließen möchten. Sie können den get-function-definition-version-Befehl verwenden, um die Greengrass Lambda-Funktionen aus einer vorhandenenFunktionsdefinitionsversion abzurufen.

Warning

Stellen Sie sicher, dass Sie einen Wert für GG_CONFIG_MAX_SIZE_BYTES angeben,der größer als oder gleich 262144 ist. Eine kleinere Größe verhindert, dass die AWS IoTGreengrass Core-Software gestartet wird.

aws greengrass create-function-definition-version \--function-definition-id function-definition-id \--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_MAX_SIZE_BYTES":"2621440","GG_CONFIG_STORAGE_TYPE":"FileSystem"}},"Executable":

60

https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html

AWS IoT Greengrass EntwicklerhandbuchClient-IDs für MQTT-Verbindungen mit AWS IoT

"spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'

7. Kopieren Sie den Arn der Funktionsdefinitionsversion aus der Ausgabe.8. Erstellen Sie eine Gruppenversion, in der die Lambda-Systemfunktion enthalten ist.

• Ersetzen Sie group-id durch die Id für die Gruppe.• Ersetzen Sie core-definition-version-arn durch den aus der neuesten Gruppenversion

kopierten CoreDefinitionVersionArn.• Ersetzen Sie function-definition-version-arn durch den aus der neuen

Funktionsdefinitionsversion kopierten Arn.• Ersetzen Sie die ARNs für andere Gruppenkomponenten (zum BeispielSubscriptionDefinitionVersionArn oder DeviceDefinitionVersionArn), die Sie ausder neuesten Gruppe kopiert haben.

• Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel --resource-definition-version-arn, wenn Ihre Gruppenversion keine Ressourcen enthält.

aws greengrass create-group-version \--group-id group-id \--core-definition-version-arn core-definition-version-arn \--function-definition-version-arn function-definition-version-arn \--device-definition-version-arn device-definition-version-arn \--logger-definition-version-arn logger-definition-version-arn \--resource-definition-version-arn resource-definition-version-arn \--subscription-definition-version-arn subscription-definition-version-arn

9. Kopieren Sie die Version aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.10. Stellen Sie die Gruppe bereit.

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie group-version-id durch die Version, die Sie für die neue Gruppe kopiert haben.

aws greengrass create-deployment \--group-id group-id \--group-version-id group-version-id \--deployment-type NewDeployment

Sie können die Speichereinstellungen mit der AWS IoT Greengrass API aktualisieren, um eine neueVersion der Funktionsdefinition zu erstellen, in der die GGCloudSpooler-Funktion mit der aktualisiertenKonfiguration enthalten ist. Fügen Sie anschließend die Funktionsdefinitionsversion einer neuenGruppenversion (zusammen mit Ihren anderen Gruppenkomponenten) hinzu und stellen Sie dieGruppenversion bereit. Wenn Sie die Standardkonfiguration wiederherstellen möchten, können Sie eineFunktionsdefinitionsversion erstellen, in der die GGCloudSpooler-Funktion nicht enthalten ist.

Diese Lambda-Systemfunktion wird in der Konsole nicht angezeigt. Nachdem die Funktion der neuestenGruppenversion hinzugefügt wurde, ist sie allerdings in Bereitstellungen enthalten, die Sie von der Konsoleaus erstellen (es sei denn, Sie ersetzen oder verschieben sie mit der API).

Client-IDs für MQTT-Verbindungen mit AWS IoTDiese Funktion ist für AWS IoT Greengrass Core v1.8 und höher verfügbar.

AWS IoT Greengrass-Core öffnet MQTT-Verbindungen mit AWS IoT für Vorgänge, wie etwaSchattensynchronisierung und Zertifikatsverwaltung. Für diese Verbindungen generiert der Core

61

AWS IoT Greengrass EntwicklerhandbuchClient-IDs für MQTT-Verbindungen mit AWS IoT

vorhersagbare Client-IDs auf Grundlage des Core-Namens. Vorhersagbare Client-IDs können mitÜberwachungs-, Überprüfungs- und Preisgestaltungsfunktionen verwendet werden, einschließlichAWS IoT Device Defender- und -AWS IoTLebenszyklusereignissen. Sie können auch eine Logik imZusammenhang mit vorhersagbaren Client-IDs erstellen (Beispiel: Aborichtlinien-Vorlagen auf Grundlagevon Zertifikatsattributen).

GGC v1.9

Zwei Greengrass-Systemkomponenten öffnen MQTT-Verbindungen mit AWS IoT. Diese Komponentenverwenden die folgenden Muster, um die Client-IDs für die Verbindungen zu generieren.

Operation Client-ID Muster

Bereitstellungen core-thing-name

Beispiel: MyCoreThing

Verwenden Sie diese Client-ID fürBenachrichtigungen bei folgendenLebenszyklusereignissen: Verbinden,Verbindung trennen, Abonnieren undAbonnement kündigen.

MQTT-Nachrichtenaustausch mit AWS IoT core-thing-name-cnn

Beispiel: MyCoreThing-c01

nn ist eine Ganzzahl, die bei 00 beginnt undmit jeder neuen Verbindung auf höchstens 05ansteigt. Die Anzahl der Verbindungen wirdfestgelegt durch die Anzahl der Geräte, die ihrenSchattenstatus mit AWS IoT synchronisieren(maximal 200 pro Gruppe) und die Anzahl derAbonnements mit cloud als ihrer Quelle in derGruppe (maximal 50 pro Gruppe).

Die Systemkomponente Spooler stelltVerbindungen zu AWS IoT her, um Nachrichtenfür Abonnements mit einer Cloudquelle odereinem Cloudziel auszutauschen. Der Spoolerdient außerdem als Proxy für den lokalenNachrichtenaustausch zwischen AWS IoTund dem lokalen Shadow-Service und DeviceCertificate Manager.

GGC v1.8

Mehrere Greengrass-Systemkomponenten öffnen MQTT-Verbindungen mit AWS IoT. DieseKomponenten verwenden die folgenden Muster, um die Client-IDs für die Verbindungen zu generieren.

Operation Client-ID Muster

Bereitstellungen core-thing-name

Beispiel: MyCoreThing

Verwenden Sie diese Client-ID fürBenachrichtigungen bei folgenden

62



AWS IoT Greengrass EntwicklerhandbuchAktivieren der automatischen IP-Erkennung

Operation Client-ID MusterLebenszyklusereignissen: Verbinden,Verbindung trennen, Abonnieren undAbonnement kündigen.

MQTT-Nachrichtenaustausch mit AWS IoT core-thing-name-spr

Beispiel: MyCoreThing-spr

Schattensynchronisierung core-thing-name-snn

Beispiel: MyCoreThing-s01

nn ist eine Ganzzahl, die bei 00 beginnt undmit jeder neuen Verbindung auf höchstens03 ansteigt. Die Anzahl der Verbindungenwird durch die Anzahl der Geräte (maximal200 Geräte pro Gruppe) bestimmt, die ihrenSchattenstatus mit AWS IoT (maximal 50Abonnements pro Verbindung) synchronisieren.

Gerätezertifikatsverwaltung core-thing-name-dcm

Beispiel: MyCoreThing-dcm

Note

Doppelte Client-IDs in gleichzeitigen Verbindungen können zu einer unendlichen Verbinden-Trennen-Schleife führen. Dies kann der Fall sein, wenn für ein anderes Gerät festgelegt ist, dassder Core-Gerätename als Client-ID in Verbindungen verwendet wird. Weitere Informationen findenSie im Fehlerbehandlungsschritt (p. 507).

Greengrass-Geräte sind zudem vollständig in den Flotten-Indizierungsdienst von AWS IoT DeviceManagement integriert. Auf diese Weise können Sie Geräte in der Cloud auf der Grundlage vonGeräteattributen, Schattenzustand und Verbindungsstatus indizieren und suchen. Greengrass-Gerätestellen beispielsweise mindestens eine Verbindung her, bei der der Objektname als Client-ID verwendetwird, damit Sie mithilfe der Gerätekonnektivitätsindizierung ermitteln können, welche Greengrass-Geräte derzeit mit AWS IoT verbunden oder davon getrennt sind. Weitere Informationen finden Sie unterFlottenindizierungsservice im AWS IoT-Entwicklerhandbuch.

Aktivieren der automatischen IP-ErkennungSie können AWS IoT Greengrass so konfigurieren, dass die automatische Erkennung Ihres AWSIoT Greengrass-Core mit der IPDetector System-Lambda-Funktion aktiviert wird. Diese Funktionkann auch aktiviert werden, indem Sie Automatic detection auswählen. Dies kann entweder bei derersten Bereitstellung Ihrer Gruppe über die Konsole oder zu jedem Zeitpunkt über die Seite mit denGruppeneinstellungen in der Konsole erfolgen.

Das folgende Verfahren verwendet den CLI-Befehl create-function-definition-version zurKonfiguration der automatischen Erkennung von Greengrass Core.

Note

Bei diesem Verfahren wird davon ausgegangen, dass Sie die Konfiguration auf die neuesteGruppenversion einer vorhandenen Gruppe aktualisieren.

1. Rufen Sie die IDs der Greengrass-Zielgruppen und die Gruppenversion ab.

63

https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html



Note

Der list-groups Befehl gibt jeweils nur 50 Gruppen zurück. Wenn Sie über mehr als50 Gruppen verfügen, geben Sie in der max-results-Option die gewünschte Anzahl derErgebnisse an (z. B. 100), sodass Sie Ihre Gruppe finden:

aws greengrass list-groups --max-results 100

Note


2. Kopieren Sie die Eigenschaften Id und LatestVersion Ihrer Zielgruppe aus der Ausgabe.3. Rufen Sie die neueste Gruppenversion ab.

• Ersetzen Sie group-id durch die kopierte Id.• Ersetzen Sie latest-group-version-id durch die kopierte LatestVersion.

aws greengrass get-group-version \--group-id group-id \--group-version-id latest-group-version-id

4. Kopieren Sie aus dem Objekt Definition in der Ausgabe den CoreDefinitionVersionArn unddie ARNs aller anderen Gruppenkomponenten außer FunctionDefinitionVersionArn. DieseWerte verwenden Sie, wenn Sie eine neue Gruppenversion erstellen.

5. Kopieren Sie die ID der Funktionsdefinition sowie die Funktionsdefinitionsversion ausFunctionDefinitionVersionArn in der Ausgabe:

arn:aws:greengrass:region:account-id:/greengrass/groups/function-definition-id/versions/function-definition-version-id

Note

Sie können optional eine Funktionsdefinition mit dem create-function-definition-Befehl erstellen und anschließend die ID aus der Ausgabe kopieren.

6. Verwenden Sie den Befehl get-function-definition-version zum Abrufen des aktuellenDefinitionsstatus. Verwenden Sie die function-definition-id, die Sie für die Funktionsdefinitionkopiert haben . Zum Beispiel: 4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3.

aws greengrass get-function-definition-version--function-definition-id function-definition-id--function-definition-version-id function-definition-version-id

Notieren Sie sich die aufgeführten Funktionskonfigurationen. Beim Erstellen einer neuenFunktionsdefinitionsversion müssen Sie diese angeben, um zu verhindern, dass Ihre aktuellenDefinitionseinstellungen verloren gehen.

7. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.

64

https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html


• Ersetzen Sie function-definition-id durch den aus der Funktionsdefinition kopierten Id. ZumBeispiel: 4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3.

• Ersetzen Sie arbitrary-function-id durch einen Namen für die Funktion, wie etwa auto-detection-function.

• Fügen Sie alle Lambda-Funktionen hinzu, die in dieser Version des functions-Arrays enthaltensein sollen, so zum Beispiel alle im vorherigen Schritt aufgelisteten Funktionen.

aws greengrass create-function-definition-version \--function-definition-id function-definition-id \--functions '[{"FunctionArn":"arn:aws:lambda:::function:GGIPDetector:1","Id":"arbitrary-function-id","FunctionConfiguration":{"Pinned":true,"MemorySize":32768,"Timeout":3}}]'\--region us-west-2

8. Kopieren Sie den Arn der Funktionsdefinitionsversion aus der Ausgabe.9. Erstellen Sie eine Gruppenversion, in der die Lambda-Systemfunktion enthalten ist.

• Ersetzen Sie group-id durch die Id für die Gruppe.• Ersetzen Sie core-definition-version-arn durch den aus der neuesten Gruppenversion

kopierten CoreDefinitionVersionArn.• Ersetzen Sie function-definition-version-arn durch den aus der neuen

Funktionsdefinitionsversion kopierten Arn.• Ersetzen Sie die ARNs für andere Gruppenkomponenten (zum BeispielSubscriptionDefinitionVersionArn oder DeviceDefinitionVersionArn), die Sie ausder neuesten Gruppe kopiert haben.

• Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel --resource-definition-version-arn, wenn Ihre Gruppenversion keine Ressourcen enthält.

aws greengrass create-group-version \--group-id group-id \--core-definition-version-arn core-definition-version-arn \--function-definition-version-arn function-definition-version-arn \--device-definition-version-arn device-definition-version-arn \--logger-definition-version-arn logger-definition-version-arn \--resource-definition-version-arn resource-definition-version-arn \--subscription-definition-version-arn subscription-definition-version-arn

10. Kopieren Sie die Version aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.11. Stellen Sie die Gruppe bereit.

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie group-version-id durch die Version, die Sie für die neue Gruppe kopiert haben.

aws greengrass create-deployment \--group-id group-id \--group-version-id group-version-id \--deployment-type NewDeployment

Wenn Sie die IP-Adresse Ihres AWS IoT Greengrass-Core manuell eingeben möchten, können Sie diesesTutorial mit einer anderen Funktionsdefinition abschließen, die die Funktion IPDetector nicht enthält.Dadurch wird verhindert, dass die Erkennungsfunktion Ihre AWS IoT Greengrass-Core-IP-Adresse findetund automatisch eingibt.

65

AWS IoT Greengrass EntwicklerhandbuchAusführen von Greengrass bei Systemstart

Diese Lambda-Systemfunktion wird in der Lambda-Konsole nicht angezeigt. Nachdem die Funktion derneuesten Gruppenversion hinzugefügt wurde, ist sie in Bereitstellungen enthalten, die Sie von der Konsoleaus erstellen (es sei denn, Sie ersetzen oder verschieben sie mit der API).

Konfigurieren das Init-Systems zum Starten desGreengrass-DaemonsEs ist ein bewährtes Verfahren, Ihr Init-System so einzurichten, dass der Greengrass-Daemon beimStartvorgang ausgeführt wird, insbesondere bei der Verwaltung großer Geräteflotten.

Es gibt verschiedene Arten von Init-Systemen, z. B. initd, systemd und SystemV, und sie verwendenähnliche Konfigurationsparameter. Das folgende Beispiel ist eine Servicedatei für systemd. Der Type-Parameter wird auf forking festgelegt, da greengrassd (das zum Starten von Greengrass verwendetwird) den Greengrass-Daemon-Prozess verzweigt und der Restart-Parameter auf on-failurefestgelegt wird, um systemd so zu steuern, dass Greengrass neu gestartet wird, wenn Greengrass einenfehlerhaften Zustand aufweist.

Note

Führen Sie das check_ggc_dependencies-Skript wie in Modul 1 (p. 70) beschrieben aus,um festzustellen, ob Ihr Gerät systemd verwendet. Zur Verwendung von systemd stellen Sieanschließend sicher, dass der useSystemd-Parameter in config.json (p. 23) auf yesfestgelegt ist.

[Unit]Description=Greengrass Daemon

[Service]Type=forkingPIDFile=/var/run/greengrassd.pidRestart=on-failureExecStart=/greengrass/ggc/core/greengrassd startExecReload=/greengrass/ggc/core/greengrassd restartExecStop=/greengrass/ggc/core/greengrassd stop

[Install]WantedBy=multi-user.target

Weitere Informationen zum Erstellen und Aktivieren einer Service-Datei für systemd auf einem RaspberryPi finden Sie unter SYSTEMD in der Raspberry Pi-Dokumentation.

Archivieren einer AWS IoT Greengrass Core-Software-InstallationWenn Sie ein Upgrade auf eine neue Version der AWS IoT Greengrass Core-Software ausführen, könnenSie die aktuell installierte Version archivieren. Dadurch bleibt Ihre aktuelle Installationsumgebung erhalten,sodass Sie eine neue Softwareversion auf derselben Hardware testen können. Dadurch wird auch einRollback auf Ihre archivierte Version vereinfacht.

So archivieren Sie die aktuelle Installation und installieren eine neue Version

1. Laden Sie das Installationspaket für die AWS IoT Greengrass-Core-Software (p. 15) herunter, aufdie Sie upgraden möchten.

2. Kopieren Sie das Paket in das Core-Zielgerät. Anweisungen zum Übertragen von Dateien finden Sie indiesem Schritt (p. 87).

66

https://www.raspberrypi.org/documentation/linux/usage/systemd.md

AWS IoT Greengrass EntwicklerhandbuchArchivieren einer Core-Software-Installation

Note

Sie kopieren Ihre aktuellen Zertifikate, Schlüssel und die Konfigurationsdatei später in dieneue Installation.

Führen Sie die Befehle in den folgenden Schritten in Ihrem Core-Geräte-Terminal aus.3. Stellen Sie sicher, dass der Greengrass-Daemon auf dem Code-Gerät beendet wird.

a. So prüfen Sie, ob der Daemon ausgeführt wird:

ps aux | grep -E 'greengrass.*daemon'

Wenn die Ausgabe einen root-Eintrag für /greengrass/ggc/packages/ggc-version/bin/daemon enthält, dann wird der Daemon ausgeführt.

Note

Dieses Verfahren setzt voraus, dass die AWS IoT Greengrass Core-Software im /greengrass-Verzeichnis installiert ist.

b. So beenden Sie den Daemon:

cd /greengrass/ggc/core/sudo ./greengrassd stop

4. Verschieben Sie das aktuelle Greengrass-Stammverzeichnis in ein anderes Verzeichnis.

sudo mv /greengrass /greengrass_backup

5. Entpacken Sie die neue Software auf dem Core-Gerät. Ersetzen Sie die Platzhalter os-architecture und version im Befehl.

sudo tar –zxvf greengrass-os-architecture-version.tar.gz –C /

6. Kopieren Sie die archivierten Zertifikate, Schlüssel und die Konfigurationsdatei in die neue Installation.

sudo cp /greengrass_backup/certs/* /greengrass/certssudo cp /greengrass_backup/config/* /greengrass/config

7. Starten Sie den Daemon:

cd /greengrass/ggc/core/sudo ./greengrassd start

Jetzt können Sie eine Gruppenbereitstellung vornehmen, um die neue Installation zu testen. Bei einemFehler können Sie die archivierte Installation wiederherstellen.

So stellen Sie die archivierte Installation wieder her

1. Beenden Sie den Daemon.2. Löschen Sie das neue /greengrass-Verzeichnis.3. Verschieben Sie das Verzeichnis /greengrass_backup wieder zu /greengrass.4. Starten Sie den -Daemon.

67

AWS IoT Greengrass EntwicklerhandbuchWeitere Informationen finden Sie auch unter:

Weitere Informationen finden Sie auch unter:• the section called “Hardware-Sicherheit” (p. 435)

68

AWS IoT Greengrass EntwicklerhandbuchVoraussetzungen

Erste Schritte mit AWS IoTGreengrass

Dieses Tutorial enthält mehrere Module, die Ihnen die Grundlagen von AWS IoT Greengrass vermitteln undIhnen einen schnellen Einstieg ermöglichen. In diesem Tutorial werden die folgenden Themen abgedeckt:

• Das AWS IoT Greengrass-Programmiermodell• Grundlegende Konzepte, wie AWS IoT Greengrass-Cores, -Gruppen und -Abonnements• Der Bereitstellungsprozess für die Ausführung von AWS LambdaFunktionen am Edge.

VoraussetzungenZum Durcharbeiten dieses Tutorials ist Folgendes erforderlich:

• Ein PC, Mac-, Windows- oder UNIX-ähnliches System.• Ein Amazon Web Services (AWS)-Konto. Falls Sie keines haben, finden Sie weitere Informationen unter

the section called “Erstellen eines AWS-Kontos” (p. 70).• Eine nutzbare AWS-Region, die AWS IoT Greengrass unterstützt. Die Liste der für AWS IoT Greengrass

unterstützten Regionen finden Sie unter Regionen und Endpunkte von AWS in AWS General Reference.Important

Notieren Sie Ihre AWS-Region, um sicherzustellen, dass sie in diesem Tutorial konsistentverwendet wird. Ein versehentlicher Wechsel zwischen AWS-Regionen während des Tutorialskann zu Problemen führen. Bei der letzten Übung in diesem Tutorial wird davon ausgegangen,dass Sie die Region USA Ost (Nord-Virginia) verwenden.

• Ein Raspberry Pi 3 Modell B+ oder Modell B mit einer 8-GB-microSD-Karte oder eine Amazon EC2-Instance. Da AWS IoT Greengrass mit physischer Hardware verwendet werden sollte, empfehlen wir dieVerwendung eines Raspberry Pi. Die Architektur Ihres Pi muss armv7l oder höher sein.

Note

Führen Sie den folgenden Befehl aus, um das Modell Ihres Raspberry Pi zu bestimmen:

cat /proc/cpuinfo

Merken Sie sich den Wert des Revision-Attributs am Ende der Liste und konsultieren Sie dieTabelle Which Pi have I got?. Beispiel: Wenn der Wert für Revision a02082 lautet, geht ausder Tabelle hervor, dass es sich um einen Pi 3 Model B handelt.Führen Sie den folgenden Befehl aus, um die Architektur Ihres Raspberry Pi zu bestimmen:

uname -m

Das Ergebnis muss gleich oder größer als armv71 sein.• Grundlegende Vertrautheit mit Python 2.7.

Obwohl dieses Tutorial Schritte für die Ausführung von AWS IoT Greengrass auf einem RaspberryPi bietet, können Sie auch andere Plattformen verwenden. Weitere Informationen finden Sie unterUnterstützte Plattformen und Anforderungen (p. 12).

69

https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology


https://www.raspberrypi.org/products/raspberry-pi-3-model-b-plus/

https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

https://elinux.org/RPi_HardwareHistory#Which_Pi_have_I_got.3F

AWS IoT Greengrass EntwicklerhandbuchErstellen eines AWS-Kontos

Erstellen eines AWS-KontosWenn Sie noch kein AWS-Konto haben, führen Sie die folgenden Schritte aus:

1. Öffnen Sie die AWS-Startseite und wählen Sie Create an AWS Account aus.

Note

Wenn Sie sich kürzlich bei AWS angemeldet haben, sehen Sie stattdessen möglicherweisedie Meldung Sign In to the Console.

2. Folgen Sie den Onlineanweisungen. Der Anmeldeprozess beinhaltet auch einen Telefonanruf und dieEingabe einer PIN über die Telefontastatur.

Important

Bevor Sie beginnen, stellen Sie sicher, dass Ihr Konto über Administratorberechtigungenverfügt.

Modul 1: Umgebungseinrichtung für GreengrassDieses Modul führt Sie durch die Einrichtung eines sofort einsetzbaren Raspberry Pi, einer Amazon EC2-Instance oder eines anderen Geräts, das von AWS IoT Greengrass als AWS IoT Greengrass-Core-Gerätverwendet werden kann.

Bevor Sie beginnen, lesen Sie die Anforderungen (p. 69) für dieses Tutorial.

Dieses Modul sollte nicht mehr als 30 Minuten in Anspruch nehmen.

Themen• Einrichten eines Raspberry Pi (p. 70)• Einrichten einer Amazon EC2-Instance (p. 75)• Einrichten anderer Geräte (p. 80)

Note

Weitere Informationen, wie Sie AWS IoT Greengrass in einem vorkonfigurierten Docker-Containerverwenden, finden Sie unter the section called “Ausführen von AWS IoT Greengrass in einemDocker-Container” (p. 192).

Einrichten eines Raspberry PiWenn Sie zum ersten Mal einen Raspberry Pi einrichten, befolgen Sie alle nachfolgenden Schritte.Andernfalls können Sie mit Schritt 9 fortfahren. Wir empfehlen ein Reimaging des Raspberry Pi mit demBetriebssystem, wie in Schritt 2 empfohlen.

1. Laden Sie einen SD-Karten-Formatierer herunter und installieren Sie ihn, z. B. SD Memory CardFormatter oder PiBakery. Legen Sie die SD-Karte in Ihren Computer. Starten Sie das Programmund wählen Sie das Laufwerk aus, in das Sie die SD-Karte eingelegt haben. Sie können eineSchnellformatierung der SD-Karte durchführen.

2. Laden Sie das Betriebssystem Raspbian Stretch als .zip-Datei herunter.3. Folgen Sie in einem SD-Karten-Schreibtool (z. B. Etcher) den Anweisungen in dem Tool, um die

heruntergeladene Datei zip auf die SD-Karte zu schreiben. Da das Betriebssystemabbild sehr groß

70

https://aws.amazon.com/

https://www.sdcard.org/downloads/formatter_4/index.html

https://www.sdcard.org/downloads/formatter_4/index.html

http://www.pibakery.org/download.html


https://etcher.io/

AWS IoT Greengrass EntwicklerhandbuchEinrichten eines Raspberry Pi

ist, kann dieser Schritt einige Zeit in Anspruch nehmen. Werfen Sie die SD-Karte aus und setzen Siedie microSD-Karte in Ihren Raspberry Pi ein.

4. Für den ersten Systemstart empfehlen wir, dass Sie den Raspberry Pi (über HDMI) mit einem Monitor,einer Tastatur und einer Maus verbinden. Schließen Sie den Pi an eine Micro USB-Stromquelle an.Das Raspbian-Betriebssystem sollte gestartet werden.

5. Sie möchten vielleicht zuerst das Pi-Tastaturlayout konfigurieren, bevor Sie fortfahren. Wählen Siedazu das Raspberry-Symbol in der rechten oberen Ecke, Preferences (Präferenzen) und danachMouse and Keyboard Settings (Maus- und Tastatureinstellungen) aus. Wählen Sie als Nächstesauf der Registerkarte Keyboard (Tastatur) die Option Keyboard Layout (Tastaturlayout) und dieentsprechende Tastaturvariante aus.

6. Verbinden Sie Ihren Raspberry Pi mit dem Internet über ein WLAN-Netzwerk oder ein Ethernet-Kabel.

Note

Verbinden Sie Ihren Raspberry Pi mit demselben Netzwerk wie Ihren Computer und stellenSie sicher, dass sowohl der Computer als auch der Raspberry Pi Internetzugriff haben, bevorSie fortfahren. Wenn Sie sich in einer Arbeitsumgebung oder hinter einer Firewall befinden,müssen Sie möglicherweise Ihren Pi und Ihren Computer mit dem Gastnetzwerk verbinden,sodass sich beide Geräte in demselben Netzwerk befinden. Bei diesem Ansatz wird jedochmöglicherweise die Verbindung Ihres Computer mit lokalen Netzwerkressourcen wie etwaIhrem Intranet getrennt. Eine Lösung ist, den Pi mit dem WLAN-Gastnetzwerk zu verbindenund Ihren Computer über ein Ethernet-Kabel mit dem WLAN-Gastnetzwerk und Ihrem lokalenNetzwerk zu verbinden. In dieser Konfiguration sollte Ihr Computer in der Lage sein, über dasWLAN-Gastnetzwerk eine Verbindung zum Raspberry Pi und über das Ethernet-Kabel eineVerbindung zu Ihren lokalen Netzwerkressourcen herzustellen.

7. Sie müssen SSH auf dem Pi einrichten, um eine Remoteverbindung zu ermöglichen. Öffnen Sie aufdem Raspberry Pi ein Terminalfenster und führen Sie den folgenden Befehl aus:

sudo raspi-config

Sie sollten Folgendes sehen:

Führen Sie einen Bildlauf nach unten aus und wählen Sie Interfacing Options und P2 SSH aus.Wählen Sie nach Aufforderung die Option Yes (Ja) aus. (Verwenden Sie die Tab-Taste gefolgt vonEnter). SSH sollte damit aktiviert sein. Klicken Sie auf OK. Wählen Sie mit der Tab-Taste Finish (Fertigstellen) und drücken Sie dann Enter. Wenn der Raspberry Pi nicht automatisch neu startet, führen Sieden folgenden Befehl aus:

sudo reboot

71

https://www.raspberrypi.org/documentation/configuration/wireless/desktop.md

https://en.wikipedia.org/wiki/Secure_Shell

https://www.raspberrypi.org/documentation/usage/terminal/


8. Führen Sie auf dem Raspberry Pi in dem Terminal den folgenden Befehl aus:

hostname -I

Damit wird die IP-Adresse Ihres Raspberry Pi zurückgegeben.

Note

Wenn Sie nachfolgend eine Meldung hinsichtlich des Fingerabdrucks für den ECDSA-Schlüssel (Are you sure you want to continue connecting (yes/no)?)erhalten, geben Sie yes ein. Das Standardpasswort für den Raspberry Pi lautet raspberry.

Wenn Sie macOS verwenden, öffnen Sie ein Terminalfenster und geben Sie Folgendes ein:

ssh pi@IP-address

Hier entspricht IP-address der IP-Adresse Ihres Raspberry Pi, die Sie mit dem Befehl hostname -I erhalten haben.

Wenn Sie Windows verwenden, müssen Sie PuTTY installieren und konfigurieren. ErweiternSie Connection (Verbindung), wählen Sie Data (Daten) und vergewissern Sie sich, dass Prompt(Auffordern) ausgewählt ist:

Wählen Sie Session (Sitzung), geben Sie die IP-Adresse des Raspberry Pi ein und wählen Sie dannOpen (Öffnen) unter Verwendung der Standardeinstellungen.

72

https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html


Wenn eine PuTTY-Sicherheitswarnung angezeigt wird, klicken Sie auf Yes (Ja).

Die Standardanmeldedaten und das Passwort für den Raspberry Pi lauten pi und raspberry.

73


Note

Wenn Ihr Computer mit einem Remote-Netzwerk über VPN verbunden ist, haben Siemöglicherweise Probleme, mit SSH eine Verbindung des Computers mit dem Raspberry Piherzustellen.

9. Jetzt können Sie den Raspberry Pi für AWS IoT Greengrass einrichten. Führen Sie zuerst diefolgenden Befehle in einem lokalen Raspberry Pi-Terminalfenster oder einem SSH-Terminalfensteraus:

sudo adduser --system ggc_usersudo addgroup --system ggc_group

10. Um die Sicherheit auf dem Pi-Gerät zu erhöhen, aktivieren Sie beim Betriebssystemstart den Hard-und Softlink-Schutz.

a. Navigieren Sie zur Datei 98-rpi.conf.

cd /etc/sysctl.dls

Note

Wenn die Datei 98-rpi.conf nicht angezeigt wird, befolgen Sie die Anweisungen in derDatei README.sysctl.

b. Fügen Sie die beiden folgenden Zeilen mithilfe eines Texteditors (z. B. Leafpad, GNU nano odervi) am Ende der Datei hinzu. Sie müssen für die Bearbeitung als Root-Benutzer möglicherweiseden Befehl sudo verwenden (z. B. sudo nano 98-rpi.conf).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

c. Starten Sie den Pi neu.

sudo reboot

Stellen Sie nach ca. einer Minute unter Verwendung von SSH eine Verbindung mit dem Pi her undführen Sie dann den folgenden Befehl aus, um die Änderung zu bestätigen:

sudo sysctl -a 2> /dev/null | grep fs.protected

Sie sollten fs.protected_hardlinks = 1 und fs.protected_symlinks = 1 sehen.11. Bearbeiten Sie Ihre Befehlszeilen-Startdatei, um Speicher-cgroups zu aktivieren und zu mounten. Auf

diese Weise kann AWS IoT Greengrass das Speicherlimit für Lambda-Funktionen festlegen. Cgroupssind ebenso erforderlich, um AWS IoT Greengrass im Containerisierungs (p. 182)-Standardmodusauszuführen.

a. Navigieren Sie zum Verzeichnis boot.

cd /boot/

b. Öffnen Sie mit einem Texteditor cmdline.txt. Fügen Sie Folgendes am Ende der vorhandenenLinie – nicht als eine neue Zeile – ein.

cgroup_enable=memory cgroup_memory=1

74

AWS IoT Greengrass EntwicklerhandbuchEinrichten einer Amazon EC2-Instance

c. Starten Sie den Pi neu.

sudo reboot

Ihr Raspberry Pi sollte jetzt für AWS IoT Greengrass bereit sein.12. Um sicherzustellen, dass Sie über alle erforderlichen Abhängigkeiten verfügen, laden Sie das

Greengrass-Abhängigkeitsprüftool aus dem GitHub-Repository AWS IoT Greengrass Samplesherunter. Diese Befehle entpacken das Abhängigkeitsprüftool-Skript im Verzeichnis Downloads undführen es aus.

cd /home/pi/Downloadsmkdir greengrass-dependency-checker-GGCv1.9.xcd greengrass-dependency-checker-GGCv1.9.xwget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.9.x.zipunzip greengrass-dependency-checker-GGCv1.9.x.zipcd greengrass-dependency-checker-GGCv1.9.xsudo modprobe configssudo ./check_ggc_dependencies | more

Wenn more erscheint, drücken Sie die Taste Spacebar, um einen weiteren Bildschirm mit Textanzuzeigen.

Important

Für dieses Tutorial ist Python 2.7 erforderlich. Das check_ggc_dependencies-Skript kannzu Warnungen über die fehlenden optionalen Node.js- und Java-Voraussetzungen führen. Siekönnen diese Warnungen ignorieren.

Weitere Information zum Befehl modprobe erhalten Sie, wenn Sie man modprobe im Terminalausführen.

Die Konfiguration Ihres Raspberry Pi ist damit abgeschlossen. Fahren Sie fort mit the section called“Modul 2: Installieren der AWS IoT Greengrass Core-Software” (p. 81).

Einrichten einer Amazon EC2-InstanceDieser Abschnitt enthält Anweisungen zum Einrichten Ihrer Amazon EC2-Instance.

Note

Sie können diese Module zwar mit einer Amazon EC2-Instance verwenden, idealerweise sollteAWS IoT Greengrass jedoch mit physischer Hardware verwendet werden. Wir empfehlen dieVerwendung eines Raspberry Pi für diese Tutorials.

1. Melden Sie sich bei der AWS Management Console an und starten Sie eine Amazon EC2-Instance miteinem Amazon Linux-AMI. Weitere Informationen zu Amazon EC2-Instances finden Sie im AmazonEC2 Getting Started Guide.

2. Sobald Ihre Amazon EC2-Instance ausgeführt wird, aktivieren Sie Port 8883, um eingehende MQTT-Kommunikation zuzulassen, sodass andere Geräte eine Verbindung mit der AWS IoT Greengrass-Core herstellen können.

a. Wählen Sie im Navigationsbereich der Amazon EC2-Konsole Security Groups(Sicherheitsgruppen).

75

https://github.com//aws-samples/aws-greengrass-samples

https://console.aws.amazon.com/

https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/

https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/


b. Wählen Sie die Sicherheitsgruppe für die Instance aus, die Sie gerade gestartet haben, undwählen Sie dann die Registerkarte Inbound (Eingehend).

c. Wählen Sie Bearbeiten aus.

76


Um Port 8883 zu aktivieren, fügen Sie eine benutzerdefinierte TCP-Regel zur Sicherheitsgruppehinzu. Weitere Informationen finden Sie unter Hinzufügen von Regeln zu einer Sicherheitsgruppeim Amazon EC2-Benutzerhandbuch für Linux-Instances.

d. Wählen Sie auf der Seite Edit inbound rules (Regeln für eingehenden Datenverkehr bearbeiten)die Option Add Rule (Regel hinzufügen), geben Sie die folgenden Einstellungen ein und klickenSie dann auf Save (Speichern).

• Wählen Sie für Type Custom TCP Rule aus.• Geben Sie für Port Range (Port-Bereich) den Wert 8883 ein.• Wählen Sie unter Source (Quelle) die Option Anywhere (Alle) aus.• Geben Sie für Description (Beschreibung) den Text MQTT Communications ein.

3. Stellen Sie eine Verbindung zur Amazon EC2-Instance her.

a. Wählen Sie im Navigationsbereich Instances, wählen Sie Ihre Instance aus und klicken Sie dannauf Connect (Verbinden).

b. Befolgen Sie die Anweisungen auf der Seite Connect To Your Instance (Mit Ihrer Instanceverbinden), um eine Verbindung mit Ihrer Instance über SSH und Ihre private Schlüsseldateiherzustellen.

77

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html


Sie können PuTTY für Windows oder Terminal für macOS verwenden. Weitere Informationen findenSie unter Verbinden Sie sich mit der Linux-Instance im Amazon EC2-Benutzerhandbuch für Linux-Instances.

4. Nachdem Sie eine Verbindung mit Ihrer Amazon EC2-Instance hergestellt haben, erstellen Sie denBenutzer ggc_user und die Gruppe ggc_group:

sudo adduser --system ggc_usersudo groupadd --system ggc_group

5. Stellen Sie sicher, dass Sie beim Betriebssystemstart den Hardlink- und Softlink-Schutz aktivieren, umdie Sicherheit auf dem Gerät zu erhöhen.

Note

Die Schritte für die Aktivierung des Hardlink- und Softlink-Schutzes sind vom Betriebssystemabhängig. Weitere Informationen finden Sie in der Dokumentation für Ihre Verteilung.

a. Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Hardlink- und Softlink-Schutz aktiviertist:

sudo sysctl -a | grep fs.protected

Wenn Hardlinks und Softlinks auf 1 festgelegt sind, sind die Schutzfunktionen korrekt aktiviert.Fahren Sie mit Schritt 6 fort.

b. Wenn Hardlinks und Softlinks nicht auf 1 festgelegt sind, aktivieren Sie diese Schutzfunktionen.Navigieren Sie zur Systemkonfigurationsdatei.

78

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html


cd /etc/sysctl.dls

c. Fügen Sie in Ihrem bevorzugten Texteditor (z. B. Leafpad, GNU nano oder vi) am Ende derSystemkonfigurationsdatei die folgenden beiden Zeilen hinzu. In Amazon Linux 1 ist dies die Datei00-defaults.conf. In Amazon Linux 2 ist dies die Datei 99-amazon.conf. Möglicherweisemüssen Sie die Berechtigungen ändern (mit dem Befehl chmod), damit Sie in die Datei schreibenkönnen. Sie können auch den Befehl sudo nano 00-defaults.conf verwenden, um dieBearbeitung als Root-Benutzer auszuführen (z. B. sudo).

fs.protected_hardlinks = 1fs.protected_symlinks = 1

d. Starten Sie die Amazon EC2-Instance neu.

sudo reboot

Stellen Sie nach ein paar Minuten eine Verbindung mit Ihrer Instance über SSH her und führen Siedann den folgenden Befehl aus, um die Änderung zu bestätigen.

sudo sysctl -a | grep fs.protected

Die Hard- und Softlinks sind auf 1 eingestellt.6. Extrahieren Sie das folgende Skript und führen Sie es aus, um Linux-Kontrollgruppen

(cgroups) zu mounten. Auf diese Weise kann AWS IoT Greengrass das Speicherlimit fürLambda-Funktionen festlegen. Cgroups sind ebenso erforderlich, um AWS IoT Greengrass imContainerisierungs (p. 182)-Standardmodus auszuführen.

curl https://raw.githubusercontent.com/tianon/cgroupfs-mount/951c38ee8d802330454bdede20d85ec1c0f8d312/cgroupfs-mount > cgroupfs-mount.shchmod +x cgroupfs-mount.sh sudo bash ./cgroupfs-mount.sh

Ihre Amazon EC2-Instance sollte jetzt für AWS IoT Greengrass bereit sein.7. Um sicherzustellen, dass Sie über alle erforderlichen Abhängigkeiten verfügen, laden Sie das

Greengrass-Abhängigkeitsprüftool aus dem GitHub-Repository AWS IoT Greengrass Samplesherunter. Diese Befehle entpacken das Abhängigkeitsprüftool-Skript und führen es aus.

mkdir greengrass-dependency-checker-GGCv1.9.xcd greengrass-dependency-checker-GGCv1.9.xwget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.9.x.zipunzip greengrass-dependency-checker-GGCv1.9.x.zipcd greengrass-dependency-checker-GGCv1.9.xsudo ./check_ggc_dependencies | more

Important


Die Konfiguration Ihrer Amazon EC2-Instance ist damit abgeschlossen. Fahren Sie fort mit the sectioncalled “Modul 2: Installieren der AWS IoT Greengrass Core-Software” (p. 81).

79

https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/ch01


AWS IoT Greengrass EntwicklerhandbuchEinrichten anderer Geräte

Einrichten anderer GeräteWenn Sie noch nicht mit AWS IoT Greengrass vertraut sind, empfehlen wir, dass Sie einen Raspberry Pioder eine Amazon EC2-Instance als Ihr Core-Gerät verwenden und die für Ihr Gerät geeigneten Setup-Schritte (p. 70) durchzuführen. Um ein anderes Gerät oder eine andere Plattform zu verwenden, folgenSie den Schritten in diesem Abschnitt. Weitere Informationen zu unterstützten Geräteplattformen finden Sieunter Greengrass Core-Plattformkompatibilität.

1. Wenn es sich bei Ihrem Core-Gerät um ein NVIDIA Jetson TX2-Gerät handelt, müssen Sie zuerstdie Firmware mit dem JetPack 3.3-Installationsprogramm aktualisieren. Wenn Sie ein anderes Gerätkonfigurieren, fahren Sie mit Schritt 2 fort.

Note

Die Version des JetPack-Installationsprogramms, die Sie verwenden, basiert auf Ihrer Ziel-CUDA-Toolkit-Version. Bei den folgenden Anweisungen wird davon ausgegangen, dassSie JetPack 3.3 und das CUDA Toolkit 9.0 verwenden, da die Binärdateien für TensorFlowv1.10.1 und MXNet v1.2.1 (die AWS IoT Greengrass für die Machine Learning-Inferenzauf einem Jetson TX2 bereitstellt) für diese Version von CUDA kompiliert werden. WeitereInformationen finden Sie unter Durchführen von Machine Learning-Inferenzen (p. 227).

a. Auf einem physischen Desktop, auf dem Ubuntu 16.04 oder höher ausgeführt wird, aktualisierenSie die Firmware mit dem JetPack 3.3-Installationsprogramm, wie unter Herunterladen undInstallieren von JetPack (3.3) in der NVIDIA-Dokumentation beschrieben.

Befolgen Sie die Anweisungen im Installationsprogramm zum Installieren aller Pakete undAbhängigkeiten auf der Jetson-Karte, die über ein Micro-B-Kabel mit dem Desktop verbunden seinmuss.

b. Starten Sie Ihre Karte im normalen Modus neu und schließen Sie einen Bildschirm an.

Note

Wenn Sie mit SSH eine Verbindung mit der Jetson-Platine herstellen, verwenden Sie denStandard-Benutzernamen (nvidia) und das Standard-Passwort (nvidia).

2. Führen Sie einen der folgenden Befehle aus, um den Benutzer ggc_user und die Gruppeggc_group zu erstellen. Die von Ihnen ausgeführten Befehle unterscheiden sich je nach der auf IhremCore-Gerät installierten Verteilung.

• Wenn Ihr Core-Gerät OpenWrt ausführt, führen Sie die folgenden Befehle aus:

opkg install shadow-useraddopkg install shadow-groupadduseradd --system ggc_usergroupadd --system ggc_group

• Führen Sie andernfalls die folgenden Befehle aus:

sudo adduser --system ggc_usersudo addgroup --system ggc_group

Note

Wenn der Befehl addgroup in Ihrem System nicht verfügbar ist, verwenden Sie denfolgenden Befehl.

sudo groupadd --system ggc_group

80

https://aws.amazon.com/greengrass/faqs/

https://docs.nvidia.com/jetson/archives/jetpack-archived/jetpack-33/index.html#jetpack/3.3/install.htm%3FTocPath%3D_____3

https://docs.nvidia.com/jetson/archives/jetpack-archived/jetpack-33/index.html#jetpack/3.3/install.htm%3FTocPath%3D_____3

AWS IoT Greengrass EntwicklerhandbuchModul 2: Installieren der AWSIoT Greengrass Core-Software

3. Um sicherzustellen, dass Sie über alle erforderlichen Abhängigkeiten verfügen, laden Sie dasGreengrass-Abhängigkeitsprüftool aus dem GitHub-Repository AWS IoT Greengrass Samplesherunter. Diese Befehle entpacken das Abhängigkeitsprüftool-Skript und führen es aus.

mkdir greengrass-dependency-checker-GGCv1.9.xcd greengrass-dependency-checker-GGCv1.9.xwget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.9.x.zipunzip greengrass-dependency-checker-GGCv1.9.x.zipcd greengrass-dependency-checker-GGCv1.9.xsudo ./check_ggc_dependencies | more

Note

Das Skript check_ggc_dependencies wird auf von AWS IoT Greengrass unterstütztenPlattformen ausgeführt und erfordert folgende Linux-Systembefehle: printf, uname, cat,ls, head, find, zcat, awk, sed, sysctl, wc, cut, sort, expr, grep, test, dirname,readlink, xargs, strings, uniq.Weitere Informationen finden Sie in der Readme-Datei des Abhängigkeitsprüftools.

4. Installieren Sie alle erforderlichen Abhängigkeiten auf Ihrem Gerät entsprechend der Ausgabe desAbhängigkeitsprüftools. Für fehlende Abhängigkeiten auf Kernel-Ebene müssen Sie Ihren Kernelmöglicherweise neu kompilieren. Zum Mounting von Linux-Kontrollgruppen (cgroups) können Siedas Skript cgroupfs-mount ausführen. Auf diese Weise kann AWS IoT Greengrass das Speicherlimitfür Lambda-Funktionen festlegen. Cgroups sind ebenso erforderlich, um AWS IoT Greengrass imContainerisierungs (p. 182)-Standardmodus auszuführen.

Wenn keine Fehler in der Ausgabe angezeigt werden, sollte AWS IoT Greengrass jetzt erfolgreich aufIhrem Gerät ausgeführt werden können.

Important


Die Liste der AWS IoT Greengrass-Anforderungen und -Abhängigkeiten finden Sie unter UnterstütztePlattformen und Anforderungen (p. 12).

Modul 2: Installieren der AWS IoT GreengrassCore-Software

In diesem Modul erfahren Sie, wie Sie die AWS IoT Greengrass Core-Software auf dem von Ihnenausgewählten Gerät installieren. Dieses Tutorial bietet Anweisungen zum Einrichten eines Raspberry Pi,Sie können aber jedes unterstützte Gerät verwenden. Sie können die AWS IoT Greengrass Core-Softwarevon AWS IoT Greengrass-Core-Software (p. 15)-Downloads herunterladen. Dieses Verfahren umfasstSchritte zur Konfiguration und zum Starten der Software auf Ihrem Gerät.

Die AWS IoT Greengrass Core-Software bietet folgende Funktionalität:



unter Verwendung verwalteter Abonnements.

81


https://github.com/aws-samples/aws-greengrass-samples/blob/master/greengrass-dependency-checker-GGCv1.9.x/README.md

https://raw.githubusercontent.com/tianon/cgroupfs-mount/master/cgroupfs-mount

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren von AWS IoT Greengrass auf AWS IoT

• MQTT-Messaging zwischen dem AWS IoT und Geräten, Connectors und Lambda-Funktionen unterVerwendung verwalteter Abonnements.

• Sichere Verbindungen zwischen Geräten und der Cloud durch Geräteauthentifizierung und Autorisierung.• Lokale Shadow-Synchronisierung von Geräten. Schatten können so konfiguriert werden, dass sie mit der





Überprüfen Sie zu Beginn, ob Sie das Modul 1 (p. 70) abgeschlossen haben.


Themen• Konfigurieren von AWS IoT Greengrass auf AWS IoT (p. 82)• Starten von AWS IoT Greengrass auf dem Core-Gerät (p. 86)

Konfigurieren von AWS IoT Greengrass auf AWS IoT1. Melden Sie sich in der AWS Management Console auf Ihrem Computer an und öffnen Sie AWS IoT-

Konsole. Wenn diese Konsole zum ersten Mal geöffnet wird, wählen Sie Erste Schritte aus.2. Wählen Sie Greengrass.

Note

Falls Sie den Greengrass-Knoten im Navigationsbereich nicht sehen, wechseln Sie in eineAWS-Region, die AWS IoT Greengrass unterstützt. Eine Liste der unterstützten Regionenfinden Sie unter AWS-Regionen und -Endpunkte in den allgemeinen AWS-Referenzen.

82

https://console.aws.amazon.com/



3. Wählen Sie auf der Seite Welcome to AWS IoT Greengrass (Willkommen) die Option Create a Group(Eine Gruppe erstellen) aus.

Eine AWS IoT Greengrass-Gruppe (p. 6) enthält Einstellungen und weitere Informationen zuzugeordneten Komponenten, z. B. Geräten, Lambda-Funktionen und Konnektoren. Eine Gruppedefiniert, wie die Komponenten miteinander interagieren können.

Tip

Für ein Beispiel mit der Verwendung der AWS IoT Greengrass-API zum Erstellen undBereitstellen einer Gruppe vgl. das Paket gg_group_setup aus GitHub.

4. Wählen Sie auf der Seite Set up your Greengrass group (Einrichten Ihrer Greengrass-Gruppe) dieOption Use easy creation (Einfache Erstellung verwenden) aus, um eine Gruppe und einen AWS IoTGreengrass Core (p. 23) zu erstellen.

Jede Gruppe benötigt einen Kern, d.h. ein Gerät, das die lokalen IoT-Prozesse verwaltet. Ein Kernbenötigt ein Zertifikat und Schlüssel, die ihn zum Zugriff auf AWS IoT berechtigen, und eine AWSIoT-Richtlinie, die ihm die Ausführung von AWS IoT- und AWS IoT Greengrass-Aktionen ermöglicht.Wenn Sie die Option Use easy creation (Einfache Erstellung verwenden) wählen, werden dieseSicherheitsressourcen für Sie erstellt und der Kern wird in der AWS IoT-Registrierung bereitgestellt.

83

https://github.com/awslabs/aws-greengrass-group-setup


5. Geben Sie einen Namen für Ihre Gruppe ein (beispielsweise MyFirstGroup) und wählen Sie Weiteraus.

6. Verwenden Sie den Standard-Namen für den AWS IoT Greengrass-Core und wählen Sie dann Weiteraus.

84


7. Die Seite Run a scripted easy Group creation mit Hervorhebung der Schaltfläche Create Group andCore

AWS IoT erstellt eine AWS IoT Greengrass-Gruppe mit Standard-Sicherheitsrichtlinien undKonfigurationsdateien, die Sie auf Ihr Gerät laden können.

8. Laden Sie die Sicherheitsressourcen und die Konfigurationsdatei Ihres Kerns herunter. Wählen Sie aufder Bestätigungsseite unter Download and store your Core's security resources (Herunterladen undSpeichern der Sicherheitsressourcen Ihres Kerns ) die Option Download these resources as a tar.gz(Diese Ressourcen als tar.gz herunterladen).

85

AWS IoT Greengrass EntwicklerhandbuchStarten von AWS IoT Greengrass auf dem Core-Gerät

Important

Laden Sie erst die Sicherheitsressourcen herunter, bevor Sie Finish (Fertigstellen) wählen.9. Nachdem Sie die Sicherheitsressourcen heruntergeladen haben, wählen Sie Finish (Fertigstellen).

Die Gruppenkonfigurationsseite wird in der Konsole angezeigt:

10. Laden Sie das AWS IoT Greengrass Core-Software- (p. 15)-Installationspaket herunter. Wählen Siedie CPU-Architektur und die Verteilung (und ggf. das Betriebssystem) aus, die Ihr Core-Gerät ambesten beschreibt. zum Beispiel:

• Laden Sie für einen Raspberry Pi das Paket "ARMv7l for Raspbian" herunter.• Wenn Sie eine Amazon EC2-Instance verwenden, laden Sie das x86_64 for Linux-Pakete herunter.• Wenn Sie ein NVIDIA Jetson TX2-Gerät verwenden, laden Sie das Paket „ARMv8 (AArch64) for

Ubuntu“ herunter.• Wenn Sie ein Intel Atom-Gerät verwenden, laden Sie das Paket "x86_64 for Linux" herunter.

Starten von AWS IoT Greengrass auf dem Core-GerätNote

Dieses Tutorial bietet Anweisungen zum Starten von AWS IoT Greengrass auf Ihrem RaspberryPi, Sie können aber jedes unterstützte Gerät verwenden.

86


Im vorherigen Schritt (p. 85) haben Sie zwei Dateien auf Ihren Computer heruntergeladen:

• greengrass-OS-architecture-1.9.3.tar.gz aus. Diese komprimierte Datei enthält die AWS IoTGreengrass Core-Software, die auf dem Core-Gerät ausgeführt wird.

• hash-setup.tar.gz. Diese komprimierte Datei enthält Sicherheitszertifikate, die eine sichereKommunikation zwischen AWS IoT und der Datei config.json ermöglichen, die spezifischeKonfigurationsinformationen für Ihren AWS IoT Greengrass-Core und den AWS IoT-Endpunkt enthält.

1. Wenn Sie die IP-Adresse Ihres AWS IoT Greengrass-Core-Geräts nicht kennen, öffnen Sie einTerminal auf dem AWS IoT Greengrass-Core-Gerät und führen den folgenden Befehl aus:

Note

Dieser Befehl gibt für einige Geräte möglicherweise nicht die richtige IP-Adresse zurück.Informationen zum Abrufen der IP-Adresse Ihres Geräts finden Sie in der Dokumentation.

hostname -I

2. Übertragen Sie die beiden komprimierten Dateien von Ihrem Computer auf das AWS IoT Greengrass-Core-Gerät. Wählen Sie Ihr Betriebssystem für Schritte, die zeigen, wie Sie Dateien an Ihr RaspberryPi-Gerät übertragen. Die Dateiübertragungsschritte variieren je nach Gerät oder EC2-Instance.

Note

Bei einem Rasberry PI lautet der Standardbenutzername pi und das Passwort istraspberry.Bei einem NVIDIA Jetson TX2-Gerät lautet der Standardbenutzername nvidia und dasPasswort ist nvidia.

Windows

Verwenden Sie zum Übertragen der komprimierten Dateien von Ihrem Computer zu einemRaspberry Pi-AWS IoT Greengrass-Core-Gerät ein Tool wie WinSCP oder den PuTTY-Befehlpscp. Für die Verwendung des pscp-Befehls öffnen Sie ein Eingabeaufforderungsfenster aufIhrem Computer und führen die folgenden Schritte aus:

cd path-to-downloaded-filespscp -pw Pi-password greengrass-OS-architecture-1.9.3.tar.gz pi@IP-address:/home/pipscp -pw Pi-password hash-setup.tar.gz pi@IP-address:/home/pi

zum Beispiel:

macOS

Öffnen Sie zum Übertragen der komprimierten Dateien von Ihrem Mac auf ein Raspberry AWS IoTGreengrass-Core-Gerät ein Terminal-Fenster auf Ihrem Computer und führen Sie die folgendenBefehle aus. path-to-downloaded-files ist in der Regel ~/Downloads.

Note

Sie werden möglicherweise aufgefordert, zwei Passwörter einzugeben. In diesem Fall giltdas erste Passwort für den sudo-Befehl des Mac, und das zweite ist das Passwort fürden Raspberry Pi.

87

https://winscp.net/eng/download.php

https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html


cd path-to-downloaded-filesscp greengrass-OS-architecture-1.9.3.tar.gz pi@IP-address:/home/piscp hash-setup.tar.gz pi@IP-address:/home/pi

UNIX-like system

Öffnen Sie zum Übertragen der komprimierten Dateien von Ihrem Computer auf ein RaspberryAWS IoT Greengrass-Core-Gerät ein Terminal-Fenster auf Ihrem Computer und führen Sie diefolgenden Befehle aus:

cd path-to-downloaded-filesscp greengrass-OS-architecture-1.9.3.tar.gz pi@IP-address:/home/piscp hash-setup.tar.gz pi@IP-address:/home/pi

Raspberry Pi web browser

Wenn Sie den Webbrowser des Raspberry Pi zum Herunterladen der komprimierten Dateienverwendeten, sollten sich die Dateien im Ordner ~/Downloads des Pi befinden (z. B. /home/pi/Downloads). Andernfalls sollten sich die komprimierten Dateien im Ordner ~ des Pi befinden(z. B. /home/pi).

3. Öffnen Sie ein Terminal auf dem AWS IoT Greengrass-Core-Gerät und navigieren Sie zu dem Ordnermit den komprimierten Dateien (z. B. cd /home/pi).

cd path-to-compressed-files

4. Dekomprimieren Sie die AWS IoT Greengrass Core-Software und die Sicherheitsressourcen.

• Der erste Befehl erstellt das /greengrass-Verzeichnis im Stammordner des AWS IoT Greengrass-Core-Geräts (mittels des Arguments -C /).

• Der zweite Befehl kopiert die Zertifikate in den /greengrass/certs-Ordner und dieconfig.json (p. 23)-Datei in den Ordner /greengrass/config (mittels des Arguments -C /greengrass).

sudo tar -xzvf greengrass-OS-architecture-1.9.3.tar.gz -C /sudo tar -xzvf hash-setup.tar.gz -C /greengrass

5. Überprüfen Sie die Dokumentation zu Server-Authentifizierung im AWS IoT-Core und wählen Sie dasentsprechende CA-Stammzertifikat. Wir empfehlen, Amazon Trust Services(ATS)-Endpunkte und CA-Zertifikate von ATS zu verwenden.-Zertifikate ermöglichen Ihrem Gerät die Kommunikation mit AWSIoT unter Verwendung des MQTT-Messaging-Protokolls über TLS.

Stellen Sie sicher, dass das AWS IoT Greengrass-Core-Gerät mit dem Internet verbunden ist, undladen Sie das Stamm-CA-Zertifikat auf Ihr Kerngerät herunter.

Important

Der Typ Ihres CA-Zertifikat muss dem Endpunkt entsprechen. Sie müssen ein CA-Stammzertifikat von ATS mit einem ATS-Endpunkt (empfohlen) oder ein CA-Stammzertifikatvon Verisign mit einem Legacy-Endpunkt verwendet. Nur einige AWS-Regionen unterstützenLegacy-Endpunkte. Weitere Informationen finden Sie unter the section called “Endpunktemüssen dem Zertifikattyp entsprechen” (p. 48).

Laden Sie für ATS-Endpunkte (empfohlen) das entsprechende CA-Stammzertifikat von ATS herunter.Im folgenden Beispiel wird AmazonRootCA1.pem heruntergeladen. Der Parameter wget -O ist derGroßbuchstabe O

88


AWS IoT Greengrass EntwicklerhandbuchModul 3 (Teil 1): Lambda-

Funktionen auf AWS IoT Greengrass

cd /greengrass/certs/sudo wget -O root.ca.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem

Note

Laden Sie für Legacy-Endpunkte ein CA-Stammzertifikat von Verisign herunter. Auch wennLegacy-Endpunkte für dieses Tutorial verwendet werden können, empfehlen wir, einen ATS-Endpunkt zu erstellen und ein CA-Stammzertifikat von ATS herunterzuladen.

cd /greengrass/certs/sudo wget -O root.ca.pem https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

Sie können den folgenden Befehl ausführen, um zu bestätigen, dass die Datei root.ca.pem nichtleer ist:

cat root.ca.pem

Wenn die Datei root.ca.pem leer ist, prüfen Sie die URL wget und versuchen Sie es erneut.6. Starten Sie AWS IoT Greengrass auf dem Core-Gerät.


Es sollte die Meldung Greengrass successfully started angezeigt werden. Notieren Sie sichdie PID.

Note

Informationen zur Einrichtung Ihres Core-Geräts für die Ausführung von AWS IoT Greengrassbeim Systemstart finden Sie unter the section called “Ausführen von Greengrass beiSystemstart” (p. 66).

Sie können den folgenden Befehl ausführen, um den ordnungsgemäßen Betrieb der AWS IoTGreengrass Core-Software (Daemon) zu bestätigen. Ersetzten Sie PID-number durch Ihre PID:

ps aux | grep PID-number

Es sollte ein Eintrag für die PID mit einem Pfad zum laufenden Greengrass-Daemon angezeigt werden(z. B. /greengrass/ggc/packages/1.9.3/bin/daemon). Bei Problemen mit dem Starten vonAWS IoT Greengrass vgl. Fehlersuche (p. 500).

Modul 3 (Teil 1): Lambda-Funktionen auf AWS IoTGreengrass

In diesem Modul erfahren Sie, wie Sie eine Lambda-Funktion konfigurieren und auf Ihrem AWSIoT Greengrass-Core-Gerät bereitstellen. Hier finden Sie Informationen zum MQTT-Messaging, zuAbonnements, Bereitstellungen auf AWS IoT Greengrass und zu Konfigurationen von Lambda-Funktionen.

Teil 1 dieses Moduls veranschaulicht, wie Sie eine Lambda-Funktion auf dem AWS IoT Greengrass-Corebereitstellen, die "Hello World"-Nachrichten an die AWS IoT Greengrass-Cloud sendet. Teil 2 (p. 103)

89

AWS IoT Greengrass EntwicklerhandbuchErstellen und Verpacken einer Lambda-Funktion

behandelt die Unterschiede zwischen On-Demand- und langlebigen Lambda-Funktionen in der AWS IoTGreengrass-Core.

Bevor Sie beginnen, sollten Sie sicherstellen, dass Sie Modul 1 (p. 70) und Module 2 (p. 81)abgeschlossen haben und über ein einsatzbereites AWS IoT Greengrass-Core-Gerät verfügen.

Modul 3 (Teil 1) (p. 89) und Modul 3 (Teil 2) (p. 103) sollten jeweils ca. 30 Minuten in Anspruchnehmen.

Themen• Erstellen und Verpacken einer Lambda-Funktion (p. 90)• Konfigurieren der Lambda-Funktion für AWS IoT Greengrass (p. 94)• Bereitstellen von Cloud-Konfigurationen für ein AWS IoT Greengrass Core-Gerät (p. 100)• Überprüfen Sie, ob die Lambda-Funktion auf dem Gerät ausgeführt wird (p. 101)

Erstellen und Verpacken einer Lambda-FunktionZur Ausführung auf einer AWS IoT Greengrass-Core erfordert eine Python-Lambda-Funktion den AWSIoT Greengrass-Core-SDK für Python. In diesem Tutorial fügen Sie den Ordner greengrasssdk in dasBereitstellungspaket für die Lambda-Funktion ein.

Note

Wenn Sie Python-Lambda-Funktionen ausführen, können Sie auch pip verwenden, um dasAWS IoT Greengrass-Core-SDK für Python auf dem Core-Gerät zu installieren. Anschließendkönnen Sie Ihre Funktionen bereitstellen, ohne das SDK im Lambda-Funktionsbereitstellungspaketeinschließen zu müssen. Weitere Informationen finden Sie unter greengrasssdk.

In diesem Abschnitt führen Sie folgende Schritte aus:

• Laden Sie die AWS IoT Greengrass-Core-SDK für Python auf Ihren Computer herunter (nicht auf dasAWS IoT Greengrass-Core-Gerät). Laden Sie für dieses Tutorial das SDK auf GitHub von der Seite AWSIoT GreengrassCore-SDK (p. 21)-Downloads herunter.

• Nehmen Sie die Python-Lambda-Funktion (mit dem Namen greengrassHelloWorld.py) aus demheruntergeladenen SDK.

• Erstellen Sie ein Bereitstellungspaket für die Lambda-Funktion mit dem Namenhello_world_python_lambda.zip, das greengrassHelloWorld.py und den greengrasssdk-Ordner enthält.

• Verwenden Sie die Lambda-Konsole, um das hello_world_python_lambda.zip-Pakethochzuladen.

• Verwenden Sie die AWS IoT-Konsole, um das Paket (während der Gruppenbereitstellung) auf das AWSIoT Greengrass-Core-Gerät zu übertragen.

1. Sie können AWS IoT Greengrass-Core-SDK für Python auf der AWS IoT GreengrassCore-SDK (p. 21)-Downloads-Seite herunterladen.

2. Entpacken Sie das heruntergeladene Paket, um den Code der Lambda-Funktion und das SDK zuerhalten.

Die Lambda-Funktion in diesem Modul verwendet Folgendes:

• Die Datei greengrassHelloWorld.py in examples\HelloWorld. Dies ist Ihr Lambda-Funktionscode.

• Der Ordner greengrasssdk. Dies ist das SDK.

90




Der folgende Code stammt aus der Datei greengrassHelloWorld.py. (Aus Platzgründen wurdenalle Codekommentare entfernt.) Beachten Sie, dass die Funktion alle fünf Sekunden eine von zweimöglichen Nachrichten im Thema hello/world veröffentlicht.

import greengrasssdkimport platformfrom threading import Timerimport time

client = greengrasssdk.client('iot-data')my_platform = platform.platform()

def greengrass_hello_world_run(): if not my_platform: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core.') else: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core running on platform: {}'.format(my_platform)) Timer(5, greengrass_hello_world_run).start()

greengrass_hello_world_run()

def function_handler(event, context): return

3. Kopieren Sie greengrasssdk in den OrdnerHelloWorld, der die DateigreengrassHelloWorld.py enthält.

4. Um das Funktionsbereitstellungspaket Lambda zu erstellen, speichern Sie die DateigreengrassHelloWorld.py und den Ordner greengrasssdk in einer komprimierten ZIP-Datei mitdem Namen hello_world_python_lambda.zip. Die .py-Datei und der SDK-Ordner müssen sichim Root des Verzeichnisses befinden.

Für UNIX-ähnliche Systeme (einschließlich des Mac-Terminals) können Sie den folgenden Befehlverwenden, um die Datei und den Ordner zu verpacken:

sudo zip -r hello_world_python_lambda.zip greengrasssdk greengrassHelloWorld.py

Note

Je nach Ihrer Verteilung müssen Sie möglicherweise zuerst zip installieren (z. B. durchAusführen von sudo apt-get install zip). Der Installationsbefehl kann für IhreVerteilung abweichen.

Nun können Sie Ihre Lambda-Funktion erstellen und das Bereitstellungspaket hochladen.5. Öffnen Sie die Lambda-Konsole und wählen Sie Create function.6. Wählen Sie Author from scratch aus.7. Geben Sie Ihrer Funktion den Namen Greengrass_HelloWorld und richten Sie die verbleibenden

Felder wie folgt ein:

• Wählen Sie für Runtime die Option Python 2.7 aus.

91


• Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eineAusführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nichtvon AWS IoT Greengrass verwendet.

Wählen Sie Create function (Funktion erstellen).

8. Laden Sie das Bereitstellungspaket für Ihre Lambda-Funktion hoch:

a. Legen Sie auf der Registerkarte Configuration (Konfiguration) unter Function code(Funktionscode) die folgenden Felder fest:

• Wählen Sie für Code entry type (Codeeingabetyp) die Option Upload a .ZIP file (Eine ZIP-Dateihochladen) aus.

• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie unter Handler greengrassHelloWorld.function_handler ein.

b. Wählen Sie Upload (Hochladen) und anschließend hello_world_python_lambda.zip. (DieGröße Ihrer hello_world_python_lambda.zip-Datei kann von der hier dargestellten Größeabweichen.)

c. Wählen Sie Save aus.

92


Note

Die Schaltfläche Test auf der AWS Lambda-Konsole kann für diese Funktion nichtverwendet werden. Das AWS IoT Greengrass Core SDK enthält keine Module, dieerforderlich sind, um Ihre Greengrass Lambda-Funktionen unabhängig in der AWSLambda-Konsole auszuführen. Diese Module (beispielsweise greengrass_common)werden auf die Funktionen angewendet, nachdem sie auf Greengrass Core bereitgestelltwurden.

Tip

Um Ihren hochgeladenen Code anzuzeigen, wählen Sie Edit code inline (Code internbearbeiten) im Menü Code entry type (Codeeingabetyp).

9.Veröffentlichen der Lambda-Funktion.

a. Wählen Sie im Menü Actions (Aktionen) die Option Publish new version (Neue Versionveröffentlichen) aus.

b. Geben Sie unter Version description (Versionsbeschreibung) den Wert First version ein undwählen Sie dann Publish (Veröffentlichen) aus.

10.Erstellen Sie einen Alias für die Lambda-Funktionsversion:

Note

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nachVersion referenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, dadie Abonnementtabelle oder Gruppendefinition bei der Aktualisierung des Funktionscodesnicht geändert werden müssen. Stattdessen lassen Sie den Alias einfach auf die neueFunktionsversion verweisen.

a. Wählen Sie unter Actions (Aktionen) die Option Create alias (Alias erstellen) aus.

93

https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der Lambda-Funktion für AWS IoT Greengrass

b. Geben Sie dem Alias den Namen GG_HelloWorld, setzen Sie die Version auf 1 (entsprechendder soeben veröffentlichten Version) und wählen Sie dann Create.

Note

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen.

Konfigurieren der Lambda-Funktion für AWS IoTGreengrassSie können jetzt Ihre Lambda-Funktion für AWS IoT Greengrass konfigurieren. In diesem Schrittkonfigurieren Sie auch ein Abonnement, mit dem die Lambda-Funktion mit AWS IoT kommunizieren unddie lokale Protokollierung für die Greengrass-Gruppe konfigurieren kann.

1. Wählen Sie in der AWS IoT-Konsole, unter Greengrass, Groups und dann die Gruppe, die Sie in Modul2 (p. 81) erstellt haben.

2. Klicken Sie auf der Gruppenkonfigurationsseite auf Lambdas und wählen Sie dann Add Lambda.

94


3. Wählen Sie Use existing Lambda aus.

4. Suchen Sie nach dem Namen der im vorherigen Schritt erstellten Lambda (Greengrass_HelloWorld,nicht der Aliasname), wählen Sie ihn aus, und wählen Sie dann Next:

5. Wählen Sie für die Version Alias: GG_HelloWorld und dann Finish. Sie sollten dann die FunktionGreengrass_HelloWorld Lambda in Ihrer Gruppe sehen, unter Verwendung des Alias GG_HelloWorld.

6. Wählen Sie die Auslassungspunkte (…) und dann Konfiguration bearbeiten aus:

95


7. Führen Sie auf der Seite Group-specific Lambda configuration (Gruppenspezifische Lambda-Konfiguration) die folgenden Änderungen durch:

• Legen Sie für Timeout 25 Sekunden fest. Diese Lambda-Funktion geht vor jedem Aufruf 20Sekunden in den Ruhezustand.

• Wählen Sie für Lambda-Lebenszyklus die Option Diese Funktion langlebig einstellen undunbegrenzt ausführen aus.

Note

Eine langdauernde Lambda-Funktion startet automatisch nach dem Start von AWS IoTGreengrass und wird in ihrem eigenen Container („Sandbox“) ausgeführt. Dies steht imGegensatz zu einer On-Demand-Lambda-Funktion, die nach einem Aufruf startet und beendetwird, wenn keine weiteren Aufgaben mehr auszuführen sind. Weitere Informationen finden Sieunter the section called “Lebenszykluskonfiguration” (p. 189).

8. Übernehmen Sie die Standardwerte für alle anderen Felder, z. B. Run as (Ausführen als),Containerization (Containerisierung) und Input payload data type/(Eingabe-Nutzlast-Datentyp), undklicken Sie auf Update (Aktualisieren) um Ihre Änderungen zu speichern. Weitere Informationen zuLambda-Funktionseigenschaften finden Sie unter the section called “Steuern der Greengrass Lambda-Funktionsausführung” (p. 179).

96


Erstellen Sie als Nächstes ein Abonnement, das es Lambda ermöglicht, MQTT-Nachrichten an AWSIoT zu senden.

Eine Greengrass Lambda-Funktion kann MQTT-Nachrichten mit folgenden Elementen austauschen:

• Geräte (p. 8) in der Greengrass-Gruppe.• Konnektoren (p. 297) in der Gruppe.• Andere Lambda-Funktionen in der Gruppe.• AWS IoT• Service des lokalen Schattens. Weitere Informationen finden Sie unter the section called “Modul 5:

Interaktion mit Geräteschatten” (p. 129).

Die Gruppe verwendet Abonnements, um zu steuern, wie diese Entitäten miteinander kommunizierenkönnen sollen. Abonnements bieten vorhersehbare Interaktionen und eine Sicherheitsebene.

Ein Abonnement besteht aus einer Quelle, einem Ziel und einem Thema. Die Quelle beschreibtden Ursprung der Nachricht. Das Ziel beschreibt die Destination der Nachricht. Mithilfe des Themaskönnen Sie die Daten filtern, die von der Quelle ans Ziel gesendet werden. Quelle oder Ziel können einGreengrass-Gerät, eine Lambda-Funktion, ein Konnektor, ein Geräteschatten oder AWS IoT sein.

Note

Ein Abonnement wird in dem Sinne weitergeleitet, dass Nachrichten in eine bestimmteRichtung fließen: von der Quelle zum Ziel. Wenn Sie eine Zwei-Wege-Kommunikationermöglichen möchten, müssen Sie zwei Abonnements einrichten.

Die Lambda-Funktion Greengrass_HelloWorld sendet Nachrichten nur an das Thema hello/world im AWS IoT, wie im folgenden greengrassHelloWorld.py-Codeausschnitt veranschaulicht.

def greengrass_hello_world_run(): if not my_platform: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core.') else: client.publish(topic='hello/world', payload='Hello world! Sent from Greengrass Core running on platform: {}'.format(my_platform)) Timer(5, greengrass_hello_world_run).start()

Da die Lambda-Funktion Greengrass_HelloWorld Nachrichten nur an das Thema hello/worldim AWS IoT sendet, müssen Sie nur ein Abonnement von der Lambda-Funktion zum AWS IoTerstellen, wie nachfolgend veranschaulicht.

9. Wählen Sie auf der Gruppenkonfigurationsseite Subscriptions (Abonnements) und wählen Sie dannAdd your first Subscription (Ihr erstes Abonnement hinzufügen) aus.

97

http://mqtt.org/


10. Wählen Sie im Feld Eine Quelle auswählen die Option Auswählen aus. Wählen Sie auf derRegisterkarte Lambdas die Option Greengrass_HelloWorld als Quelle aus.

11. Wählen Sie im Feld Ein Ziel auswählen die Option Auswählen aus. Wählen Sie dann auf derRegisterkarte Service die Option IoT Cloud aus und klicken Sie auf Next.

98


12. Geben Sie unter Topic filter (Themenfilter) den Wert hello/world ein und wählen Sie dann Next(Weiter) aus.

13. Klicken Sie auf Finish.14. Konfigurieren Sie die Einstellungen für die Protokollierung der Gruppe. Für dieses Tutorial

konfigurieren Sie AWS IoT Greengrass-Systemkomponenten und benutzerdefinierte Lambda-Funktionen, um Protokolle in das Dateisystem des Core-Geräts zu schreiben. Weitere Informationenfinden Sie unter Überwachung (p. 444).

a. Wählen Sie auf der Gruppenkonfigurationsseite die Option Settings (Einstellungen) aus.b. Wählen Sie in Local logs configuration (Konfiguration lokaler Protokolle), die Option Edit

(Bearbeiten) aus.c. Wählen Sie auf der Seite Configure Group logging (Gruppenprotokollierung konfigurieren) die

Option Add another log type (Einen weiteren Protokolltyp hinzufügen) aus.d. Wählen Sie in „Event source (Ereignisquelle)“ User Lambdas (Benutzer-Lambdas) und

Greengrass-System (Greengrass-System) aus und klicken Sie dann auf Update (Aktualisieren).e. Behalten Sie die Standardwerte für die Protokollierungsebene und Kontingentsgrenze bei. Wählen

Sie anschließend Save (Speichern) aus.

99

AWS IoT Greengrass EntwicklerhandbuchBereitstellen von Cloud-Konfigurationen für ein Core-Gerät

Bereitstellen von Cloud-Konfigurationen für ein AWSIoT Greengrass Core-Gerät1. Stellen Sie sicher, dass Ihr AWS IoT Greengrass-Core-Gerät mit dem Internet verbunden ist.

(Überprüfen Sie z. B., ob Sie erfolgreich zu einer Website navigieren können.)2. Stellen Sie sicher, dass der AWS IoT Greengrass-Daemon auf Ihrem Code-Gerät ausgeführt wird.

Führen Sie die folgenden Befehle in Ihrem Core-Geräte-Terminal aus.



Wenn die Ausgabe einen root-Eintrag für /greengrass/ggc/packages/1.9.3/bin/daemon enthält, dann wird der Daemon ausgeführt.

b. So starten Sie den Daemon:


Jetzt können Sie die Lambda-Funktion und die entsprechende Abonnementkonfigurationen auf IhremAWS IoT Greengrass-Core-Gerät bereitstellen.

3. Wählen Sie in der AWS IoT-Konsole auf der Gruppenkonfigurationsseite unter Aktionen die OptionBereitstellen aus.

4. Wählen Sie auf der Seite Configure how devices discover your core die Option Automatic detection.Damit können Geräte automatisch Core-Verbindungsinformationen abrufen, z. B. die IP-Adresse,DNS und die Portnummer. Die automatische Ermittlung wird empfohlen, aber AWS IoT Greengrassunterstützt auch manuell angegebene Endpunkte. Sie werden nur bei der ersten Bereitstellung derGruppe zur Angabe der Ermittlungsmethode aufgefordert.

5. Wenn Sie aufgefordert werden, wählen Sie auf der Seite Die Berechtigung für den Zugriff auf andereServices erteilen die Option Berechtigung erteilen aus. Damit wird die Greengrass-Servicerollekonfiguriert, mit der AWS IoT Greengrass in Ihrem Namen auf andere AWS-Services zugreifen kann.Diese Rolle ist erforderlich, damit die Bereitstellungen erfolgreich durchgeführt werden können.Weitere Informationen finden Sie unter the section called “Greengrass-Servicerolle” (p. 432).

100

AWS IoT Greengrass EntwicklerhandbuchÜberprüfen Sie, ob die Lambda-

Funktion auf dem Gerät ausgeführt wird

Der erste Bereitstellungsvorgang kann einige Minuten dauern. Nachdem die Bereitstellung abgeschlossenist, sollten Sie Successfully completed (Erfolgreich abgeschlossen) in der Spalte Status der SeiteDeployments (Bereitstellungen) sehen:

Note

Der Bereitstellungsstatus wird ebenfalls im Header der Seite unter dem Namen der Gruppeangezeigt.

Hilfe zur Problembehebung finden Sie unter Fehlersuche (p. 500).

Überprüfen Sie, ob die Lambda-Funktion auf demGerät ausgeführt wird1. Wählen Sie im Navigationsbereich der AWS IoT-Konsole die Option Test aus.

101

AWS IoT Greengrass EntwicklerhandbuchÜberprüfen Sie, ob die Lambda-

Funktion auf dem Gerät ausgeführt wird

2. Wählen Sie Subscribe to topic (Thema abonnieren) aus und konfigurieren Sie die folgenden Felder:

• Geben Sie für Abonnementthema hello/world ein. (Wählen Sie noch nicht Thema abonnierenaus.)

• Wählen Sie für Servicequalität 0 aus.• Wählen Sie für MQTT-Nutzlast-Anzeige die Option Nutzlasten als Zeichenfolgen anzeigen aus.

3. Wählen Sie Thema abonnieren aus.

Wenn die Lambda-Funktion auf dem Gerät ausgeführt wird, veröffentlicht sie Nachrichten im Themahello/world, ähnlich wie folgt:

102

AWS IoT Greengrass EntwicklerhandbuchModul 3 (Teil 2): Lambda-

Funktionen auf AWS IoT Greengrass

Obwohl die Lambda-Funktion weiterhin MQTT-Nachrichten an das Thema hello/world sendet,beenden Sie den AWS IoT Greengrass-Daemon nicht. Bei den verbleibenden Modulen wird nämlich davonausgegangen, dass die Funktion ausgeführt wird.

Sie können die Funktion und das Abonnement aus der Gruppe löschen:

• Wählen Sie auf der Seite Lambdas die Auslassungspunkte (…) und anschließend Remove function(Funktion entfernen) aus.

• Wählen Sie auf der Seite Subscriptions (Abonnements) die Auslassungspunkte (…) und anschließendDelete (Löschen) aus.

Die Funktion und das Abonnement werden während der nächsten Gruppenbereitstellung vom Kernentfernt.

Modul 3 (Teil 2): Lambda-Funktionen auf AWS IoTGreengrass

In diesem Modul erfahren Sie, wie Sie eine Lambda-Funktion konfigurieren und auf Ihrem AWSIoT Greengrass-Core-Gerät bereitstellen. Hier finden Sie Informationen zum MQTT-Messaging, zuAbonnements, Bereitstellungen auf AWS IoT Greengrass und zu Konfigurationen von Lambda-Funktionen.

Teil 1 (p. 89) dieses Moduls beschrieb, wie Sie eine Lambda-Funktion auf einem AWS IoT Greengrass-Core bereitstellen, die "Hello World"-Nachrichten an die AWS IoT-Cloud sendet. Dieser Teil untersuchtdie Unterschiede zwischen On-Demand- und langlebigen Lambda-Funktionen, die auf der AWS IoTGreengrass-Core ausgeführt werden.

103

AWS IoT Greengrass EntwicklerhandbuchErstellen und Verpacken der Lambda-Funktion

Bevor Sie beginnen, stellen Sie sicher, dass Sie Modul 1 (p. 70), Modul 2 (p. 81)und Modul 3(Teil 1) (p. 89) abgeschlossen haben.

Dieses Modul sollte etwa 30 Minuten in Anspruch nehmen.

Themen• Erstellen und Verpacken der Lambda-Funktion (p. 104)• Konfigurieren langlebiger Lambda-Funktionen für AWS IoT Greengrass (p. 106)• Testen von langlebigen Lambda-Funktionen (p. 107)• Testen von On-Demand-Lambda-Funktionen (p. 112)

Erstellen und Verpacken der Lambda-Funktion1. Laden Sie den Lambda-Funktionscode auf Ihren Computer herunter (nicht auf das Greengrass Core-

Gerät):

a. Öffnen Sie in einem Webbrowser die Datei greengrassHelloWorldCounter.py auf GitHub.b. Wählen Sie Raw (Roh) um die unformatierte Version der Datei zu öffnen.

c. Verwenden Sie Ctrl + S (oder Command + S auf einem Mac) zum Speichern einer Kopie dergreengrassHelloWorldCounter.py-Datei. Speichern Sie die Datei in einem Ordner, der dengreengrasssdk-Ordner enthält.

Note

Für UNIX-Systeme können Sie den folgenden Terminalbefehl ausführen, um die DateigreengrassHelloWorldCounter.py herunterzuladen:

wget https://raw.githubusercontent.com/aws-samples/aws-greengrass-samples/master/hello-world-counter-python/greengrassHelloWorldCounter.py

2. Packen Sie die greengrassHelloWorldCounter.py-Datei mit dem SDK in eine .zip-Datei, wie in Modul 3 (Teil 1) (p. 89) beschrieben. Geben Sie dem Paket den Namenhello_world_counter_python_lambda.zip.

3. Erstellen Sie in der Lambda-Konsole eine Python 2.7-Funktion mit dem NamenGreengrass_HelloWorld_Counter, wie in Modul 3 (Teil 1) (p. 89) beschrieben. Sie können dievorhandene Rolle verwenden.

4. Laden Sie das Bereitstellungspaket Ihrer Lambda-Funktion hoch:


104

https://github.com/aws-samples/aws-greengrass-samples/blob/master/hello-world-counter-python/greengrassHelloWorldCounter.py

AWS IoT Greengrass EntwicklerhandbuchErstellen und Verpacken der Lambda-Funktion


• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie unter Handler greengrassHelloWorldCounter.function_handler ein.

b. Wählen Sie Upload (Hochladen) und anschließendhello_world_counter_python_lambda.zip.

c. Wählen Sie oben auf der Seite Save.

Note


5. Veröffentlichen Sie die erste Version der Funktion:

a. Wählen Sie im Menü Actions (Aktionen) die Option Publish new version (Neue Versionveröffentlichen) aus. Geben Sie für Version description (Versionsbeschreibung) First versionein.

b. Wählen Sie Publish aus.6. Erstellen Sie einen Alias für die Funktionsversion:

a. Wählen Sie im Menü Actions (Aktionen) die Option Create alias (Alias erstellen) und legen Sie diefolgenden Werte fest:

• Geben Sie unter Name GG_HW_Counter ein.• Wählen Sie für Version die Option 1.

b. Wählen Sie Create aus.

105

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren langlebiger Lambda-Funktionen für AWS IoT Greengrass

Aliasse erstellen eine einzelne Entität für Ihre Lambda-Funktion, die von AWS IoT Greengrass-Geräten abonniert werden kann, ohne bei jeder Änderung der Funktion Abonnements mit Lambda-Versionsnummern aktualisieren zu müssen.

Konfigurieren langlebiger Lambda-Funktionen für AWSIoT GreengrassSie können jetzt Ihre Lambda-Funktion für AWS IoT Greengrass konfigurieren.

1. Wählen Sie in der AWS IoT-Konsole, unter Greengrass, Groups und dann die Gruppe, die Sie in Modul2 (p. 81) erstellt haben.

2. Klicken Sie auf der Gruppenkonfigurationsseite auf Lambdas und wählen Sie dann Add Lambda.3. Wählen Sie auf der Seite Add a Lambda to your Greengrass Group die Option Use existing Lambda

aus.4. Wählen Sie auf der Seite Use existing Lambda (Vorhandenes Lambda verwenden) die Option

Greengrass_HelloWorld_Counter und anschließend Next (Weiter) aus.

5. Wählen Sie auf der Seite Select a Lambda version die Option Alias: GG_HW_Counter und dann Finish.6. Wählen Sie auf der Seite Lambdas im Menü … die Option Edit Configuration (Konfiguration

bearbeiten) aus.

7. Bearbeiten Sie auf der Konfigurationsseite die folgenden Eigenschaften:

• Legen Sie für Timeout 25 Sekunden fest. Diese Lambda-Funktion geht vor jedem Aufruf 20Sekunden in den Ruhezustand.

• Wählen Sie für Lambda-Lebenszyklus die Option Diese Funktion langlebig einstellen undunbegrenzt ausführen aus.

• Akzeptieren Sie die Standardwerte für alle anderen Felder, wie z. B. Run as (Ausführen als) undContainerization (Containerisierung).

106

AWS IoT Greengrass EntwicklerhandbuchTesten von langlebigen Lambda-Funktionen

8. Wählen Sie Update aus.

Testen von langlebigen Lambda-FunktionenEine langlebige (p. 189) Lambda-Funktion wird nach dem Start des AWS IoT Greengrass-Coreautomatisch gestartet und in einem einzelnen Container (oder einer Sandbox) ausgeführt. Alle Variablenoder Vorverarbeitungen, die außerhalb des Funktionshandlers definiert sind, werden für jeden Aufruf desFunktionshandlers beibehalten. Mehrere Aufrufe werden so lange in eine Warteschlange gesetzt, bis dieAusführung vorheriger Aufrufe abgeschlossen ist.

Der folgende Code stammt aus der Datei greengrassHelloWorldCounter.py. (Codekommentarewurden aus Platzgründen entfernt.) Diese Lambda Funktion ähnelt der greengrassHelloWorld.pyFunktion aus Teil 1 dieses Moduls, allerdings definiert sie eine my_counter-Variable außerhalb desFunktionshandlers.

import greengrasssdkimport platformimport timeimport json

client = greengrasssdk.client('iot-data')

my_platform = platform.platform()

my_counter = 0

def function_handler(event, context): global my_counter my_counter = my_counter + 1 if not my_platform: client.publish( topic='hello/world/counter',

107


payload=json.dumps({'message': 'Hello world! Sent from Greengrass Core. Invocation Count: {}'.format(my_counter)}) ) else: client.publish( topic='hello/world/counter', payload=json.dumps({'message': 'Hello world! Sent from Greengrass Core running on platform: {}. Invocation Count: {}' .format(my_platform, my_counter)}) ) time.sleep(20) return

In diesem Schritt erstellen Sie Abonnements, die den MQTT-Nachrichtenaustausch zwischen Lambdaund der AWS IoT-Funktion ermöglichen. Im Anschluss daran stellen Sie die Gruppe bereit und testen dieFunktion.

1. Wählen Sie auf der Gruppenkonfigurationsseite die Option Subscriptions (Abonnements), und wählenSie dann Add Subscription (Abonnement hinzufügen)

2. Wählen Sie unter Eine Quelle auswählen die Registerkarte Lambdas und dannGreengrass_HelloWorld_Counter aus.

3. Wählen Sie unter Ein Ziel auswählen die Registerkarte Services und dann IoT Cloud aus und klickenSie auf Weiter.

4. Geben Sie für Topic filter (Themenfilter) die Zeichenfolge hello/world/counter ein. Klicken Sie aufWeiter und danach auf Beenden.

108


Dieses einzelne Abonnement betrifft nur eine Richtung: von der Greengrass_HelloWorld_CounterLambda-Funktion zum AWS IoT. Um diese Lambda-Funktion über die Cloud aufrufen (oder auslösen)zu können, müssen Sie ein Abonnement in der entgegengesetzten Richtung erstellen.

5. Befolgen Sie die Schritte 1–4, um ein weiteres Abonnement hinzuzufügen, das die folgenden Werteverwendet. Dadurch können Sie die Lambda-Funktion für den Empfang von Nachrichten vom AWSIoT einrichten. Dieses Abonnement wird später eingesetzt, wenn Sie von der Konsole aus eineTestnachricht an die Funktion senden.

• Wählen Sie für die Quelle Services und dann IoT Cloud aus.• Wählen Sie für das Ziel Lambdas und dann Greengrass_HelloWorld_Counter aus.• Geben Sie für den Themenfilter hello/world/counter/trigger ein.

In diesem Themenfilter wird die Erweiterung /trigger verwendet, da Sie zwei Abonnements erstellthaben, die sich nicht gegenseitig beeinträchtigen sollen.

6. Stellen Sie sicher, dass der AWS IoT Greengrass-Daemon, wie in Bereitstellen von Cloud-Konfigurationen für ein Core-Gerät (p. 100) beschrieben, ausgeführt wird.

7. Wählen Sie auf der Gruppenkonfigurationsseite unter Actions (Aktionen) die Option Deploy(Bereitstellen) aus.

109


Hiermit wird die Gruppenkonfiguration für Ihr AWS IoT Greengrass-Core-Gerät bereitgestellt. Hilfe zurProblembehebung finden Sie unter Fehlersuche (p. 500).

8. Nachdem die Bereitstellung abgeschlossen ist, kehren Sie zur AWS IoT-Konsole-Startseite zurück undwählen Sie Test aus.

9. Konfigurieren Sie die folgenden Felder:

• Geben Sie für Abonnementthema hello/world/counter ein.• Wählen Sie für Servicequalität 0 aus.• Wählen Sie für MQTT-Nutzlast-Anzeige die Option Nutzlasten als Zeichenfolgen anzeigen aus.


Anders als in Teil 1 (p. 89) dieses Moduls sollten Sie nach dem Abonnement von hello/world/counter keine Nachrichten sehen. Dies liegt daran, dass der greengrassHelloWorldCounter.pyCode, der im hello/world/counter-Thema veröffentlicht, sich innerhalb des Funktionshandlersbefindet, der nur ausgeführt wird, wenn die Funktion aufgerufen wird.

In diesem Modul haben Sie die Greengrass_HelloWorld_Counter- Lambda-Funktion so konfiguriert,dass sie aufgerufen wird, wenn sie eine MQTT-Nachricht zum hello/world/counter/triggerThema erhält. Sie können dies überprüfen, indem Sie die zugehörigen Abonnements überprüfen:

110


Das Greengrass_HelloWorld_Counter-zur-IoT Cloud-Abonnement ermöglicht es der Funktion,Nachrichten an das AWS IoT zu senden, die das hello/world/counter-Thema betreffen. Das IoTCloud-zur-Greengrass_HelloWorld_Counter-Abonnement ermöglicht es dem AWS IoT, Nachrichten andie Funktion zu senden, die das hello/world/counter/trigger-Thema betreffen.

Note

Greengrass_HelloWorld_Counter ignoriert den Inhalt der empfangenen Nachrichten.Sie führt lediglich den Code im function_handler aus, wodurch eine Nachrichtan das hello/world/counter-Thema gesendet wird. Unter dem Code-Beispiel greengrassHelloWorldCounter.py (p. 107) können Sie diesen Code überprüfen.

11. Um den langlebigen Lebenszyklus zu überprüfen, rufen Sie die Lambda-Funktion auf, indem Sieeine Nachricht im hello/world/counter/trigger-Thema veröffentlichen. Sie können dieStandardnachricht verwenden.

Jedes Mal, wenn eine Nachricht im Thema hello/world/counter/trigger veröffentlicht wird, wirddie my_counter-Variable um einen Schritt erhöht. Die Anzahl der Aufrufe wird in den von der Lambda-Funktion gesendeten Nachrichten angegeben. Da der Funktionshandler einen 20-sekündigen Ruhezyklusbeinhaltet (time.sleep(20)), führt ein wiederholtes Auslösen des Handlers dazu, dass die Antwortenvom AWS IoT Greengrass-Core in eine Warteschlange gestellt werden.

111

AWS IoT Greengrass EntwicklerhandbuchTesten von On-Demand-Lambda-Funktionen

Testen von On-Demand-Lambda-FunktionenEine On-Demand (p. 189)-Lambda-Funktion entspricht funktional einer Cloud-basierten AWS Lambda-Funktion. Es können mehrere Aufrufe einer On-Demand-Lambda-Funktion parallel ausgeführt werden.Ein Aufruf der Lambda-Funktion erstellt einen separaten Container für die Verarbeitung der Aufrufeoder verwendet einen vorhandenen Container neu, wenn die Ressourcen dies zulassen. Variablen oderVorverarbeitungen, die außerhalb des Funktionshandlers definiert sind, werden nicht beibehalten, wennContainer erstellt werden.

1. Wählen Sie auf der Gruppenkonfigurationsseite die Option Lambdas aus.2. Wählen Sie für die Greengrass_HelloWorld_Counter Lambda-Funktion die Option Edit Configuration.

112


3. Wählen Sie unter Lambda Lifecycle (Lambda-Lebenszyklus) die Option On-demand Function (On-demand-Funktion) aus und klicken Sie dann auf Update (Aktualisieren).



5. Nachdem die Bereitstellung abgeschlossen ist, kehren Sie zur AWS IoT-Konsole-Startseite zurück undwählen Sie Test aus.

6. Konfigurieren Sie die folgenden Felder:

• Geben Sie für Abonnementthema hello/world/counter ein.• Wählen Sie für Servicequalität 0 aus.• Wählen Sie für MQTT-Nutzlast-Anzeige die Option Nutzlasten als Zeichenfolgen anzeigen aus.

113



Note

Sie sollten nach dem Abonnement keine Nachrichten sehen.8. Um den On-demand-Lebenszyklus zu überprüfen, rufen Sie die Funktion auf, indem Sie eine Nachricht

im hello/world/counter/trigger-Thema veröffentlichen. Sie können die Standardnachrichtverwenden.

a. Wählen Sie schnell dreimal hintereinander die Schaltfläche Publish to topic (Veröffentlichung imThema) aus, wobei zwischen jedem Drücken der Taste nur fünf Sekunden liegen sollten.

Jede Veröffentlichung ruft den Funktionshandler auf und erstellt einen neuen Container für jedenAufruf. Die Zahl der Aufrufe wird durch das dreimalige Auslösen der Funktion nicht erhöht, da jedeOn-Demand-Lambda;-Funktion über einen eigenen Container bzw. eine eigene Sandbox verfügt.

114


b. Wählen Sie nach ungefähr 30 Sekunden die Option Publish to topic (Veröffentlichung im Thema)aus. Der Zahl der Aufrufe sollte sich auf 2 erhöhen. Dies zeigt, dass ein Container, der durcheinen vorherigen Aufruf erstellt wurde, erneut verwendet wird, und Variablen, die außerhalb desFunktionshandlers vorab verarbeitet wurden, gespeichert wurden.

115

AWS IoT Greengrass EntwicklerhandbuchModul 4: Interaktion mit Geräten ineiner AWS IoT Greengrass-Gruppe

Sie sollten nun die zwei Arten von Lambda-Funktionen, die auf der AWS IoT Greengrass-Core ausgeführtwerden können, verstanden haben. Im nächsten Modul, Modul 4 (p. 116), erfahren Sie, wie Geräte ineiner AWS IoT Greengrass-Gruppe interagieren können.

Modul 4: Interaktion mit Geräten in einer AWS IoTGreengrass-Gruppe

n diesem Modul erfahren Sie, wie AWS IoT-Geräte mit einem AWS IoT Greengrass-Core-Gerätverbunden werden und kommunizieren können. AWS IoT-Geräte, die mit einer AWS IoT Greengrass-Core verbunden sind, sind Teil einer AWS IoT Greengrass-Gruppe und können am AWS IoT Greengrass-Programmierparadigma teilnehmen. In diesem Modul sendet ein Greengrass-Gerät eine „Hello World“-Nachricht an ein anderes Gerät in der Greengrass-Gruppe.

Bevor Sie beginnen, stellen Sie sicher, dass Sie Modul 1 (p. 70), Modul 2 (p. 81), Modul 3(Teil 1) (p. 89) und Modul 3 (Teil 2) (p. 103) abgeschlossen haben. Sie benötigen keine anderenKomponenten oder Geräte.


Themen• Erstellen von AWS IoT-Geräten in einer AWS IoT Greengrass-Gruppe (p. 117)• Konfigurieren von Abonnements (p. 121)• Installieren der AWS IoT-Geräte-SDK für Python (p. 122)• Testen der Kommunikation (p. 126)

116

AWS IoT Greengrass EntwicklerhandbuchErstellen von AWS IoT-Geräten in

einer AWS IoT Greengrass-Gruppe

Erstellen von AWS IoT-Geräten in einer AWS IoTGreengrass-Gruppe1. Wählen in der AWS IoT-Konsole nacheinander Greengrass, Gruppen und dann Ihre Gruppe aus.2. Wählen Sie auf der Gruppenkonfigurationsseite Geräte und dann Hinzufügen Ihres ersten Geräts aus.

3. Wählen Sie Neues Gerät erstellen.

4. Registrieren Sie dieses Gerät als HelloWorld_Publisher und wählen Sie dann Weiter.

117



5. Wählen Sie für 1-Click die Option Standardwerte verwenden aus. Diese Option generiert einGerätezertifikat mit angefügten AWS IoT-Richtlinien sowie einen öffentlichen und privaten Schlüssel.

6. Erstellen Sie einen Ordner auf Ihrem Computer. Laden Sie das Zertifikat und die Schlüssel für IhrGerät in den Ordner herunter.

118



Notieren Sie sich die allgemeine Hash-Komponente in den Dateinamen für das HelloWorld_Publisher-Gerätezertifikat und die Schlüssel (in diesem Beispiel bcc5afd26d). Sie benötigen sie später. WählenSie Finish aus.

7. Extrahieren Sie die Datei hash-setup.tar.gz. Führen Sie z. B. den folgenden Befehl aus:

tar -xzf hash-setup.tar.gz

Note

Unter Windows können Sie .tar.gz-Dateien mit einem Tool wie 7-Zip oder WinZipdekomprimieren.

8. Wählen Sie Add Device (Gerät hinzufügen) aus und wiederholen Sie die Schritte 3 bis 7, um derGruppe ein neues Gerät hinzuzufügen.

Geben Sie diesem Gerät den Namen HelloWorld_Subscriber. Laden Sie die Zertifikate undSchlüssel für das Gerät auf Ihren Computer herunter. Speichern und extrahieren Sie sie im selbenOrdner, den Sie für HelloWorld_Publisher erstellt haben.

Notieren Sie sich wieder die allgemeine Hash-Komponente in den Dateinamen für dasHelloWorld_Subscriber-Gerät.

Sie sollten jetzt zwei Geräte in Ihrem AWS IoT Greengrass-Gruppe haben:

119

http://www.7-zip.org/

http://www.winzip.com/



9. Überprüfen Sie die Dokumentation zu Server-Authentifizierung im AWS IoT-Core und wählen Sie dasentsprechende CA-Stammzertifikat. Wir empfehlen, Amazon Trust Services(ATS)-Endpunkte undCA-Zertifikate von ATS zu verwenden. Der Typ Ihres CA-Zertifikat muss dem Endpunkt entsprechen.Sie müssen ein CA-Stammzertifikat von ATS mit einem ATS-Endpunkt (empfohlen) oder ein CA-Stammzertifikat von Verisign mit einem Legacy-Endpunkt verwendet. Nur einige AWS-Regionenunterstützen Legacy-Endpunkte. Weitere Informationen finden Sie unter the section called “Endpunktemüssen dem Zertifikattyp entsprechen” (p. 48).

Speichern Sie das CA-Stammzertifikat als root-ca-cert.pem im selben Ordner wie die Zertifikateund Schlüssel für beide Geräte. Alle diese Dateien müssen sich in einem Ordner auf Ihrem Computer(nicht auf dem AWS IoT Greengrass-Core-Gerät) befinden.

• Für ATS-Endpunkte (bevorzugt) laden Sie das entsprechende ATS-CA-Stammzertifikat herunter, wieetwa Amazon Root CA 1.

• Laden Sie für Legacy-Endpunkte ein CA-Stammzertifikat von Verisign herunter. Auch wenn Legacy-Endpunkte für dieses Tutorial verwendet werden können, empfehlen wir, einen ATS-Endpunkt zuerstellen und ein CA-Stammzertifikat von ATS herunterzuladen.

Note

Wenn Sie einen Webbrowser auf dem Mac verwenden und die Warnung Dieses Zertifikatist bereits als Zertifizierungsstelle installiert erhalten, können Sie ein Terminal-Fensteröffnen und das Zertifikat in den Ordner mit den Gerätezertifikaten und -schlüsseln fürHelloWorld_Publisher und HelloWorld_Subscriber herunterladen: Beispiel: Falls Sie einenATS-Endpunkt verwenden, können Sie den folgenden Befehl zum Herunterladen des AmazonRoot CA 1-Zertifikats ausführen.

cd path-to-folder-containing-device-certificatescurl -o ./root-ca-cert.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem

Führen Sie cat root-ca-cert.pem aus, um sicherzustellen, dass die Datei nicht leer ist.Wenn die Datei leer ist, prüfen Sie die URL und geben Sie den Befehl curl erneut aus.

120


https://www.amazontrust.com/repository/AmazonRootCA1.pem

https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren von Abonnements

Konfigurieren von AbonnementsIn diesem Schritt aktivieren Sie das HelloWorld_Publisher-Gerät, um MQTT-Nachrichten an dasHelloWorld_Subscriber-Gerät zu senden.


2. Konfigurieren Sie das Abonnement.

• Wählen Sie unter Select a source (Eine Quelle auswählen) die Option Devices (Geräte) aus undklicken Sie auf HelloWorld_Publisher.

• Wählen Sie unter Select a target (Ein Ziel auswählen) die Option Devices (Geräte) aus und klickenSie auf HelloWorld_Subscriber.

• Wählen Sie Next.

3. Geben Sie unter Topic filter (Themenfilter) hello/world/pubsub ein, wählen Sie Next (Weiter) ausund klicken Sie auf Finish (Beenden).

Note

Sie können Abonnements aus den früheren Modulen löschen. Wählen Sie dazu auf der Seiteder Gruppe Subscriptions (Abonnements) die Auslassungspunkte (…) aus, die mit einemAbonnement verknüpft sind, und klicken Sie anschließend auf Delete (Löschen).



121

AWS IoT Greengrass EntwicklerhandbuchInstallieren der AWS IoT-Geräte-SDK für Python


Der Bereitstellungsstatus wird im Header der Seite unter dem Namen der Gruppe angezeigt. Um dieBereitstellungsdetails anzuzeigen, wählen Sie Deployments (Bereitstellungen) aus.

Installieren der AWS IoT-Geräte-SDK für PythonAWS IoT-Geräte können das AWS IoT-Geräte-SDK für Python für die Kommunikation mit dem AWS IoTund AWS IoT Greengrass-Core-Geräten verwenden (unter Verwendung der Programmiersprache Python).Weitere Informationen, einschließlich der Voraussetzungen, finden Sie in der AWS IoT-Geräte-SDK fürPython SDK Readme auf GitHub.

1. Um das SDK mit allen erforderlichen Komponenten auf Ihrem Computer zu installieren, wählen Sie IhrBetriebssystem aus:

Windows

1. Öffnen Sie eine erweiterte Eingabeaufforderung und führen Sie den folgenden Befehl aus:

python --version

Wenn keine Versionsinformationen zurückgegeben werden oder wenn die Versionsnummerfür Python 2 kleiner als 2.7 oder für Python 3 kleiner als 3.3 ist, installieren Sie Python 2.7+oder Python 3.3+ gemäß den Anweisungen unter Downloading Python. Weitere Informationenfinden Sie unter Using Python on Windows.

2. Laden Sie mit einem Webbrowser die AWS IoT-Geräte-SDK für Python zip-Datei undspeichern Sie sie als aws-iot-device-sdk-python-latest.zip (dies sollte derStandardname sein). Die Datei zip wird in der Regel in Ihrem Downloads-Ordnergespeichert. Dekomprimieren Sie aws-iot-device-sdk-python-latest.zip an einemgeeigneten Speicherort, beispielsweise Ihrem Stammverzeichnis (z. B. cd %HOME%). NotierenSie den Dateipfad zu dem dekomprimierten aws-iot-device-sdk-python-latest-Ordner. Im nächsten Schritt ist dieser Dateipfad als path-to-SDK-folder dargestellt.

3. Führen Sie von der erweiterten Eingabeaufforderung aus Folgendes aus:

cd path-to-SDK-folderpython setup.py install

macOS

1. Öffnen Sie ein Terminalfenster und führen Sie den folgenden Befehl aus:

python --version

Wenn keine Versionsinformationen zurückgegeben werden oder wenn die Versionsnummerfür Python 2 kleiner als 2.7 oder für Python 3 kleiner als 3.3 ist, installieren Sie Python 2.7+oder Python 3.3+ gemäß den Anweisungen unter Downloading Python. Weitere Informationenfinden Sie unter Using Python on a Macintosh.

2. Führen Sie im Terminalfenster die folgenden Befehle aus, um die OpenSSL-Version zuermitteln:

python

122

https://github.com/aws/aws-iot-device-sdk-python

https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx

https://wiki.python.org/moin/BeginnersGuide/Download

https://docs.python.org/3.6/using/windows.html

https://s3.amazonaws.com/aws-iot-device-sdk-python/aws-iot-device-sdk-python-latest.zip


https://docs.python.org/3/using/mac.html


>>>import ssl>>>print ssl.OPENSSL_VERSION

Notieren Sie sich den Wert der OpenSSL-Version.

Note

Wenn Sie Python 3 ausführen, verwenden Sie print(ssl.OPENSSL_VERSION).

Um die Python-Shell zu schließen, führen Sie den folgenden Befehl aus:

>>>exit()

Wenn die OpenSSL Version 1.0.1 oder höher ist, gehen Sie direkt zu Schritt 3. Führen Sieandernfalls die folgenden Schritte aus:

• Führen Sie im Terminalfenster den folgenden Befehl aus, um zu festzustellen, ob derComputer das Simple Python Version Management verwendet:

which pyenv

Wird ein Dateipfad zurückgegeben, wählen Sie die Registerkarte Using pyenv (UnterVerwendung von). Wird nichts zurückgegeben, wählen Sie die Registerkarte Not using pyenv(Nicht unter Verwendung von).

Using pyenv

1. Weitere Informationen, wie Sie die neueste stabile Python-Version bestimmen, findenSie unter Python Releases for Max OS X (oder ähnlich). Im folgenden Beispiel wirddieser Wert durch latest-Python-version dargestellt.

2. Führen Sie im Terminalfenster die folgenden Befehle aus:

pyenv install latest-Python-versionpyenv global latest-Python-version

Wenn beispielsweise die neueste Version für Python 2 gleich 2.7.14 ist, lauten dieseBefehle:

pyenv install 2.7.14pyenv global 2.7.14

3. Schließen Sie das Terminalfenster und öffnen Sie es wieder und führen Sie dann diefolgenden Befehle aus:

python>>>import ssl>>>print ssl.OPENSSL_VERSION

Die OpenSSL-Version sollte 1.0.1 oder neuer sein. Wenn die Version kleiner als 1.0.1ist, dann ist die Aktualisierung fehlgeschlagen. Überprüfen Sie die Python-Version inden Befehlen pyenv install und pyenv global und versuchen Sie es erneut.

4. Um die Python-Shell zu schließen, führen Sie den folgenden Befehl aus:

exit()

123

https://www.python.org/downloads/mac-osx/


Not using pyenv

1. Führen Sie den folgenden Befehl in einem Terminalfenster aus, um festzustellen, obbrew installiert ist:

which brew

Wird kein Dateipfad zurückgegeben, installieren Sie brew wie folgt:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Note

Befolgen Sie die Eingabeaufforderungen für die Installation. Der Download fürdie Xcode-Befehlszeilentools kann einige Zeit in Anspruch nehmen.

2. Führen Sie die folgenden Befehle aus:

brew updatebrew install opensslbrew install python@2

Das AWS IoT-Geräte-SDK für Python erfordert OpenSSL-Version 1.0.1 (oderhöher), kompiliert mit der Python-Programmdatei. Der obige Befehl brew installpython installiert eine ausführbare python2-Datei, die diese Anforderung erfüllt. Dieausführbare python2-Datei wird im Ordner /usr/local/bin installiert, das Teilder Umgebungsvariablen PATH sein sollte. Führen Sie zur Bestätigung den folgendenBefehl aus:

python2 --version

Wenn python2-Versionsinformationen bereitgestellt werden, gehen Sie zum nächstenSchritt über. Andernfalls fügen Sie Ihrer Umgebungsvariablen PATH dauerhaft denPfad /usr/local/bin hinzu, indem Sie Ihrem Shell-Profil die folgende Zeilehinzufügen:

export PATH="/usr/local/bin:$PATH"

Wenn Sie beispielsweise .bash_profile verwenden oder noch kein Shell-Profilhaben, führen Sie den folgenden Code von einem Terminalfenster aus aus:

echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.bash_profile

Anschließend führen Sie source für Ihr Shell-Profil aus und bestätigen, dass python2--version Versionsinformationen bereitstellt. Wenn Sie z. B. .bash_profileverwenden, führen Sie die folgenden Befehle aus:

source ~/.bash_profilepython2 --version

python2-Versionsinformationen sollten zurückgegeben werden.

124

https://brew.sh/

https://en.wikipedia.org/wiki/Source_(command)


3. Fügen Sie Ihrem Shell-Profil die folgende Zeile hinzu:

alias python="python2"

Wenn Sie beispielsweise .bash_profile verwenden oder noch kein Shell-Profilhaben, führen Sie den folgenden Code aus:

echo 'alias python="python2"' >> ~/.bash_profile

4. Anschließend führen Sie source für Ihr Shell-Profil aus. Wenn Sie z. B..bash_profile verwenden, führen Sie den folgenden Befehl aus:

source ~/.bash_profile

Wenn der Befehl python aufgerufen wird, wird die Python-Programmdateienausgeführt, in der die erforderliche OpenSSL-Version (python2) enthalten ist.

5. Führen Sie die folgenden Befehle aus:

python import ssl print ssl.OPENSSL_VERSION

Die OpenSSL-Version sollte 1.0.1 oder neuer sein.6. Um die Python-Shell zu schließen, führen Sie den folgenden Befehl aus:

exit()

3. Führen Sie die folgenden Befehle aus, um AWS IoT-Geräte-SDK für Python zu installieren:

cd ~git clone https://github.com/aws/aws-iot-device-sdk-python.gitcd aws-iot-device-sdk-pythonpython setup.py install

UNIX-like system

1. Führen Sie in einem Terminalfenster den folgenden Befehl aus:

python --version

Wenn keine Versionsinformationen zurückgegeben werden oder wenn die Versionsnummerfür Python 2 kleiner als 2.7 oder für Python 3 kleiner als 3.3 ist, installieren Sie Python 2.7+oder Python 3.3+ gemäß den Anweisungen unter Downloading Python. Weitere Informationenfinden Sie unter Using Python on Unix-Plattformen.

2. Führen Sie im Terminal die folgenden Befehle aus, um die OpenSSL-Version zu ermitteln:

python>>>import ssl>>>print ssl.OPENSSL_VERSION

Notieren Sie sich den Wert der OpenSSL-Version.

Um die Python-Shell zu schließen, führen Sie den folgenden Befehl aus:125

https://en.wikipedia.org/wiki/Source_(command)


https://docs.python.org/3.6/using/unix.html

AWS IoT Greengrass EntwicklerhandbuchTesten der Kommunikation

exit()

Wenn die OpenSSL Version 1.0.1 oder höher ist, gehen Sie direkt zum nächsten Schritt.Andernfalls führen Sie den Befehl/die Befehle für die Aktualisierung von OpenSSL für IhreVerteilung aus (zum Beispiel sudo yum update openssl, sudo apt-get update usw.).

Vergewissern Sie sich, dass die OpenSSL-Version 1.0.1 oder höher ist, indem Sie diefolgenden Befehle ausführen:

python>>>import ssl>>>print ssl.OPENSSL_VERSION>>>exit()

3. Führen Sie die folgenden Befehle aus, um AWS IoT-Geräte-SDK für Python zu installieren:

cd ~git clone https://github.com/aws/aws-iot-device-sdk-python.gitcd aws-iot-device-sdk-pythonsudo python setup.py install

2. Nachdem das AWS IoT-Geräte-SDK für Python installiert wurde, wechseln Sie zum Ordner samples,öffnen Sie den Ordner greengrass und kopieren Sie die Datei basicDiscovery.py in denOrdner mit den Zertifikatdateien der Geräte HelloWorld_Publisher und HelloWorld_Subscriber, wie imfolgenden Beispiel dargestellt. (Die Hash-Komponente in Ihren Dateinamen unterscheiden sich.)

Testen der Kommunikation1. Stellen Sie sicher, dass Ihr Computer und das AWS IoT Greengrass-Core-Gerät mit dem Internet

verbunden sind und dasselbe Netzwerk verwenden.

a. Führen Sie auf dem AWS IoT Greengrass-Core-Gerät den folgenden Befehl aus, um diezugehörige IP-Adresse zu ermitteln.

hostname -I

b. Führen Sie auf Ihrem Computer mit der IP-Adresse des Cores den folgenden Befehl aus. Mit Ctrl+ C können Sie den Befehl ping stoppen.

ping IP-address

126


Eine Ausgabe ähnlich der folgenden bedeutet eine erfolgreiche Kommunikation zwischen demComputer und dem AWS IoT Greengrass-Core-Gerät (0 % Paketverlust):

Note

Wenn Sie nicht in der Lage sind, eine EC2-Instance, auf der AWS IoT Greengrassausgeführt wird, per Ping zu erreichen, stellen Sie sicher, dass die eingehendenSicherheitsgruppenregeln für die Instance ICMP-Datenverkehr für Echo-Anfrage-Nachrichten erlauben. Weitere Informationen finden Sie unter Hinzufügen von Regeln zueiner Sicherheitsgruppe im Amazon EC2-Benutzerhandbuch für Linux-Instances.Möglicherweise müssen Sie auf Windows-Host-Computern in der App „Windows-Firewall mit erweiterter Sicherheit“ eine eingehende Regel aktivieren, die eingehendeEcho-Anfragen (z. B. File and Printer Sharing (Echo Request - ICMPv4-In) (Datei- undDruckerfreigabe [Echo-Anfrage – ICMPv4-In])) zulässt oder selber eine erstellen.

2. Bereiten Sie Ihren AWS IoT-Endpunkt vor.

a. Wählen Sie im Navigationsbereich auf der Startseite von AWS IoT-Konsole die OptionEinstellungen.

b. Notieren Sie unter Einstellungen den Wert von Endpunkt. Sie verwenden diesen Wert, um dieAWS_IOT_ENDPOINT-Platzhalter in den Befehlen der folgenden Schritten zu ersetzen.

Note

Stellen Sie sicher, dass Ihre Endpunkte Ihrem Zertifikatstypen entsprechen (p. 48).3. Öffnen Sie zwei command-line-Fenster (Terminal- oder Befehlszeilenfenster) auf Ihrem Computer

(nicht auf dem AWS IoT Greengrass-Core-Gerät). Ein Fenster repräsentiert das HelloWorld_Publisher-Gerät und das andere das HelloWorld_Subscriber-Gerät.

127

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html#sg-rules-ping



https://en.wikipedia.org/wiki/Command-line_interface


Bei der Ausführung versucht basicDiscovery.py Informationen über den Speicherort des AWSIoT Greengrass-Core an seinen Endpunkten zu erfassen. Diese Informationen werden gespeichert,nachdem das Gerät den Kern erkannt und sich erfolgreich mit ihm verbunden hat. Auf diese Weise istkünftig ein lokales Ausführen (ohne Internetverbindung) von Messaging-Funktionen und Operationenmöglich.

Note

Sie können den folgenden Befehl über den Ordner mit der Datei basicDiscovery.pyausführen, um detaillierte Skriptnutzungsinformationen zu erhalten:

python basicDiscovery.py --help

4. Führen Sie im Fenster des Geräts HelloWorld_Publisher die folgenden Befehle aus.

• Ersetzen Sie path-to-certs-folder mit dem Pfad zu dem Ordner, in dem sich die Zertifikate,Schlüssel und die Datei basicDiscovery.py befinden.

• Ersetzen Sie AWS_IOT_ENDPOINT mit Ihrem Endpunkt.• Ersetzen Sie die beiden Publisher-Instances mit dem Hash im Dateinamen für Ihr

HelloWorld_Publisher-Gerät.

cd path-to-certs-folderpython basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert publisher.cert.pem --key publisher.private.key --thingName HelloWorld_Publisher --topic 'hello/world/pubsub' --mode publish --message 'Hello, World! Sent from HelloWorld_Publisher'

Die Ausgabe sollte ungefähr wie die folgende aussehen und kann beispielsweise die nachstehendenEinträge umfassen: Published topic 'hello/world/pubsub': {"message": "Hello,World! Sent from HelloWorld_Publisher", "sequence": 1}.

Note

Wenn das Skript eine error: unrecognized arguments-Nachricht zurückgibt, ändernSie die einfachen Anführungszeichen zu doppelten Anführungszeichen für die Parameter --topic und --message und führen Sie den Befehl erneut aus.Um einen Verbindungsfehler zu beheben, können Sie versuchen, das Problem mithilfe dermanuellen IP-Erkennung (p. 129) zu lösen.

5. Führen Sie die folgenden Befehle im Fenster des HelloWorld_Subscriber-Geräts aus.

• Ersetzen Sie path-to-certs-folder mit dem Pfad zu dem Ordner, in dem sich die Zertifikate,Schlüssel und die Datei basicDiscovery.py befinden.

• Ersetzen Sie AWS_IOT_ENDPOINT mit Ihrem Endpunkt.

128

AWS IoT Greengrass EntwicklerhandbuchModul 5: Interaktion mit Geräteschatten

• Ersetzen Sie die beiden Subscriber-Instances mit dem Hash im Dateinamen für IhrHelloWorld_Subscriber-Gerät.

cd path-to-certs-folderpython basicDiscovery.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert subscriber.cert.pem --key subscriber.private.key --thingName HelloWorld_Subscriber --topic 'hello/world/pubsub' --mode subscribe

Die Ausgabe sollte folgendermaßen aussehen und kann beispielsweise nachstehende Einträgeumfassen: Received message on topic hello/world/pubsub: {"message": "Hello,World! Sent from HelloWorld_Publisher", "sequence": 1}.

Schließen Sie das HelloWorld_Publisher-Fenster, um weitere Nachrichten im HelloWorld_Subscriber-Fenster zu verhindern.

Tests in einem Unternehmensnetzwerk können die Verbindung zum Core beeinträchtigen. Um diesesProblem zu umgehen, können Sie den Endpunkt manuell eingeben. Auf diese Weise wird sichergestellt,dass sich das Skript basicDiscovery.py mit der richtigen IP-Adresse des AWS IoT Greengrass-Core-Geräts verbindet.

Endpunkt manuell eingeben

1. Wählen Sie Greengrass, Gruppen und dann Ihre Gruppe aus.2. Wählen Sie Settings aus.3. Wählen Sie unter Local connection detection (Lokale Verbindungserkennung) die Option Manually

manage connection information (Verbindungsinformationen manuell verwalten) und anschließend ViewCores for specific endpoint information (Cores für spezifische Endpunktinformationen anzeigen) aus.

4. Wählen Sie Ihren Core und danach Anbindung aus.5. Klicken Sie auf Bearbeiten und stellen Sie sicher, dass nur ein Endpunkt-Wert vorhanden ist.

Bei diesem Wert muss es sich um den IP-Adressen-Endpunkt für den Port 8883 Ihres AWS IoTGreengrass-Core-Geräts handeln (beispielsweise 192.168.1.4).

6. Wählen Sie Update aus.

Modul 5: Interaktion mit GeräteschattenDieses erweiterte Modul zeigt, wie AWS IoT Greengrass-Geräte mit AWS IoT-Schattengeräten in einerAWS IoT Greengrass-Gruppe interagieren können. Ein Schatten ist ein JSON-Dokument, das für dieSpeicherung der aktuellen oder gewünschten Statusinformationen für einen Gegenstand verwendet wird. Indiesem Modul erfahren Sie, wie ein AWS IoT Greengrass-Gerät (GG_Switch) den Zustand eines anderenAWS IoT Greengrass-Gerät (GG_TrafficLight) modifizieren kann und wie diese Zustände in der AWSIoT Greengrass-Cloud synchronisiert werden können:

129

https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren von Geräten und Abonnements

Bevor Sie beginnen, stellen Sie sicher, dass Sie Modul 1 (p. 70), Modul 2 (p. 81), Modul 3(Teil 1) (p. 89) und Modul 3 (Teil 2) (p. 103) abgeschlossen haben. Sie sollten außerdem wissen, wieGeräte mit einem AWS IoT Greengrass-Core (Modul 4 (p. 116)) verbunden werden. Sie benötigen keineanderen Komponenten oder Geräte.


Themen• Konfigurieren von Geräten und Abonnements (p. 130)• Download der benötigten Dateien (p. 134)• Testen der Kommunikation (Gerätesynchronisierungen deaktiviert) (p. 134)• Testen der Kommunikation (Gerätesynchronisierungen aktiviert) (p. 137)

Konfigurieren von Geräten und AbonnementsSchatten können mit AWS IoT synchronisiert werden, wenn der AWS IoT Greengrass-Core mit demInternet verbunden ist. In diesem Modul verwenden Sie zunächst die lokalen Schattengeräte ohne einSynchronisieren mit der Cloud. Anschließend aktivieren Sie die Cloud-Synchronisierung.

Jedes Gerät hat einen eigenen Schatten. Weitere Informationen finden Sie Device Shadow-Service fürAWS IoT im AWS IoT-Entwicklerhandbuch.

130




1. Fügen Sie auf der Seite Devices (Geräte) zwei neue Geräte in Ihre AWS IoT Greengrass-Gruppe.Ausführliche Informationen zu den Schritten dieses Prozesses finden Sie unter the section called“Erstellen von AWS IoT-Geräten in einer AWS IoT Greengrass-Gruppe” (p. 117).

• Geben Sie den Geräten die Namen GG_Switch und GG_TrafficLight.• Generieren und laden Sie die standardmäßigen 1-Click-Sicherheits-Ressourcen für beide Geräte

herunter.• Notieren Sie sich die Hash-Komponente in den Dateinamen der Sicherheits-Ressourcen für die

Geräte. Sie werden diese Werte in einem späteren Schritt verwenden.

2. Extrahieren Sie die heruntergeladenen Zertifikate und Schlüssel für beide Geräte in einen Ordner aufIhrem Computer. Führen Sie z. B. den folgenden Befehl für jede .tar.gz-Datei aus.

tar -xzf hash-setup.tar.gz

Note

Unter Windows können Sie .tar.gz-Dateien mit einem Tool wie 7-Zip oder WinZipdekomprimieren.

3. Kopieren Sie die root-ca-cert.pem-Datei, die Sie im vorherigen Modul (p. 120) heruntergeladenhaben, in diesen Ordner.

4. Stellen Sie sicher, dass die Geräte so eingestellt sind, dass sie lokale Schatten verwenden. Ist diesnicht der Fall, wählen Sie die Auslassungspunkte (…) und anschließend Make local only (Nur lokaleinstellen) aus.

131

http://www.7-zip.org/

http://www.winzip.com/


5. Der in diesem Modul verwendete Funktionscode macht es erforderlich, dass Sie den Endpunkt desKerns manuell konfigurieren.

a. Wählen Sie auf der Gruppenkonfigurationsseite die Option Settings (Einstellungen) aus.b. Wählen Sie unter Local connection detection (Lokale Verbindungserkennung) die Option Manually

manage connection information (Verbindungsinformationen manuell verwalten) und anschließendView Cores for specific endpoint information (Cores für spezifische Endpunktinformationenanzeigen) aus.

c. Wählen Sie Ihren Core und danach Anbindung aus.d. Klicken Sie auf Bearbeiten und stellen Sie sicher, dass nur ein Endpunkt-Wert vorhanden ist.

Bei diesem Wert muss es sich um den IP-Adressen-Endpunkt für den Port 8883 Ihres AWS IoTGreengrass-Core-Geräts handeln (beispielsweise 192.168.1.4).

e. Wählen Sie Update aus.6. Fügen Sie die Abonnements der folgenden Tabelle zu Ihrer Gruppe hinzu. So erstellen Sie

beispielsweise das erste Abonnement:

a. Wählen Sie auf der Gruppenkonfigurationsseite die Option Subscriptions (Abonnements) undanschließend Add Subscription (Abonnement hinzufügen) aus.

b. Wählen Sie unter Select a source (Eine Quelle auswählen) die Option Devices (Geräte) aus undklicken Sie auf GG_Switch.

c. Wählen Sie für Ein Ziel auswählen die Option Services und danach Local Shadow Service(Lokaler Schatten-Service) aus.

d. Wählen Sie Next.e. Geben Sie unter Topic filter (Themenfilter) $aws/things/GG_TrafficLight/shadow/update

ein.f. Klicken Sie auf Weiter und danach auf Beenden.

Die Themen müssen genau wie in der Tabelle eingegeben werden. Sie können zwar Platzhalterverwenden, um einige der Abonnements zu konsolidieren, dies wird jedoch nicht empfohlen. WeitereInformationen finden Sie unter MQTT-Themen für Schatten im AWS IoT-Entwicklerhandbuch.

Quelle Ziel Thema Hinweise

GG_Switch Local Shadow Service $aws/things/GG_TrafficLight/shadow/update

Der GG_Switchsendet eineAktualisierungsanfragean dasAktualisierungsthema.

Local Shadow Service GG_Switch $aws/things/GG_TrafficLight/shadow/update/accepted

Die GG_Switchmuss wissen, ob dieAktualisierungsanforderungakzeptiert wurde.

Local Shadow Service GG_Switch $aws/things/GG_TrafficLight/shadow/update/rejected

Die GG_Switchmuss wissen, ob dieAktualisierungsanforderungabgelehnt wurde.

GG_TrafficLight Local Shadow Service $aws/things/GG_TrafficLight/shadow/update

Das GG_TrafficLightsendet eineAktualisierungseines Status an dasAktualisierungsthema.

132

https://docs.aws.amazon.com/iot/latest/developerguide/device-shadow-mqtt.html


Quelle Ziel Thema Hinweise

Local Shadow Service GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/delta

Der lokaleSchattenservice sendeteine empfangeneAktualisierung überdas Delta-Thema anGG_TrafficLight.

Local Shadow Service GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/accepted

GG_TrafficLightmuss wissen, ob dieStatusaktualisierungakzeptiert wurde.

Local Shadow Service GG_TrafficLight $aws/things/GG_TrafficLight/shadow/update/rejected

GG_TrafficLightmuss wissen, ob dieStatusaktualisierungabgelehnt wurde.

Die neuen Abonnements werden auf der Seite Subscriptions (Abonnements) angezeigt. Um denvollständigen Themenpfad eines Abonnements anzuzeigen, platzieren Sie mit den Mauszeiger überdie Spalte Topic (Thema) .

Note

Weitere Informationen zum $-Zeichen finden Sie im Abschnitt zu Reserved Topics(Reservierte Topics).



133

https://docs.aws.amazon.com/iot/latest/developerguide/topics.html#reserved-topics

https://docs.aws.amazon.com/iot/latest/developerguide/topics.html#reserved-topics

AWS IoT Greengrass EntwicklerhandbuchDownload der benötigten Dateien


Download der benötigten Dateien1. Falls noch nicht erfolgt, installieren Sie das AWS IoT-Geräte-SDK für Python. Anweisungen

hierzu finden Sie in Schritt 1 unter the section called “Installieren der AWS IoT-Geräte-SDK fürPython” (p. 122).

Dieses SDK wird von AWS IoT-Geräten für die Kommunikation mit dem AWS IoT und mit AWS IoTGreengrass-Core-Geräten verwendet.

2. Laden Sie aus dem AWS IoT Greengrass-Beispiel-Repository auf GitHub die DateienlightController.py und trafficLight.py auf Ihren Computer herunter. Speichern Sie sie indem Ordner, der die Gerätezertifikate und Schlüssel für GG_Switch und GG_TrafficLight enthält.

Das Skript lightController.py entspricht dem GG_Switch-Gerät und das SkripttrafficLight.py dem GG_TrafficLight-Gerät.

Testen der Kommunikation (Gerätesynchronisierungendeaktiviert)1. Stellen Sie sicher, dass Ihr Computer und das AWS IoT Greengrass-Core-Gerät mit dem Internet

verbunden sind und dasselbe Netzwerk verwenden.

a. Führen Sie auf dem AWS IoT Greengrass-Core-Gerät den folgenden Befehl aus, um diezugehörige IP-Adresse zu ermitteln.

hostname -I

b. Führen Sie auf Ihrem Computer mit der IP-Adresse des Cores den folgenden Befehl aus. Mit Ctrl+ C können Sie den Befehl ping stoppen.

134

https://github.com//aws-samples/aws-greengrass-samples/tree/master/traffic-light-example-python


(Gerätesynchronisierungen deaktiviert)

ping IP-address

Eine Ausgabe ähnlich der folgenden bedeutet eine erfolgreiche Kommunikation zwischen demComputer und dem AWS IoT Greengrass-Core-Gerät (0 % Paketverlust):

Note

Wenn Sie nicht in der Lage sind, eine EC2-Instance, auf der AWS IoT Greengrassausgeführt wird, per Ping zu erreichen, stellen Sie sicher, dass die eingehendenSicherheitsgruppenregeln für die Instance ICMP-Datenverkehr für Echo-Anfrage-Nachrichten erlauben. Weitere Informationen finden Sie unter Hinzufügen von Regeln zueiner Sicherheitsgruppe im Amazon EC2-Benutzerhandbuch für Linux-Instances.Möglicherweise müssen Sie auf Windows-Host-Computern in der App „Windows-Firewall mit erweiterter Sicherheit“ eine eingehende Regel aktivieren, die eingehendeEcho-Anfragen (z. B. File and Printer Sharing (Echo Request - ICMPv4-In) (Datei- undDruckerfreigabe [Echo-Anfrage – ICMPv4-In])) zulässt oder selber eine erstellen.

2. Bereiten Sie Ihren AWS IoT-Endpunkt vor.

a. Wählen Sie im Navigationsbereich auf der Startseite von AWS IoT-Konsole die OptionEinstellungen.

b. Notieren Sie unter Einstellungen den Wert von Endpunkt. Sie verwenden diesen Wert, um dieAWS_IOT_ENDPOINT-Platzhalter in den Befehlen der folgenden Schritten zu ersetzen.

Note

Stellen Sie sicher, dass Ihre Endpunkte Ihrem Zertifikatstypen entsprechen (p. 48).

135

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html#sg-rules-ping




(Gerätesynchronisierungen deaktiviert)

3. Öffnen Sie zwei command-line-Fenster (Terminal- oder Befehlszeilenfenster) auf Ihrem Computer(nicht auf dem AWS IoT Greengrass-Core-Gerät). Ein Fenster repräsentiert das GG_Switch-Gerät unddas andere das GG_TrafficLight-Gerät.

a. Führen Sie im GG_Switch-Gerätefenster die folgenden Befehle aus:

• Ersetzen Sie path-to-certs-folder mit dem Pfad zu dem Ordner, in dem sich dieZertifikate, Schlüssel und die Python-Dateien befinden.

• Ersetzen Sie AWS_IOT_ENDPOINT mit Ihrem Endpunkt.• Ersetzen Sie die beiden Switch-Instances mit dem Hash im Dateinamen Ihres GG_Switch-

Geräts.

cd path-to-certs-folderpython lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert switch.cert.pem --key switch.private.key --thingName GG_TrafficLight --clientId GG_Switch

b. Führen Sie im GG_TrafficLight-Gerätefenster die folgenden Befehle aus:

• Ersetzen Sie path-to-certs-folder mit dem Pfad zu dem Ordner, in dem sich dieZertifikate, Schlüssel und die Python-Dateien befinden.

• Ersetzen Sie AWS_IOT_ENDPOINT mit Ihrem Endpunkt.• Ersetzen Sie die beiden Light-Instances mit dem Hash im Dateinamen Ihres GG_TrafficLight-

Geräts.

cd path-to-certs-folderpython trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert light.cert.pem --key light.private.key --thingName GG_TrafficLight --clientId GG_TrafficLight

Alle 20 Sekunden aktualisiert der Schalter den Schattenzustand mit „G”, „Y” und „R” und dieLampe zeigt ihren neuen Zustand an, wie nachfolgend dargestellt.

GG_Switch Ausgabe:

GG_TrafficLight Ausgabe:

136



(Gerätesynchronisierungen aktiviert)

Jedes dieser Skripte löst bei der ersten Ausführung den AWS IoT Greengrass-Erkennungsservicefür eine Verbindung mit dem AWS IoT Greengrass-Core (über das Internet) aus. Nachdem ein Geräteinen AWS IoT Greengrass-Core erkannt und erfolgreich eine Verbindung dazu hergestellt hat, könnenkünftige Funktionen lokal ausgeführt werden.

Note

Die Skripts trafficLight.py und lightController.py speichernVerbindungsinformationen im Ordner groupCA. Dieser wird im selben Ordner wie die Skriptserstellt. Wenn Sie Verbindungsfehler erhalten, stellen Sie sicher, dass die IP-Adresse in derDatei ggc-host mit derjenigen des Einzel-IP-Adressen-Endpunkts übereinstimmt, den Sie indiesem Schritt (p. 132) für den Core konfiguriert haben.

4. Wählen Sie unter AWS IoT-Konsole Ihre AWS IoT Greengrass-Gruppe aus und klicken Sie dann aufDevices (Geräte) und GG_TrafficLight.

5. Klicken Sie auf Shadow. Nachdem sich der Zustand von GG_Switch geändert hat, sollte diesesSchatten-Thema unter Schattenstatus nicht mehr aktualisiert werden. Dies liegt daran, dassGG_TrafficLight auf NUR LOKALER SCHATTEN anstatt auf SCHATTENSYNCHRONISIERUNG MITDER CLOUD eingestellt ist.

6. Drücken Sie Ctrl + C im GG_Switch-Gerätefenster (lightController.py). Es sollte zu beobachtensein, dass das GG_TrafficLight-Fenster (trafficLight.py) keine Statusänderungsnachrichten mehrerhält.

Schließen Sie diese Fenster nicht, damit Sie die Befehle im nächsten Abschnitt erneut ausführenkönnen.

Testen der Kommunikation (Gerätesynchronisierungenaktiviert)Für diesen Test konfigurieren Sie den GG_TrafficLight-Geräteschatten so, dass er mit dem AWS IoTsynchronisiert wird. Führen Sie die gleichen Befehle wie im vorherigen Test aus, aber dieses Mal wird derSchattenzustand in der Cloud aktualisiert, sobald GG_Switch eine Aktualisierungsanforderung sendet.

1. Wählen Sie in der AWS IoT-Konsole Ihre AWS IoT Greengrass-Gruppe und danach Geräte aus.2. Wählen Sie für das GG_TrafficLight-Gerät die Auslassungspunkte (…) aus und klicken Sie dann auf

Sync to the Cloud (Synchronisieren mit der Cloud).

137


(Gerätesynchronisierungen aktiviert)

Sie sollten eine Benachrichtigung erhalten, dass das Schattengerät aktualisiert wurde.3. Wählen Sie auf der Gruppenkonfigurationsseite unter Actions (Aktionen) die Option Deploy

(Bereitstellen) aus.


4. Führen Sie in den beiden Befehlszeilenfenster die Befehle aus dem vorherigen Test für dieGG_Switch (p. 136)- und GG_TrafficLight (p. 136) -Geräte aus.

5. Überprüfen Sie nun den Schattenstatus in der AWS IoT-Konsole. Wählen Sie Ihre AWS IoTGreengrass-Gruppe aus und klicken Sie anschließend auf Devices (Geräte), GG_TrafficLight undschließlich auf Shadow (Schatten).

Da Sie die Synchronisierung des GG_TrafficLight-Schattens mit AWS IoT aktiviert haben, sollte derSchattenzustand in der Cloud automatisch aktualisiert werden, sobald GG_Switch eine Aktualisierungsendet. Diese Funktionalität kann verwendet werden, um den Status eines Greengrass-Geräts an dasAWS IoT offenzulegen.

138

AWS IoT Greengrass EntwicklerhandbuchModul 6: Zugriff auf andere AWS-Services

Note

Falls erforderlich, können Sie Probleme mithilfe der AWS IoT Greengrass-Core-Protokollebeheben, insbesondere runtime.log:

cd /greengrass/ggc/var/logsudo cat system/runtime.log | more

Sie können auch GGShadowSyncManager.log und GGShadowService.log einsehen.Weitere Informationen finden Sie unter Fehlersuche (p. 500).

Behalten Sie die Geräte und Abonnements eingerichtet. Sie werden sie im nächsten Modul wiederverwenden. Zudem werden Sie die gleichen Befehle ausführen.

Modul 6: Zugriff auf andere AWS-ServicesIn diesem fortgeschrittenen Modul wird gezeigt, wie AWS IoT Greengrass-Kerne mit anderenAWS-Services in der Cloud interagieren können. Es basiert auf dem „Traffic Light“-Beispiel ausModul 5 (p. 129) und fügt eine zusätzliche Lambda-Funktion hinzu, die Schattenzustände verarbeitet undeine Zusammenfassung in eine Amazon DynamoDB-Tabelle hochlädt.

139

AWS IoT Greengrass EntwicklerhandbuchModul 6: Zugriff auf andere AWS-Services

Überprüfen Sie zu Beginn, ob Sie Modul 1 (p. 70) bis Modul 5 (p. 129) abgeschlossen haben. Siebenötigen keine anderen Komponenten oder Geräte.


Note

Dieses Modul erstellt und aktualisiert eine Tabelle in DynamoDB. Obwohl die meisten derOperationen klein sind und in den Kostenloses Kontingent für AWS fallen, können bei derAusführung einiger dieser Schritte in diesem Modul Gebühren für Ihr Konto anfallen. Informationenzu Preisen finden Sie unter DynamoDB-Preisdokumentation.

Themen• Konfigurieren der Gruppenrolle (p. 141)• Erstellen und Konfigurieren der Lambda-Funktion (p. 143)• Konfigurieren von Abonnements (p. 148)• Testen der Kommunikation (p. 149)

140

https://aws.amazon.com/dynamodb/pricing/

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der Gruppenrolle

Konfigurieren der GruppenrolleBei der Gruppenrolle handelt es sich um eine IAM-Rolle, die Sie erstellen und Ihrer Gruppeanfügen. Diese Rolle enthält die Berechtigungen, die Ihre bereitgestellten Lambda-Funktionen (undKonnektoren (p. 297)) für den Zugriff auf AWS-Services verwenden. Weitere Informationen zu IAM-Rollenfinden Sie unter IAM-Benutzerhandbuch.

In diesem Schritt erstellen Sie eine Berechtigungsrichtlinie, die das Beschreiben, Erstellen undAktualisieren von Aktionen für eine Amazon DynamoDB-Tabelle gestattet. Anschließend fügen Sie dieRichtlinie an eine neue Rolle an und ordnen die Rolle Ihrer Greengrass-Gruppe zu.

Zuerst erstellen Sie eine vom Kunden verwaltete Richtlinie, die die von der Lambda-Funktion in diesemModul erforderlichen Berechtigungen gewährt.

1. Wählen Sie in der IAM-Konsole im Navigationsbereich die Option Policies (Richtlinien) und dannCreate policy (Richtlinie erstellen) aus.

2. Ersetzen Sie auf der Registerkarte JSON den Platzhalterinhalt durch die folgende Richtlinie. DieLambda-Funktion in diesem Modul verwendet diese Berechtigungen zum Erstellen und Aktualisiereneiner DynamoDB-Tabelle mit dem Namen CarStats.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "PermissionsForModule6", "Effect": "Allow", "Action": [ "dynamodb:DescribeTable", "dynamodb:CreateTable", "dynamodb:PutItem" ], "Resource": "arn:aws:dynamodb:*:*:table/CarStats" } ]}

3. Wählen Sie Review policy aus.4. Geben Sie unter Name den Namen greengrass_CarStats_Table ein und wählen Sie dann Create

policy (Richtlinie erstellen) aus.

Erstellen Sie als Nächstes eine Rolle, die die neue Richtlinie verwendet.5. Wählen Sie im Navigationsbereich Roles (Rollen) und dann Create role (Rolle erstellen).6. Wählen Sie unter Select type of trusted entity (Typ der vertrauenswürdigen Entität auswählen) die

Option AWS service (AWS-Service) aus.7. Wählen Sie unter Choose the service that will use this role (Wählen Sie den Service aus, der diese

Rolle verwendet) die Option Greengrass aus und klicken Sie anschließend auf Next: Permissions(Weiter: Berechtigungen).

8. Wählen Sie unter Attach permissions policies (Berechtigungsrichtlinien anfügen) die neue Richtliniegreengrass_CarStats_Table aus.

141

https://docs.aws.amazon.com/IAM/latest/UserGuide/

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der Gruppenrolle

9. Wählen Sie Next: Tags (Weiter: Tags) und danach Next: Review (Weiter: Prüfen) aus. In diesemTutorial werden keine Tags verwendet.

10. Geben Sie für Role name (Rollenname) den Namen Greengrass_Group_Role ein.11. Geben Sie für Role description (Rollenbeschreibung) Greengrass group role for connectors

and user-defined Lambda functions ein.

12. Wählen Sie Create role (Rolle erstellen) aus.

Fügen Sie die Rolle nun an Ihre Greengrass-Gruppe an.13. Wählen Sie in der AWS IoT-Konsole unter Greengrass Gruppen und dann Ihre AWS IoT Greengrass-

Gruppe aus.14. Wählen Sie Settings (Einstellungen) und anschließend Add Role (Rolle hinzufügen) aus.

142

AWS IoT Greengrass EntwicklerhandbuchErstellen und Konfigurieren der Lambda-Funktion

15. Wählen Sie aus der Liste der Rollen Greengrass_Group_Role aus und klicken dann auf Save(Speichern).

Erstellen und Konfigurieren der Lambda-FunktionIn diesem Schritt erstellen Sie eine Lambda-Funktion, die die Anzahl der Autos verfolgt, die über dieAmpel fahren. Immer wenn sich der GG_TrafficLight-Schattenstatus in G ändert, simuliert die Lambda-Funktion eine zufällige Anzahl durchfahrender Fahrzeuge (1 bis 20). Bei jedem dritten Umschalten derG-Leuchte sendet die Lambda-Funktion grundlegende statistische Werte, beispielsweise Minimum undMaximum, an eine DynamoDB-Tabelle.

1. Erstellen Sie auf Ihrem Computer den Ordner car_aggregator.2. Laden Sie aus dem AWS IoT Greengrass-Beispiel-Repository auf GitHub die Funktion

carAggregator.py in den Ordner car_aggregator herunter. Dies ist Ihr Lambda-Funktionscode.3. Führen Sie den folgenden Befehl in einem command-line-Fenster aus, um das Paket Boto 3 -

The AWS SDK for Python und die zugehörigen Abhängigkeiten im Ordner car_aggregator zuinstallieren. Greengrass Lambda-Funktionen verwenden das AWS SDK für den Zugriff auf andereAWS-Services. (Verwenden Sie unter Windows eine Eingabeaufforderung mit erhöhten Rechten).

pip install boto3 -t path-to-car_aggregator-folder

Dadurch wird eine Verzeichnisliste ähnlich der folgenden angezeigt:

143

https://github.com//aws-samples/aws-greengrass-samples/tree/master/traffic-light-example-python


https://github.com/boto/boto3/blob/develop/README.rst

https://github.com/boto/boto3/blob/develop/README.rst

https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx


4. Komprimieren Sie den Inhalt des Ordners car_aggregator in eine .zip-Datei namenscar_aggregator.zip. (Komprimieren Sie den Inhalt des Ordners, nicht den Ordner.) Dies ist dasBereitstellungspaket für Ihre Lambda-Funktion.

5. Erstellen Sie in der Lambda-Konsole eine Funktion mit dem Namen GG_Car_Aggregator, und legenSie die folgenden Werte für die restlichen Felder fest:

• Wählen Sie für Runtime die Option Python 2.7 aus.• Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eine

Ausführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nichtvon AWS IoT Greengrass verwendet.

Wählen Sie Create function (Funktion erstellen).

144


6. Laden Sie das Bereitstellungspaket für Ihre Lambda-Funktion hoch:



• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie unter Handler carAggregator.function_handler ein.

b. Wählen Sie Upload (Hochladen) und anschließend car_aggregator.zip.c. Wählen Sie Save aus.

145


7. Veröffentlichen Sie die Lambda-Funktion, und erstellen Sie dann einen Alias mit dem NamenGG_CarAggregator. Schrittweise Anweisungen finden Sie in den Schritten zum Veröffentlichen derLambda-Funktion (p. 93) und zum Erstellen eines Alias (p. 93) in Modul 3 (Teil 1).

8. Fügen Sie in der AWS IoT-Konsole die soeben erstellte Lambda-Funktion zu Ihrer AWS IoTGreengrass-Gruppe hinzu:

a. Klicken Sie auf der Gruppenkonfigurationsseite auf Lambdas und wählen Sie dann Lambdahinzufügen.

b. Wählen Sie Use existing Lambda aus.

c. Wählen Sie GG_Car_Aggregator und klicken Sie dann auf Weiter.

d. Wählen Sie Alias: GG_Car_Aggregator und klicken Sie dann auf Beenden.

146


Note

Sie können andere Lambda-Funktionen aus früheren Modulen entfernen.9. Bearbeiten Sie die Konfiguration der Lambda-Funktion.

a. Wählen Sie die Auslassungspunkte (…) für die Lambda-Funktion aus und klicken Sieanschließend auf Edit Configuration (Konfiguration bearbeiten).

b. Geben Sie unter Memory Limit (Speicherlimit) die Einstellung 64 MB ein.c. Wählen Sie unter Lambda-Lebenszyklus die Option Diese Funktion langlebig einstellen und

unbegrenzt ausführen und danach Aktualisieren aus.

147

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren von Abonnements

Konfigurieren von AbonnementsIn diesem Schritt erstellen Sie ein Abonnement, das es dem GG_TrafficLight-Schatten ermöglicht,aktualisierte Zustandsinformationen an die Lambda-Funktion GG_Car_Aggregator zu senden. DasAbonnement wird den Abonnements hinzugefügt, die Sie in Modul 5 (p. 129) erstellt haben, und die allefür dieses Modul erforderlich sind.


2. Legen Sie auf der Seite Select your source and target (Wählen Sie Ihre Quelle und Ihr Ziel aus) diefolgenden Werte fest:

• Wählen Sie für Eine Quelle auswählen die Option Services und danach Local Shadow Service(Service lokaler Schatten) aus.

• Wählen Sie für Ein Ziel auswählen die Option Lambdas und danach GG_Car_Aggregator aus.

Wählen Sie Next aus.

3. Geben Sie auf der Seite Filter your data with a topic (Filtern Sie Ihre Daten nach einem Thema) unterTopic filter (Themenfilter) das folgende Thema ein:

$aws/things/GG_TrafficLight/shadow/update/documents

4. Klicken Sie auf Next und danach auf Finish.

148


Dieses Modul erfordert das neue Abonnement sowie die Abonnements (p. 132), die Sie in Modul 5erstellt haben.




Testen der Kommunikation1. Öffnen Sie zwei Befehlszeilenfenster auf Ihrem Computer. Wie in Modul 5 (p. 129) ist ein Fenster für

das GG_Switch-Gerät und das andere für das GG_TrafficLight-Gerät bestimmt. Sie verwenden diese,um die gleichen Befehle wie in Modul 5 auszuführen.

Führen Sie die folgenden Befehle für das GG_Switch-Gerät aus:

cd path-to-certs-folderpython lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert switch.cert.pem --key switch.private.key --thingName GG_TrafficLight --clientId GG_Switch

Führen Sie die folgenden Befehle für das GG_TrafficLight-Gerät aus:

cd path-to-certs-folderpython trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA root-ca-cert.pem --cert light.cert.pem --key light.private.key --thingName GG_TrafficLight --clientId GG_TrafficLight

Alle 20 Sekunden aktualisiert der Schalter den Schattenzustand mit „G”, „Y” und „R” und die Lampezeigt ihren neuen Zustand an.

2. Bei jedem dritten grünen Licht (alle 3 Minuten) wird der Funktionshandler der Lambda-Funktionausgelöst und es wird ein neuer DynamoDB-Datensatz erstellt. Nachdem lightController.pyund trafficLight.py drei Minuten lang ausgeführt wurden, wechseln Sie zur AWS ManagementConsole und öffnen Sie die DynamoDB-Konsole.

3. Wählen Sie USA Ost (Nord-Virginia) im Menü für AWS-Regionen aus. Dies ist die Region, in der dieGG_Car_Aggregator-Funktion die Tabelle erstellt.

4. Wählen Sie im Navigationsbereich Tables (Tabellen) und anschließend die Tabelle CarStats (CarStats)aus.

149



Auf der Registerkarte Einträge sollten Sie Einträge mit grundlegenden Statistikdaten zu dendurchgefahrenen Fahrzeugen sehen (einen Eintrag alle drei Minuten). Möglicherweise müssen Siedie Schaltfläche zum Aktualisieren wählen, um die an der Tabelle vorgenommenen Aktualisierungenanzuzeigen.

5. Wenn der Test nicht erfolgreich ist, überprüfen Sie die Greengrass-Protokolle auf Informationen, dieSie bei der Fehlerbehebung unterstützen können.

a. Wechseln Sie zum Root-Benutzer und navigieren Sie zum Verzeichnis log. Der Zugriff auf AWSIoT Greengrass-Protokolle erfordert Root-Berechtigungen.

150

AWS IoT Greengrass EntwicklerhandbuchModul 7: Simulation der Hardware-Sicherheitsintegration

sudo sucd /greengrass/ggc/var/log

b. Prüfen Sie runtime.log auf Fehler.

cat system/runtime.log | grep 'ERROR'

c. Prüfen Sie das Protokoll, das von der Lambda-Funktion generiert wurde.

cat user/Region/account-id/GG_Car_Aggregator.log

Die Skripts trafficLight.py und lightController.py speichernVerbindungsinformationen im Ordner groupCA. Dieser wird im selben Ordner wie die Skriptserstellt. Wenn Sie Verbindungsfehler erhalten, stellen Sie sicher, dass die IP-Adresse in der Dateiggc-host mit derjenigen des Einzel-IP-Adressen-Endpunkts übereinstimmt, den Sie in diesemSchritt (p. 132) für den Core konfiguriert haben.

Weitere Informationen finden Sie unter Fehlersuche (p. 500).

Dies ist das Ende des grundlegenden Tutorials. Sie sollten jetzt über grundlegende Kenntnisse des AWSIoT Greengrass-Programmiermodells, der diesem zugrundeliegenden Konzepte wie AWS IoT Greengrass-Kerne, Gruppen, Abonnements oder Geräte und des Bereitstellungsprozesses für am Edge ausgeführteLambda-Funktionen verfügen.

Sie können die DynamoDB-Tabelle und die Greengrass Lambda-Funktionen und -Abonnements löschen.Um die Kommunikation zwischen dem AWS IoT Greengrass-Core-Gerät und der AWS IoT-Cloud zubeenden, öffnen Sie ein Terminal auf dem Core-Gerät und führen Sie einen der folgenden Befehle aus:

• So schließen Sie das AWS IoT Greengrass-Core-Gerät:

sudo halt

• So beenden Sie den AWS IoT Greengrass-Daemon:


Modul 7: Simulation der Hardware-Sicherheitsintegration

Diese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

Dieses Modul für Fortgeschrittene zeigt Ihnen, wie Sie ein simuliertes Hardware-Sicherheitsmodul (HSM)für die Verwendung mit einem Greengrass Core konfigurieren. Die Konfiguration verwendet SoftHSM.Dabei handelt es sich um eine reine Software-Implementierung mithilfe der PKCS#11 (p. 157) ApplicationProgramming Interface (API). Zweck dieses Moduls ist es, Ihnen die Einrichtung einer Umgebung zuermöglichen, in der Sie lernen und erste Tests in einer reinen Software-Implementierung der PKCS#11-API durchführen können. Das Modul wird nur für Lern- und Ersttests bereitgestellt, nicht für den produktivenEinsatz jeglicher Art.

Mit dieser Konfiguration können Sie mit einem PKCS#11-kompatiblen Service zum Speichern Ihrerprivaten Schlüssel experimentieren. Weitere Informationen über die reine Software-Implementierung finden

151

AWS IoT Greengrass EntwicklerhandbuchInstallieren von SoftHSM

Sie unter SoftHSM. Weitere Informationen zur Integration der Hardware-Sicherheit auf einem AWS IoTGreengrass-Core, einschließlich allgemeiner Anforderungen, finden Sie unter the section called “Hardware-Sicherheit” (p. 435).

Important

Dieses Modul ist nur für Experimentierzwecke gedacht. Wir raten dringend davon ab, SoftHSMin einer Produktionsumgebung einzusetzen, da dies ein falsches Gefühl von zusätzlicherSicherheit vermitteln könnte. Die resultierende Konfiguration bietet jedoch keine tatsächlichenSicherheitsvorteile. Die in SoftHSM gespeicherten Schlüssel sind nicht sicherer als jede andere Artder Geheimhaltung in der Greengrass-Umgebung.Dieses Modul soll Ihnen ermöglichen, sich über die PKCS#11-Spezifikation zu informierenund erste Tests Ihrer Software durchzuführen, wenn Sie planen, in Zukunft ein echteshardwarebasiertes HSM einzusetzen.Sie müssen Ihre zukünftige Hardware-Implementierung separat und vollständig vor jederProduktionsnutzung testen, da es Unterschiede zwischen der in SoftHSM bereitgestelltenPKCS#11-Implementierung und einer hardwarebasierten Implementierung geben kann.

Wenn Sie bei der Einbindung eines unterstützten Hardware-Sicherheitsmoduls (p. 435) Hilfe benötigen,wenden Sie sich an Ihren AWS Enterprise Support Mitarbeiter.

Bevor Sie beginnen, sollten Sie das Modul 1 (p. 70) und Modul 2 (p. 81) des Tutorials Erste Schritteabgeschlossen haben. In diesem Modul gehen wir davon aus, dass Ihr Core bereits bereitgestellt ist undmit AWS kommuniziert. Dieses Modul sollte etwa 30 Minuten in Anspruch nehmen.

Installieren der SoftHSM-SoftwareIn diesem Schritt installieren Sie SoftHSM und die pkcs11-Tools, mit denen Sie Ihre SoftHSM-Instanceverwalten.

• Führen Sie in einem Terminal auf Ihrem AWS IoT Greengrass-Core-Gerät den folgenden Befehl aus:

sudo apt-get install softhsm2 libsofthsm2-dev pkcs11-dump

Weitere Informationen zu diesen Paketen finden Sie unter Installieren von softhsm2, Installieren vonlibsofthsm2-dev und Installieren von pkcs11-dump.

Note

Wenn bei der Verwendung dieses Befehls auf Ihrem System Probleme auftreten, sieheSoftHSM Version 2 auf GitHub. Diese Seite bietet weitere Installationsinformationen,einschließlich der Anleitung zum Erstellen aus dem Quellcode.

Konfigurieren von SoftHSMIn diesem Schritt konfigurieren Sie SoftHSM.

1. Wechseln Sie zum Root-Benutzer.

sudo su

2. Verwenden Sie die Handbuchseite, um den systemweiten softhsm2.conf-Speicherort zu suchen.Ein häufiger Speicherort ist /etc/softhsm/softhsm2.conf, jedoch kann der Speicherort aufeinigen Systemen abweichen.

man softhsm2.conf

152

https://www.opendnssec.org/softhsm/

https://www.howtoinstall.co/en/ubuntu/xenial/softhsm2

https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev

https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev

https://www.howtoinstall.co/en/ubuntu/xenial/pkcs11-dump

https://github.com/opendnssec/SoftHSMv2

https://github.com/opendnssec/SoftHSMv2#configure-1

AWS IoT Greengrass EntwicklerhandbuchImportieren des privaten Schlüssels

3. Erstellen Sie das Verzeichnis für die softhsm2-Konfigurationsdatei im systemweiten Speicherort. Indiesem Beispiel nehmen wir an, der Speicherort lautet /etc/softhsm/softhsm2.conf.

mkdir -p /etc/softhsm

4. Erstellen Sie das Token-Verzeichnis im Verzeichnis /greengrass.

Note

Wenn dieser Schritt übersprungen wird, meldet softhsm2 ERROR: Could not initializethe library.

mkdir -p /greengrass/softhsm2/tokens

5. Konfigurieren Sie das Token-Verzeichnis.

echo "directories.tokendir = /greengrass/softhsm2/tokens" > /etc/softhsm/softhsm2.conf

6. Konfigurieren Sie eine Datei-basierte Backend.

echo "objectstore.backend = file" >> /etc/softhsm/softhsm2.conf

Note

Diese Konfigurationseinstellungen sind nur für Experimentierzwecke gedacht. Um alleKonfigurationsoptionen anzuzeigen, lesen Sie die Handbuchseite für die Konfigurationsdatei.

man softhsm2.conf

Importieren des privaten Schlüssels in SoftHSMIn diesem Schritt initialisieren Sie das SoftHSM-Token, konvertieren das Format des privaten Schlüsselsund importieren dann den privaten Schlüssel.

1. Initialisieren Sie das SoftHSM-Token.

softhsm2-util --init-token --slot 0 --label greengrass --so-pin 12345 --pin 1234

Note

Geben Sie bei Aufforderung den SO-Pin 12345 und den Benutzer-Pin 1234 ein. AWS IoTGreengrass verwendet nicht den SO (Supervisor) Pin, sodass Sie jeden beliebigen Wertverwenden können.

2. Konvertieren Sie den privaten Schlüssel in ein Format, das vom SoftHSM-Import-Tool verwendetwerden kann. Für dieses Tutorial konvertieren Sie den privaten Schlüssel, den Sie von der OptionEasy Group creation in Modul 2 (p. 81) des Tutorials Erste Schritte erhalten haben.

openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in hash.private.key -out hash.private.pem

3. Importieren Sie den privaten Schlüssel in SoftHSM. Führen Sie nur einen der folgenden Befehle aus, jenach Ihrer softhsm2-Version.

153

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren des Greengrass-Cores

Raspbian softhsm2-util v2.2.0-Syntax

softhsm2-util --import hash.private.pem --token greengrass --label iotkey --id 0000 --pin 12340

Ubuntu softhsm2-util v2.0.0-Syntax

softhsm2-util --import hash.private.pem --slot 0 --label iotkey --id 0000 --pin 1234

Dieser Befehl identifiziert den Slot als 0 und definiert das Schlüssel-Label als iotkey. Sie brauchendiese Werte im nächsten Abschnitt.

Nachdem der private Schlüssel importiert wurde, können Sie ihn optional aus dem Verzeichnis /greengrass/certs entfernen. Achten Sie darauf, dass sich die Stammzertifikate für CA und Gerät imVerzeichnis befinden.

Konfigurieren Sie den Greengrass Core für dieVerwendung von SoftHSM.In diesem Schritt ändern Sie die Greengrass Core-Konfigurationsdatei für die Verwendung von SoftHSM.

1. Suchen Sie den Pfad zur SoftHSM-Anbieterbibliothek (libsofthsm2.so) auf Ihrem System:

a. Holen Sie sich die Liste der installierten Pakete für die Bibliothek.

sudo dpkg -L libsofthsm2

Die Datei libsofthsm2.so befindet sich im Verzeichnis softhsm.b. Kopieren Sie den vollständigen Pfad in die Datei (z. B. /usr/lib/x86_64-linux-gnu/

softhsm/libsofthsm2.so). Sie benötigen sie später.2. Stoppen Sie den AWS Greengrass-Daemon.


3. Öffnen Sie die Greengrass-Konfigurationsdatei. Dies ist die Datei config.json (p. 23) im Verzeichnis/greengrass/config.

Note

Die Beispiele in diesem Verfahren sind unter der Annahme verfasst, dass die Dateiconfig.json das Format verwendet, das aus der Option Easy Group creation in Modul2 (p. 81) des Tutorials Erste Schritte erzeugt wird.

4. Fügen Sie in das Objekt crypto.principals das folgende MQTT Server-Zertifikat-Objekt ein.Fügen Sie bei Bedarf ein Komma hinzu, um eine gültige JSON-Datei zu erstellen.

"MQTTServerCertificate": { "privateKeyPath": "path-to-private-key" }

154

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren des Greengrass-Cores

5. Fügen Sie in das Objekt crypto das folgende PKCS11-Objekt ein. Fügen Sie bei Bedarf ein Kommahinzu, um eine gültige JSON-Datei zu erstellen.

"PKCS11": { "P11Provider": "/path-to-pkcs11-provider-so", "slotLabel": "crypto-token-name", "slotUserPin": "crypto-token-user-pin" }

Die Datei sollte wie folgt aussehen:

{ "coreThing" : { "caPath" : "root.ca.pem", "certPath" : "hash.cert.pem", "keyPath" : "hash.private.key", "thingArn" : "arn:partition:iot:Region:account-id:thing/core-thing-name", "iotHost" : "host-prefix.iot.Region.amazonaws.com", "ggHost" : "greengrass.iot.Region.amazonaws.com", "keepAlive" : 600 }, "runtime" : { "cgroup" : { "useSystemd" : "yes" } }, "managedRespawn" : false, "crypto": { "PKCS11": { "P11Provider": "/path-to-pkcs11-provider-so", "slotLabel": "crypto-token-name", "slotUserPin": "crypto-token-user-pin" }, "principals" : { "MQTTServerCertificate": { "privateKeyPath": "path-to-private-key" }, "IoTCertificate" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key", "certificatePath" : "file:///greengrass/certs/hash.cert.pem" }, "SecretsManager" : { "privateKeyPath" : "file:///greengrass/certs/hash.private.key" } }, "caPath" : "file:///greengrass/certs/root.ca.pem" }}

Note

Um Over-The-Air (OTA)-Updates mit Hardware-Sicherheit zu verwenden, muss das ObjektPKCS11 auch die Eigenschaft OpenSSLEngine enthalten. Weitere Informationen finden Sieunter the section called “Konfigurieren von OTA-Updates” (p. 442).

6. Bearbeiten Sie das Objekt crypto:

a. Konfigurieren Sie das Objekt PKCS11.

• Geben Sie für P11Provider den vollständigen Pfad zur Datei libsofthsm2.so ein.• Geben Sie unter slotLabel den Wert greengrass ein.• Geben Sie unter slotUserPin den Wert 1234 ein.

155

AWS IoT Greengrass EntwicklerhandbuchTesten der Konfiguration

b. Konfigurieren Sie die privaten Schlüsselpfade im Objekt principals. Bearbeiten Sie dieEigenschaft certificatePath nicht.

• Geben Sie für die Eigenschaften privateKeyPath den folgenden RFC 7512 PKCS#11-Pfad ein (der die Bezeichnung des Schlüssels angibt). Machen Sie dies für die Prinzipale vonIoTCertificate, SecretsManager und MQTTServerCertificate.

pkcs11:object=iotkey;type=private

c. Prüfen Sie das crypto-Objekt. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:

"crypto": { "PKCS11": { "P11Provider": "/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so", "slotLabel": "greengrass", "slotUserPin": "1234" }, "principals": { "MQTTServerCertificate": { "privateKeyPath": "pkcs11:object=iotkey;type=private" }, "SecretsManager": { "privateKeyPath": "pkcs11:object=iotkey;type=private" }, "IoTCertificate": { "certificatePath": "file://certs/core.crt", "privateKeyPath": "pkcs11:object=iotkey;type=private" } }, "caPath": "file://certs/root.ca.pem" }

7. Entfernen Sie die Werte für caPath, certPath und keyPath aus dem coreThing-Objekt. Dassollte bei Ihnen ähnlich wie im folgenden Bild aussehen:

"coreThing" : { "thingArn" : "arn:partition:iot:Region:account-id:thing/core-thing-name", "iotHost" : "host-prefix-ats.iot.Region.amazonaws.com", "ggHost" : "greengrass-ats.iot.Region.amazonaws.com", "keepAlive" : 600}

Note

Für dieses Tutorial geben Sie für alle Prinzipale den gleichen privaten Schlüssel an. WeitereInformationen zur Auswahl des privaten Schlüssels für den lokalen MQTT-Server finden Sie unterPerformance (p. 440). Weitere Informationen über den Manager lokaler Secrets finden Sie unterSecrets für Core bereitstellen (p. 274).

Testen der Konfiguration• Starten Sie den AWS Greengrass-Daemon.


Wenn der Daemon erfolgreich startet, dann ist Ihr Core korrekt konfiguriert.

156


Sie sind nun bereit, die PKCS#11-Spezifikation kennenzulernen und erste Tests mit der PKCS#11-APIdurchzuführen, die von der SoftHSM-Implementierung bereitgestellt wird.

Important

Auch hier ist es äußerst wichtig zu wissen, dass dieses Modul nur zum Lernen und Testengedacht ist. Es erhöht nicht wirklich den Sicherheitsstatus Ihrer Greengrass-Umgebung.Stattdessen soll das Modul Ihnen ermöglichen, mit dem Lernen und Testen zu beginnen,um sich auf den Einsatz eines echten hardwarebasierten HSM in der Zukunft vorzubereiten.Zu diesem Zeitpunkt müssen Sie Ihre Software vor jeder Produktionsnutzung separatund vollständig mit dem hardwarebasierten HSM testen, da es Unterschiede zwischender in SoftHSM bereitgestellten PKCS#11-Implementierung und einer hardwarebasiertenImplementierung geben kann.

Weitere Informationen finden Sie auch unter:• PKCS #11 Kryptographische Token-Schnittstelle, Bedienungsanleitung Version 2.40. Herausgegeben

von John Leiseboer und Robert Griffin. 16. November 2014. OASIS-Ausschuss Anmerkung 02. http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html. Letzte Version: http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html.

• RFC 7512

157

http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html


http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html




OTA-Updates der AWS IoTGreengrass Core-Software


Die AWS IoT Greengrass Core-Software wird mit einem Agenten geliefert, der eine Aktualisierungder Core-Software oder des Agenten selbst auf die neueste Version durchführen kann. OTA-Updates sind zwar optional, können Ihnen jedoch bei der Verwaltung Ihrer AWS IoT Greengrass-Core-Geräte helfen. Sie können eine Aktualisierung über die AWS IoT Greengrass-Konsole oder dieCreateSoftwareUpdateJob-API starten. Die Anwendung einer OTA-Aktualisierung bietet folgendeVorteile:

• Schließen von Sicherheitslücken.• Behebung von Software-Stabilitätsproblemen.• Bereitstellung neuer oder verbesserter Funktionen.

Sie müssen keine manuellen Schritte ausführen. Das Gerät, auf dem die Core-Software ausgeführt wird,muss auch nicht physisch vorhanden sein. Im Falle einer fehlgeschlagenen Aktualisierung nimmt der OTA-Aktualisierungsagent ein Rollback vor.

Zur Unterstützung von OTA-Aktualisierungen der Greengrass Core-Software muss Ihr Greengrass Core-Gerät folgende Bedingungen erfüllen:

• Der verfügbare lokale Speicherplatz muss dreimal so groß wie die Laufzeitnutzungsanforderung desCores sein.

• In der Partition, die die Greengrass Core-Plattformsoftware enthält, darf Trusted Boot nicht aktiviertsein. (AWS IoT Greengrass-Core kann auf einer Partition mit aktiviertem Trusted Boot installiert undausgeführt werden, eine OTA-Aktualisierung ist dann aber nicht möglich.)

• Es darf nicht so konfiguriert werden, dass ein Netzwerk-Proxy (p. 49) verwendet wird.• Es muss über Lese-/Schreibberechtigungen für die Partition mit der Greengrass Core-Plattformsoftware

verfügen.• Eine Verbindung zur AWS-Cloud muss bestehen.• Es muss über korrekt konfigurierte AWS IoT Greengrass-Core und entsprechende Zertifikate verfügen.

Berücksichtigen Sie vor einer OTA-Aktualisierung der Greengrass Core-Software die Auswirkungen auf dieGeräte in Ihrer Greengrass-Gruppe, sowohl das Core-Gerät als auch die Client-Geräte, die lokal mit demCore verbunden sind:

• Der Core wird während der Aktualisierung heruntergefahren.• Alle auf dem Core ausgeführten Lambda-Funktionen werden beendet. Wenn diese Funktionen Daten

auf lokale Ressourcen schreiben, kann es sein, dass diese Ressourcen in einem fehlerhaften Statusverbleiben, wenn sie nicht ordnungsgemäß heruntergefahren werden.

• Während der Ausfallzeit des Core gehen alle seine Verbindungen mit der Cloud verloren. Von Client-Geräten über den Core geleitete Nachrichten gehen verloren.

• Zwischenspeicherungen von Anmeldeinformationen gehen verloren.• Warteschlangen, in denen anstehende Aufgaben für Lambda-Funktionen enthalten sind, gehen verloren.• Langlebige Lambda-Funktionen verlieren ihre dynamischen Statusinformationen und alle anstehenden

Aufgaben werden gelöscht.

158

AWS IoT Greengrass EntwicklerhandbuchGreengrass OTA-Update-Agent

Die folgenden Statusinformationen bleiben während einer OTA-Aktualisierung erhalten:

• Lokale Schatten• Greengrass-Protokolle• OTA-Aktualisierungsagent-Protokolle

Greengrass OTA-Update-AgentDer Greengrass OTA-Aktualisierungsagent ist die Softwarekomponente auf dem Gerät, die in der Clouderstellte und bereitgestellte Aktualisierungsaufträge handhabt. Der OTA-Aktualisierungsagent vonGreengrass wird im selben Softwarepaket wie die AWS IoT Greengrass Core-Software verteilt. Der Agentbefindet sich in ./greengrass/ota/ota_agent/ggc-ota. Er erstellt seine Protokolle in /var/log/greengrass/ota/ggc_ota.txt.

Sie können den Greengrass OTA-Aktualisierungsagent starten, indem Sie die Binärdatei manuell ausführenoder als Teil eines Init-Skripts, beispielsweise einer systemd service-Datei, integrieren. Die Binärdateisollte als root ausgeführt werden. Beim Start wartet der Greengrass OTA-Aktualisierungsagent aufGreengrass-Aktualisierungsaufträge aus der Cloud und führt sie sequenziell aus. Der Greengrass OTA-Aktualisierungsagent ignoriert alle anderen IoT-Auftragstypen.

Starten Sie nicht mehrere OTA-Aktualisierungsagent-Instances, da dies zu Konflikten führen kann.

Wenn Ihr Greengrass Core oder Greengrass OTA-Aktualisierungsagent-Agent von einem Init-Systemverwaltet wird, beachten Sie die Informationen unter Integration mit Init Systemen (p. 162) zu denentsprechenden Konfigurationen.

CreateSoftwareUpdateJob API

Die CreateSoftwareUpdateJob API erstellt eine Software-Aktualisierung für einen oder mehrere Cores.Diese API kann verwendet werden, um den OTA-Aktualisierungsagent und die Greengrass Core-Softwarezu aktualisieren. Sie nutzt die AWS IoT-Aufgaben. Diese stellen weitere Befehle für die Verwaltung vonAktualisierungsaufgaben für die Greengrass Core-Software bereit. Weitere Informationen hierzu finden Sieunter Aufgaben.

Das folgende Beispiel zeigt, wie ein Auftrag zur Aktualisierung der AWS IoT Greengrass Core-Software aufeinem Core-Gerät über die CLI erstellt wird:

aws greengrass create-software-update-job \ --update-targets-architecture x86_64 \ --update-targets arn:aws::iot:Region:123456789012:thing/myDevice \ --update-targets-operating-system ubuntu \ --software-to-update core \ --s3-url-signer-role arn:aws::iam::123456789012:role/IotS3UrlPresigningRole \ --update-agent-log-level WARN \ --amzn-client-token myClientToken1

Der Befehl create-software-update-job gibt ein JSON-Objekt zurück, das die Auftrags-ID und den ARN desAuftrags enthält:

{ "IotJobId": "Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303", "IotJobArn": "arn:aws::iot:Region:123456789012:job/Greengrass-OTA-c3bd7f36-ee80-4d42-8321-a1da0e5b1303"}

Der Befehl create-software-update-job hat die folgenden Parameter:

159

https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html


--update-targets-architecture

Die Architektur des Core-Geräts. Zulässige Werte sind: armv7l, x86_64 oder aarch64.--update-targets

Eine Liste der Ziele, auf die die OTA-Aktualisierung angewendet werden soll. Die Liste kann die ARNsvon Gegenständen enthalten, die Cores sind, oder die ARNs von Gruppen von Gegenständen, derenMitglieder Cores sind. Weitere Informationen finden Sie unter IoT-Gruppen von Gegenständen.

--update-targets-operating-system

Das Betriebssystem des Core-Geräts. Zulässige Werte sind: ubuntu, amazon_linux, raspbianoder openwrt.

--software-to-update

Gibt an, ob die Core-Software oder die Software des OTA-Aktualisierungsagent aktualisiert werdensoll. Zulässige Werte sind: core oder ota_agent.

--s3-url-signer-role

Die IAM-Rolle, die für das Vorsignieren der S3-URL verwendet wird, die zum AWS IoT Greengrass-Software-Update führt. Sie müssen eine Rolle angeben, die über die entsprechende Richtlinie derBerechtigungen verfügt. Die folgende Beispielrichtlinie erlaubt den Zugriff auf AWS IoT Greengrass-Software-Updates in den angegebenen AWS-Regionen:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "AllowAccessToGreengrassOTAUpdateArtifacts", "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::us-east-1-greengrass-updates/*", "arn:aws:s3:::us-west-2-greengrass-updates/*", "arn:aws:s3:::ap-northeast-1-greengrass-updates/*", "arn:aws:s3:::ap-southeast-2-greengrass-updates/*", "arn:aws:s3:::eu-central-1-greengrass-updates/*", "arn:aws:s3:::eu-west-1-greengrass-updates/*" ] } ]}

Note

Sie können auch ein Namensschema mit dem Platzhalter * für die Resource-Eigenschaftverwenden , um Zugriff auf AWS IoT Greengrass-Software-Updates zu gewähren. Beispiel:Das folgende Format erlaubt den Zugriff auf Software-Updates für alle unterstützten AWS-Regionen (derzeitige und zukünftige), die die Partition aws verwenden. Stellen Sie sicher,dass Sie die richtigen Partitionen für die AWS-Regionen verwenden, die Sie unterstützenmöchten.

"Resource": "arn:aws:s3:::*-greengrass-updates/*"

Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

Hier finden Sie ein Beispiel für ein AssumeRole-Richtliniendokument mit den mindestenserforderlichen vertrauenswürdigen Entitäten:

160

https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html



https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html


{ "Version": "2012-10-17", "Statement": [ { "Action": "sts:AssumeRole", "Principal": { "Service": "iot.amazonaws.com" }, "Effect": "Allow", "Sid": "AllowIotToAssumeRole" } ]}

--amzn-client-token

(Optional) Ein Client-Token für idempotente Anfragen. Geben Sie einen eindeutigen Token an, umzu verhindern, dass aufgrund interner wiederholter Versuche doppelte Aktualisierungen durchgeführtwerden.

--update-agent-log-level

(Optional) Die Protokollierungsebene für vom OTA-Aktualisierungsagent generierteProtokollierungsanweisungen. Zulässige Werte sind: NONE, TRACE, DEBUG, VERBOSE, INFO, WARN,ERROR oder FATAL. Der Standardwert ist ERROR.

Hier finden Sie ein Beispiel für eine IAM-Richtlinie mit den für den Aufruf der API mindestens erforderlichenBerechtigungen:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "AllowCreateSoftwareUpdateJob", "Action": [ "greengrass:CreateSoftwareUpdateJob" ], "Effect": "Allow", "Resource": "*" }, { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": "arn:aws:s3:us-east-1:123456789012:role/IotS3UrlPresigningRole" }, { "Effect": "Allow", "Action": [ "iot:CreateJob" ], "Resource": "*" } ]}

Note

Da AWS IoT Greengrass nur auf einem Teil der mit diesem Befehl möglichen Kombinationen ausArchitektur und Betriebssystem unterstützt wird, lehnt CreateSoftwareUpdateJob Anfragen ab,außer für die folgenden unterstützten Plattformen:

161

AWS IoT Greengrass EntwicklerhandbuchIntegration mit Init-Systemen

• ubuntu/x86_64• ubuntu/aarch64• amazon_linux/x86_64• raspbian/armv7l• openwrt/aarch64• openwrt/armv7l

Integration mit Init-SystemenWährend einer OTA-Aktualisierung werden Binärdateien, einschließlich einiger gerade ausgeführterDateien, aktualisiert und neu gestartet. Dies kann zu Konflikten führen, wenn ein Init-System den Zustandder AWS IoT Greengrass Core-Software oder des Greengrass OTA-Aktualisierungsagent währendder Aktualisierung überwacht. Um die Integration des OTA-Aktualisierungsmechanismus mit IhrenÜberwachungsstrategien zu unterstützen, können Sie Shell-Skripts schreiben, die vor und nach einerAktualisierung ausgeführt werden. Um den OTA-Aktualisierungsagent zum Ausführen dieser Shell-Skriptsanzuweisen, müssen Sie das Flag "managedRespawn" : true in die Datei ./greengrass/config/config.json einschließen. zum Beispiel:

{

"coreThing": { … }, "runtime": { … }, "managedRespawn": true

}

Wenn managedRespawn auf true eingestellt ist, müssen die Skripts im Verzeichnis vorhanden sein.Andernfalls schlägt die Aktualisierung fehl. Die Verzeichnisstruktur sollte wie folgt aussehen:

<greengrass_root>|-- certs|-- config| |-- config.json|-- ggc|-- usr/scripts| |-- ggc_pre_update.sh| |-- ggc_post_update.sh| |-- ota_pre_update.sh| |-- ota_post_update.sh|-- ota

OTA-Selbstaktualisierung mit Managed RespawnWenn der OTA-Aktualisierungsagent eine Selbstaktualisierung vorbereitet und managedRespawn auf truegesetzt ist, sucht der OTA-Aktualisierungsagent im Verzeichnis ./greengrass/usr/scripts nach demota_pre_update.sh-Skript und führt es aus.

Wenn der OTA-Aktualisierungsagent die Aktualisierung abgeschlossen hat, versucht er, dasota_post_update.sh-Skript über das Verzeichnis ./greengrass/usr/scripts auszuführen.

162

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Core-

Aktualisierung mit Managed Respawn

AWS IoT Greengrass Core-Aktualisierung mitManaged RespawnWenn der OTA-Aktualisierungsagent eine AWS IoT Greengrass-Core-Aktualisierung vorbereitet undmanagedRespawn auf true gesetzt ist, sucht der OTA-Aktualisierungsagent im Verzeichnis ./greengrass/usr/scripts nach dem ggc_pre_update.sh-Skript und führt es aus.

Wenn der OTA-Aktualisierungsagent-Agent die Aktualisierung abgeschlossen hat, versucht er, dasggc_post_update.sh-Skript vom Verzeichnis ./greengrass/usr/scripts aus auszuführen.

• Die benutzerdefinierten Skripts in ./greengrass/usr/scripts sollten Eigentum von Root sein undnur von Root ausgeführt werden können.

• Wenn managedRespawn auf true gesetzt ist, müssen die Skripts vorhanden sein und einenerfolgreichen Antwortcode zurückgeben.

• Wenn managedRespawn auf false gesetzt ist, werden die Skripts nicht ausgeführt, selbst wenn sie sichauf dem Gerät befinden.

• Auf einem Gerät, das Ziel einer Aktualisierung ist, dürfen nicht zwei Instances des OTA-Aktualisierungsagent für denselben AWS IoT-Gegenstand ausgeführt werden. Andernfalls verarbeitendie beiden Agenten dieselben Aufträge, was zu Konflikten führt.

Selbstaktualisierung des OTA-Update-AgentenGehen Sie für eine Selbstaktualisierung des OTA-Aktualisierungsagent wie folgt vor:

1. Stellen Sie sicher, dass das AWS IoT Greengrass-Core-Gerät korrekt mit gültigen config.json-Dateieinträgen und erforderlichen Zertifikaten bereitgestellt ist.

2. Wenn der OTA-Aktualisierungsagent von einem Init-System verwaltet wird, stellen Sie in der Dateiconfig.json sicher, dass die Eigenschaft managedRespawn auf true eingestellt ist. Stellen Sie auchsicher, dass sich die Skripts ota_pre_update.sh und ota_post_update.sh im Verzeichnis ./greengrass/usr/scripts befinden.

3. Führen Sie ./greengrass/ota/ota_agent/ggc-ota.4. Verwenden Sie die CreateSoftwareUpdateJob-API zum Erstellen eines OTA-

Selbstaktualisierungsauftrags. Stellen Sie sicher, dass der Parameter --software-to-update aufota_agent gesetzt ist.

Greengrass Core-SoftwareaktualisierungGehen Sie für eine AWS IoT Greengrass Core-Softwareaktualisierung wie folgt vor:

1. Stellen Sie sicher, dass das AWS IoT Greengrass-Core-Gerät korrekt mit gültigen config.json-Dateieinträgen und erforderlichen Zertifikaten bereitgestellt ist.

2. Wenn die AWS IoT Greengrass Core-Software von einem Init-System verwaltet wird, stellen Sie in derDatei config.json sicher, dass die Eigenschaft managedRespawn auf true eingestellt ist. StellenSie sicher, dass sich die Skripts ggc_pre_update.sh und ggc_post_update.sh im Verzeichnis ./greengrass/usr/scripts befinden.

3. Führen Sie ./greengrass/ota/ota_agent/ggc-ota.4. Verwenden Sie die API CreateSoftwareUpdateJob zum Erstellen eines Aktualisierungsauftrags für

die Core-Software. Stellen Sie sicher, dass der Parameter --software-to-update auf core gesetztist.

163


Zurücksetzen von BereitstellungenDiese Funktion ist für AWS IoT Greengrass Core v1.1 und höher verfügbar.

Das Zurücksetzen der Bereitstellungen einer Gruppe ist in folgenden Fällen ratsam:

• Die Gruppe soll gelöscht werden (z. B. wenn das Image für den Core der Gruppe erneut erstellt wurde).• Der Core der Gruppe soll in eine andere Gruppe verschoben werden.• Die Gruppe soll wieder in den Zustand vor der Bereitstellung versetzt werden.• Die Bereitstellungskonfiguration soll vom Core-Gerät entfernt werden.• Sensible Daten sollen vom Core-Gerät oder aus der Cloud gelöscht werden.• Eine neue Gruppenkonfiguration soll auf einem Core bereitgestellt werden, ohne dass der Core durch

einen anderen in der aktuellen Gruppe ersetzt wird.

Note

Die Funktion zum Zurücksetzen von Bereitstellungen ist in AWS IoT Greengrass >Core Softwarev1.0.0 nicht verfügbar. Beachten Sie außerdem, dass bei Verwendung von v1.0.0 keine Gruppengelöscht werden können, die bereits bereitgestellt wurden.

Der Befehl ResetDeployments löscht alle in der Cloud für eine bestimmte Gruppe gespeichertenBereitstellungsinformationen. Danach weist er das Core-Gerät der Gruppe an, auch sämtlicheInformationen im Zusammenhang mit Bereitstellungen zu löschen (Lambda-Funktionen,Benutzerprotokolle, Schattendatenbank und Serverzertifikat, jedoch nicht die benutzerdefinierte config.json-Datei oder die Greengrass Core-Zertifikate). Die Bereitstellungen einer Gruppe können nicht zurückgesetztwerden, wenn für diese Gruppe aktuell eine Bereitstellung mit dem Status Pending oder Buildingvorhanden ist.

aws greengrass reset-deployments --group-id <GroupId> [--force]

Argumente für den CLI-Befehl reset-deployments:

--group-id

Die Gruppen-ID.--force

[Optional] Verwenden Sie diesen Parameter, wenn das Core-Gerät der Gruppe verloren, gestohlenoder zerstört wurde. Diese Option bewirkt, dass während des Zurücksetzens der Bereitstellungeneine Erfolgsmeldung ausgegeben wird, sobald alle Bereitstellungsinformationen in der Cloud gelöschtwurden, ohne auf die Antwort des Core-Geräts zu warten. Wenn das Core-Gerät jedoch aktiv ist oderspäter aktiv wird, führt es die Bereinigungen ebenfalls durch.

Die Ausgabe des CLI-Befehls reset-deployments sieht wie folgt aus:

{ "DeploymentId": "4db95ef8-9309-4774-95a4-eea580b6ceef", "DeploymentArn": "arn:aws:greengrass:us-west-2:106511594199:/greengrass/groups/b744ed45-a7df-4227-860a-8d4492caa412/deployments/4db95ef8-9309-4774-95a4-eea580b6ceef"}

164


Sie können den Status der Bereitstellungsrücksetzung mit dem CLI-Befehl get-deployment-statusprüfen.

aws greengrass get-deployment-status --deployment-id DeploymentId --group-id GroupId

Argumente für den CLI-Befehl get-deployment-status:

--deployment-id

Die Bereitstellungs-ID.--group-id

Die Gruppen-ID.

Die Ausgabe des CLI-Befehls get-deployment-status sieht wie folgt aus:

{ "DeploymentStatus": "Success", "UpdatedAt": "2017-04-04T00:00:00.000Z"}

Der Wert von DeploymentStatus wird auf Building gesetzt, wenn das Zurücksetzen derBereitstellungen vorbereitet wird. Wenn das Zurücksetzen vorbereitet, aber noch nicht vom AWS IoTGreengrass-Core aufgenommen wurde, ändert sich der Wert von DeploymentStatus zu InProgress.

Wenn das Zurücksetzen fehlschlägt, werden Fehlerinformationen in der Antwort zurückgegeben.

Weitere Informationen finden Sie auch unter:• ResetDeployments in der AWS IoT Greengrass-API-Referenz• GetDeploymentStatus in der AWS IoT Greengrass-API-Referenz

165

https://docs.aws.amazon.com/greengrass/latest/apireference/resetdeployments-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getdeploymentstatus-get.html


Erstellen von Sammelbereitstellungenfür Gruppen

Sie können einfache API-Aufrufe verwenden, um eine große Anzahl von Greengrass-Gruppen aufeinmal bereitzustellen. Diese Bereitstellungen werden mit einer adaptiven Rate ausgelöst, die eine festeObergrenze hat.

Dieses Tutorial beschreibt, wie Sie mit dem AWS CLI eine Gruppen-Sammelbereitstellung in AWS IoTGreengrass erstellen und überwachen können. Das Beispiel für die Sammelbereitstellung in diesemTutorial enthält mehrere Gruppen. Sie können das Beispiel verwenden, um in Ihrer Implementierung soviele Gruppen hinzufügen, wie Sie benötigen.

Das Tutorial enthält die folgenden allgemeinen Schritte:

1. Erstellen und Hochladen der Eingabedatei für die Sammelbereitstellung (p. 166)2. Erstellen und Konfigurieren einer IAM-Ausführungsrolle (p. 168)3. Ihrer Ausführungsrolle den Zugriff auf Ihren S3-Bucket ermöglichen (p. 170)4. Bereitstellen der Gruppen (p. 171)5. Testen der Bereitstellung (p. 172)

VoraussetzungenZum Durchführen dieses Tutorials benötigen Sie Folgendes:

• Eine oder mehrere bereitstellbare Greengrass-Gruppen. Weitere Informationen zum Erstellen von AWSIoT Greengrass-Gruppen und -Kernen finden Sie unter Erste Schritte mit AWS IoT Greengrass (p. 69).

• Das AWS CLI ist auf Ihrem Computer installiert und konfiguriert. Weitere Informationen finden Sie im AWS CLI-Benutzerhandbuch.

• Ein S3-Bucket, der in der gleichen Region wie AWS IoT Greengrass erstellt wurde. WeitereInformationen finden Sie unter Erstellen und Konfigurieren eines S3-Buckets.

Note

Derzeit werden SSE KMS-aktivierte Buckets nicht unterstützt.

Schritt 1: Erstellen und Hochladen der Eingabedateifür die Sammelbereitstellung

In diesem Schritt erstellen Sie eine Eingabedatei für die Bereitstellung und laden sie in Ihren Amazon S3-Bucket hoch. Diese Datei ist eine serialisierte, zeilengetrennte JSON-Datei, die Informationen über jedeGruppe in Ihrer Sammelbereitstellung enthält. AWS IoT Greengrass verwendet diese Informationen, umjede Gruppe in Ihrem Namen bereitzustellen, wenn Sie Ihre Sammelbereitstellung initialisieren.

1. Führen Sie den folgenden Befehl aus, um die groupId für jede Gruppe zu erhalten, die Siebereitstellen möchten. Sie geben die groupId in Ihrer Eingabedatei für die Sammelbereitstellung ein,damit AWS IoT Greengrass jede bereitzustellende Gruppe identifizieren kann.

166

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-configure-bucket.html

AWS IoT Greengrass EntwicklerhandbuchErstellen und Hochladen der Eingabedatei

für die Sammelbereitstellung

Note



Die Antwort enthält Informationen über jede einzelne Gruppe in Ihrem AWS IoT Greengrass-Konto:

{ "Groups": [ { "Name": "string", "Id": "string", "Arn": "string", "LastUpdatedTimestamp": "string", "CreationTimestamp": "string", "LatestVersion": "string", "LatestVersionArn": "string" } ], "NextToken": "string"}

Führen Sie den folgenden Befehl aus, um die groupVersionId jeder Gruppe zu erhalten, die Siebereitstellen möchten.

list-group-versions --group-id groupId

Die Antwort enthält Informationen über alle Versionen in der Gruppe. Notieren Sie sich die ID derGruppenversion, die Sie verwenden möchten.

{ "Versions": [ { "Arn": "string", "Id": "string", "Version": "string", "CreationTimestamp": "string" } ], "NextToken": "string"}

2. Erstellen Sie in Ihrem Computerterminal oder Editor Ihrer Wahl eine Datei,MyBulkDeploymentInputFile, aus dem folgenden Beispiel. Diese Datei enthält Informationenüber jede AWS IoT Greengrass-Gruppe, die in eine Sammelbereitstellung einbezogen werden soll.Obwohl in diesem Beispiel mehrere Gruppen definiert sind, kann Ihre Datei für dieses Tutorial nur eineenthalten.

167

AWS IoT Greengrass EntwicklerhandbuchErstellen und Konfigurieren einer IAM-Ausführungsrolle

Note

Die Größe dieser Datei muss kleiner als 100 MB sein.

{"GroupId":"groupId1", "GroupVersionId":"groupVersionId1", "DeploymentType":"NewDeployment"}{"GroupId":"groupId2", "GroupVersionId":"groupVersionId2", "DeploymentType":"NewDeployment"}{"GroupId":"groupId3", "GroupVersionId":"groupVersionId3", "DeploymentType":"NewDeployment"}...

Jeder Datensatz (oder Zeile) enthält ein Gruppenobjekt. Jedes Gruppenobjekt enthält seineentsprechende groupId und groupVersionId und einen DeploymentType. Derzeit unterstütztAWS IoT Greengrass nur NewDeployment Sammelbereitstellungstypen.

Speichern und schließen Sie Ihre Datei. Notieren Sie sich den Speicherort der Datei.3. Verwenden Sie den folgenden Befehl in Ihrem Terminal, um Ihre Eingabedatei in Ihren Amazon S3-

Bucket hochzuladen. Ersetzen Sie den Dateipfad durch den Speicherort und den Namen Ihrer Datei.Weitere Informationen finden Sie unter Hinzufügen eines Objekts zu einem Bucket.

aws s3 cp path/MyBulkDeploymentInputFile s3://my-bucket/

Schritt 2: Erstellen und Konfigurieren einer IAM-Ausführungsrolle

In diesem Schritt verwenden Sie die IAM-Konsole, um eine eigenständige Ausführungsrolle zu erstellen.Anschließend stellen Sie eine Vertrauensbeziehung zwischen der Rolle und AWS IoT Greengrass her undstellen sicher, dass Ihr IAM-Benutzer über PassRole-Privilegien für Ihre Ausführungsrolle verfügt. Diesermöglicht es AWS IoT Greengrass, Ihre Ausführungsrolle zu übernehmen und die Bereitstellungen inIhrem Namen zu erstellen.

1. Verwenden Sie die folgende Richtlinie, um eine Ausführungsrolle zu erstellen. DiesesRichtliniendokument ermöglicht es AWS IoT Greengrass, auf Ihre Eingabedatei für dieSammelbereitstellung zuzugreifen, wenn es jede Bereitstellung in Ihrem Namen erstellt.

Weitere Informationen zum Erstellen einer IAM-Rolle und zum Delegieren von Berechtigungen findenSie unter Erstellen von IAM-Rollen.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": "greengrass:CreateDeployment", "Resource": [ "arn:aws:greengrass:region:accountId:/greengrass/groups/groupId1", "arn:aws:greengrass:region:accountId:/greengrass/groups/groupId2", "arn:aws:greengrass:region:accountId:/greengrass/groups/groupId3", ... ] }

168

https://docs.aws.amazon.com/AmazonS3/latest/gsg/PuttingAnObjectInABucket.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html

AWS IoT Greengrass EntwicklerhandbuchErstellen und Konfigurieren einer IAM-Ausführungsrolle

]}

Note

Diese Richtlinie muss für jede Gruppe oder Gruppenversion in Ihrer Eingabedateieine Ressource für die Sammelbereitstellung enthalten, die von AWS IoT Greengrassbereitzustellen ist. Um den Zugriff auf alle Gruppen zu ermöglichen, geben Sie für dieRessource einen Sternchen an:

"Resource": ["*"]

2. Ändern Sie die Vertrauensbeziehung für Ihre Ausführungsrolle, um AWS IoT Greengrasseinzuschließen. Dadurch kann AWS IoT Greengrass Ihre Ausführungsrolle und die damit verbundenenBerechtigungen verwenden. Weitere Informationen finden Sie unter Bearbeiten der Vertrauensstellungfür eine vorhandene Rolle.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "greengrass.amazonaws.com" }, "Action": "sts:AssumeRole" } ]}

3. Geben Sie Ihrem IAM-Benutzer die IAM-Berechtigungen PassRole für Ihre Ausführungsrolle. DieserIAM-Benutzer ist derjenige, der für die Einleitung der Sammelbereitstellung verwendet wird. DiePassRole-Berechtigungen ermöglichen es Ihrem IAM-Benutzer, Ihre Ausführungsrolle an AWS IoTGreengrass zur Verwendung zu übergeben. Weitere Informationen finden Sie unter Gewähren vonBerechtigungen, mit denen ein Benutzer eine Rolle an einen AWS-Service übergeben kann.

Verwenden Sie das folgende Beispiel, um Ihr Vertrauensrichtliniendokument zu aktualisieren. ÄndernSie dieses Beispiel, falls erforderlich.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "Stmt1508193814000", "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::123456789012:user/executionRoleArn" ] } ]}

169

https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html

https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html

AWS IoT Greengrass EntwicklerhandbuchIhrer Ausführungsrolle den Zugriffauf Ihren S3-Bucket ermöglichen

Schritt 3: Ihrer Ausführungsrolle den Zugriff aufIhren S3-Bucket ermöglichen

Um Ihre Sammelbereitstellung zu starten, muss Ihre Ausführungsrolle in der Lage sein, Ihre Eingabedateifür die Sammelbereitstellung aus Ihrem Amazon S3-Bucket zu lesen. Fügen Sie die folgendeBeispielrichtlinie Ihrem Amazon Amazon S3-Bucket hinzu, damit seine GetObject-Berechtigungen für IhreAusführungsrolle zugänglich sind.

Weitere Informationen finden Sie unter Wie füge ich eine S3-Bucket-Richtlinie hinzu?

{ "Version": "2008-10-17", "Id": "examplePolicy", "Statement": [ { "Sid": "Stmt1535408982966", "Effect": "Allow", "Principal": { "AWS": [ "executionRoleArn" ] }, "Action": "s3:GetObject", "Resource": "arn:aws:s3:::my-bucket/objectKey" } ]}

Sie können den folgenden Befehl in Ihrem Terminal verwenden, um die Richtlinien Ihres Buckets zuüberprüfen:

aws s3api get-bucket-policy --bucket my-bucket

Note

Sie können Ihre Ausführungsrolle direkt ändern, um ihr stattdessen die GetObject-Berechtigungen Ihres Amazon S3-Buckets zu gewähren. Fügen Sie dazu Ihrer Ausführungsrolledie folgende Beispielrichtlinie an.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::my-bucket/objectKey" } ]}

170

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-bucket-policy.html

AWS IoT Greengrass EntwicklerhandbuchBereitstellen der Gruppen

Schritt 4: Bereitstellen der GruppenIn diesem Schritt starten Sie eine Sammelbereitstellung für alle Gruppenversionen, die in IhrerEingabedatei für die Sammelbereitstellung konfiguriert sind. Die Bereitstellungsaktion für jede IhrerGruppenversionen ist vom Typ NewDeploymentType.

Note

Sie können StartBulkDeployment nicht aufrufen, während eine andere Sammelbereitstellung ausdemselben Konto noch läuft. Die Anforderung wurde abgelehnt.

1. Verwenden Sie den folgenden Befehl, um die Sammelbereitstellung zu starten.

Wir empfehlen, dass Sie ein X-Amzn-Client-Token-Token in jeder StartBulkDeploymentAnforderung einschließen. Diese Anforderungen sind in Bezug auf das Token und dieAnfrageparameter idempotent. Dieses Token kann eine beliebige eindeutige Zeichenfolge, bei der dieGroß- und Kleinschreibung zu beachten ist, mit bis zu 64 ASCII-Zeichen sein.

aws greengrass start-bulk-deployment --cli-input-json "{ "InputFileUri":"URI of file in S3 bucket", "ExecutionRoleArn":"ARN of execution role", "AmznClientToken":"your Amazon client token" }"

Der Befehl sollte zu einem erfolgreichen Statuscode 200 führen, zusammen mit der folgenden Antwort:

{ "bulkDeploymentId": UUID}

Notieren Sie sich die ID der Sammelbereitstellung. Sie kann verwendet werden, um den Status IhrerSammelbereitstellung zu überprüfen.

2. Verwenden Sie den folgenden Befehl, um den Status Ihrer Sammelbereitstellung zu überprüfen:

aws greengrass get-bulk-deployment-status --bulk-deployment-id 1234567

Der Befehl sollte einen erfolgreichen Statuscode 200 zurückgeben, zusätzlich zu einer JSON-Nutzlastaus Informationen:

{ "BulkDeploymentStatus": Running, "Statistics": { "RecordsProcessed": integer, "InvalidInputRecords": integer, "RetryAttempts": integer }, "CreatedAt": "string", "ErrorMessage": "string", "ErrorDetails": [ { "DetailedErrorCode": "string", "DetailedErrorMessage": "string" } ]

171

AWS IoT Greengrass EntwicklerhandbuchTesten der Bereitstellung

}

BulkDeploymentStatus enthält den aktuellen Status der Sammelausführung. Die Ausführung kanneinen von sechs verschiedenen Statusarten haben:

• Initializing Die Anforderung der Sammelbereitstellung ist eingegangen, und die Ausführungbereitet sich auf den Start vor.

• Running Die Sammelbereitstellung wurde gestartet.• Completed Die Ausführung der Sammelbereitstellung hat die Verarbeitung aller Datensätze

abgeschlossen.• Stopping Die Ausführung der Sammelbereitstellung hat den Befehl zum Stoppen erhalten und wird

in Kürze beendet. Sie können keine neue Sammelbereitstellung starten, solange sich eine frühereBereitstellung noch nicht im Status Stopping befindet.

• Stopped Die Ausführung der Sammelbereitstellung wurde manuell gestoppt.• Failed Die Sammelbereitstellung ist auf einen Fehler gestoßen und hat die Ausführung beendet.

Fehlerdetails finden Sie im Feld ErrorDetails.

Die JSON-Nutzlast enthält auch statistische Informationen über den Fortschritt derSammelbereitstellung. Anhand dieser Informationen können Sie feststellen, wie viele Gruppenverarbeitet wurden und wie viele fehlgeschlagen sind. Die statistischen Informationen umfassen:

• RecordsProcessed: Die Anzahl der Gruppensätze, die versucht wurden.• InvalidInputRecords: Die Gesamtzahl der Datensätze, die einen nicht wiederholbaren Fehler

(Non-Retryable Error) zurückgegeben haben. Dies kann beispielsweise der Fall sein, wenn einGruppendatensatz aus der Eingabedatei ein ungültiges Format aufweist oder eine nicht vorhandeneGruppenversion angibt, oder wenn die Ausführung keine Berechtigung zum Bereitstellen einerGruppen- oder Gruppenversion erteilt.

• RetryAttempts: Die Anzahl der Bereitstellungsversuche, die einen wiederholbaren Fehler(Retryable Error) zurückgegeben haben. Beispielsweise wird ein Wiederholungsversuch ausgelöst,wenn der Versuch, eine Gruppe bereitzustellen, einen Ablehnungsfehler (Throttling Error) zurückgibt.Eine Gruppenbereitstellung kann bis zu fünfmal wiederholt werden.

Im Falle eines Ausführungsfehlers bei der Sammelbereitstellung beinhaltet diese Nutzlast auch einenAbschnitt ErrorDetails, der zur Fehlerbehebung verwendet werden kann. Hierin sind Informationenüber die Ursache des Ausführungsfehlers enthalten.

Sie können den Status der Sammelbereitstellung regelmäßig überprüfen, um sicherzustellen, dass siewie erwartet verläuft. Nachdem die Bereitstellung abgeschlossen ist, sollte RecordsProcessed gleichder Anzahl der Bereitstellungsgruppen in Ihrer Eingabedatei für die Sammelbereitstellung sein. Dieszeigt an, dass jeder Datensatz bearbeitet wurde.

Schritt 5: Testen der BereitstellungSuchen Sie bei Bedarf die ID Ihrer Sammelbereitstellung, indem Sie den Befehl ListBulkDeploymentsverwenden.

aws greengrass list-bulk-deployments

Dieser Befehl gibt eine Liste aller Ihrer Sammelbereitstellung von der neuesten bis zur ältesten zurück,einschließlich Ihrer BulkDeploymentId.

172

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei Sammelbereitstellungen

{ "BulkDeployments": [ { "BulkDeploymentId": 1234567, "BulkDeploymentArn": "string", "CreatedAt": "string" } ], "NextToken": "string"}

Rufen Sie nun den Befehl ListBulkDeploymentDetailedReports auf, um detaillierte Informationen zu jederBereitstellung zu sammeln.

aws greengrass list-bulk-deployment-detailed-reports --bulk-deployment-id 1234567

Der Befehl sollte einen erfolgreichen Statuscode 200 zurückgeben, zusammen mit einer JSON-Nutzlastaus Informationen:

{ "BulkDeploymentResults": [ { "DeploymentId": "string", "GroupVersionedArn": "string", "CreatedAt": "string", "DeploymentStatus": "string", "ErrorMessage": "string", "ErrorDetails": [ { "DetailedErrorCode": "string", "DetailedErrorMessage": "string" } ] } ], "NextToken": "string"}

Diese Nutzlast enthält in der Regel eine paginierte Liste jeder Bereitstellung mit ihrem Bereitstellungsstatus,von der neuesten bis zur ältesten. Es enthält auch weitere Informationen für den Fall einesAusführungsfehlers bei der Sammelbereitstellung. Auch hier sollte die Gesamtzahl der aufgelistetenBereitstellungen der Anzahl der Gruppen entsprechen, die Sie in Ihrer Eingabedatei für dieSammelbereitstellung angegeben haben.

Die zurückgegebenen Informationen können sich ändern, bis sich die Bereitstellungen in einemTerminalzustand befinden (Erfolg oder Misserfolg). Sie können diesen Befehl bis dahin periodisch aufrufen.

Fehlerbehebung bei SammelbereitstellungenWenn die Sammelbereitstellung nicht erfolgreich ist, können Sie folgende Schritte ausführen, um denFehler zu beheben. Führen Sie die Befehle in Ihrem Terminal aus.

173

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei Fehlern in der Eingabedatei

Fehlerbehebung bei Fehlern in der EingabedateiDie Sammelbereitstellung kann bei Syntaxfehlern in der Eingabedatei für die Sammelbereitstellungfehlschlagen. Dies gibt einen Sammelbereitstellungsstatus Failed mit einer Fehlermeldung zurück, die dieZeilennummer des ersten Validierungsfehlers anzeigt. Es gibt vier mögliche Fehlermeldungen:

•InvalidInputFile: Missing GroupId at line number: line number

Dieser Fehler zeigt an, dass die angegebene Zeile der Eingabedatei den angegebenen Parameter nichtregistrieren kann. Die möglichen fehlenden Parameter sind die GroupId und die GroupVersionId.

•InvalidInputFile: Invalid deployment type at line number : line number. Only valid type is 'NewDeployment'.

Dieser Fehler zeigt an, dass in der Zeile der angegebenen Eingabedatei ein ungültiger Bereitstellungstypangeführt ist. Derzeit wird nur der Bereitstellungstyp NewDeployment unterstützt.

•Line %s is too long in S3 File. Valid line is less than 256 chars.

Dieser Fehler zeigt an, dass die angegebene Zeile der Eingabedatei zu lang ist und gekürzt werdenmuss.

•Failed to parse input file at line number: line number

Dieser Fehler zeigt an, dass die angegebene Zeile der Eingabedatei als nicht gültig für JSON angesehenwird.

Auf gleichzeitige Sammelbereitstellungen prüfen.Sie können keine neue Sammelbereitstellung starten, während eine andere noch läuft bzw. sich nichtim terminalen Zustand befindet. Dies kann zum Fehler Concurrent Deployment Error führen. Siekönnen mit dem Befehl ListBulkDeployments überprüfen, ob derzeit eine Sammelbereitstellung ausgeführtwird. Dieser Befehl listet Ihre Sammelbereitstellungen von der neuesten bis zur ältesten auf.

{ "BulkDeployments": [ { "BulkDeploymentId": BulkDeploymentId, "BulkDeploymentArn": "string", "CreatedAt": "string" } ], "NextToken": "string"}

Verwenden Sie die BulkDeploymentId der ersten aufgelisteten Sammelbereitstellung, um den BefehlGetBulkDeploymentStatus auszuführen. Wenn sich Ihre jüngste Sammelbereitstellung in einem laufendenZustand befindet (Initializing oder Running), verwenden Sie den folgenden Befehl, um dieSammelbereitstellung zu stoppen.

174

AWS IoT Greengrass EntwicklerhandbuchErrorDetails überprüfen

aws greengrass stop-bulk-deployment --bulk-deployment-id BulkDeploymentId

Diese Aktion führt zum Status Stopping, bis die Bereitstellung auf Stopped gesetzt ist. Nachdem dieBereitstellung den Status Stopped erreicht hat, können Sie eine neue Sammelbereitstellung starten.

ErrorDetails überprüfenFühren Sie den Befehl GetBulkDeploymentStatus aus, um eine JSON-Nutzlast zurückzugeben, diedetaillierte Informationen über einen Fehler bei der Ausführung der Sammelbereitstellung enthält.

"Message": "string", "ErrorDetails": [ { "DetailedErrorCode": "string", "DetailedErrorMessage": "string" } ]

Bei Beendigung mit einem Fehler, enthalten die ErrorDetails der JSON-Nutzlast, die von diesem Aufrufzurückgegeben wird, weitere Informationen über den Fehler bei der Ausführung der Sammelbereitstellung.Ein Fehlerstatuscode in der Serie 400 zeigt beispielsweise einen Eingabefehler an, entweder in denEingabeparametern oder in den Abhängigkeiten des Anrufers.

Das AWS IoT Greengrass Core-Protokoll überprüfenSie können Probleme mithilfe der AWS IoT Greengrass Core-Protokolle beheben. Verwenden Sie diefolgenden Befehle, um das runtime.log anzuzeigen:

cd /greengrass/ggc/var/logsudo cat system/runtime.log | more

Weitere Informationen zur AWS IoT Greengrass-Protokollierung finden Sie unter Überwachung mit AWSIoT Greengrass-Protokollen (p. 444).

Weitere RessourcenWeitere Informationen finden Sie in den folgenden Ressourcen:

• AWS IoT Greengrass-CLI-Referenz• AWS IoT Greengrass-API-Referenz

175

https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html

https://docs.aws.amazon.com/greengrass/latest/apireference/api-doc.html


Lambda-Funktionen auf dem AWSIoT Greengrass-Core ausführen

AWS IoT Greengrass bietet eine Lambda-Laufzeitumgebung in Containern für benutzerdefinierten Code.Lambda-Funktionen, die für einen AWS IoT Greengrass-Core bereitgestellt werden, werden in der lokalenLambda- Laufzeitumgebung des Cores ausgeführt. Lokale Lambda-Funktionen können durch lokaleEreignisse, Nachrichten von der Cloud oder andere Quellen ausgelöst werden. Dadurch wird die lokaleDatenverarbeitungsfunktionalität mit angeschlossenen Geräten verbunden. Beispielsweise können SieGreengrass Lambda-Funktionen zum Filtern von Gerätedaten verwenden, bevor diese in die Cloudübertragen werden.

Wenn Sie eine Lambda-Funktion für einen Core bereitstellen möchten, fügen Sie die Funktion einerGreengrass-Gruppe hinzu (indem Sie auf die vorhandene Lambda-Funktion verweisen), konfigurierenSie gruppenspezifische Einstellungen für die Funktion und stellen Sie anschließend die Gruppe bereit.Wenn die Funktion auf AWS-Services zugreift, müssen Sie auch der Gruppenrolle alle erforderlichenBerechtigungen hinzufügen.

Sie können Parameter konfigurieren, die bestimmen, wie die Lambda-Funktionen ausgeführt werden,einschließlich Berechtigungen, Isolierung, Arbeitsspeicherlimits und vieles mehr. Weitere Informationenfinden Sie unter the section called “Steuern der Greengrass Lambda-Funktionsausführung” (p. 179).

Note

Diese Einstellungen können Ihnen auch die Ausführung von AWS IoT Greengrass in einemDocker-Container ermöglichen. Weitere Informationen finden Sie unter the section called“Ausführen von AWS IoT Greengrass in einem Docker-Container” (p. 192).

In der folgenden Tabelle sind die unterstützten AWS Lambda-Laufzeiten und die Versionen der AWS IoTGreengrass Core-Software aufgelistet, die sie ausführen können.

Programmiersprache oder Plattform GGC-Version

Python 2.7 1.0 oder höher

Python 3.7 1.9

Java 8 1.1 oder höher

Node.js 6.10 1.1 oder höher

Node.js 8.10 1.9

C, C++ 1.6 or later

SDKs für Greengrass Lambda-FunktionenAWS bietet drei SDKs, die von Greengrass Lambda-Funktionen, die auf einem AWS IoT Greengrass-Coreausgeführt werden, genutzt werden können. Da diese SDKs in verschiedenen Paketen enthalten sind,können sie von Funktionen gleichzeitig genutzt werden. Um ein SDK in einer Greengrass Lambda-Funktionzu verwenden, müssen Sie es in das Bereitstellungspaket einfügen.

176



Ermöglicht lokalen Lambda Funktionen die Interaktion mit dem Core, um folgende Aufgabenauszuführen:• Austauschen von MQTT-Nachrichten mit AWS IoT.• Austauschen von MQTT-Nachrichten mit Konnektoren, Geräten und anderen Lambda-Funktionen in

der Greengrass-Gruppe.• Interagieren mit dem lokalen Shadow-Service.• Aufrufen von anderen lokalen Lambda-Funktionen.• Zugreifen auf geheime Ressourcen (p. 274).

AWS IoT Greengrass stellt das AWS IoT GreengrassCore-SDK in den folgenden Sprachen undPlattformen auf GitHub bereit.• AWS IoT GreengrassCore-SDK für Java• AWS IoT GreengrassCore-SDK für Node.js• AWS IoT Greengrass-Core-SDK für Python• AWS IoT Greengrass Core-SDK für C

Wenn Sie Python-Lambda-Funktionen ausführen, können Sie auch pip verwenden, um das AWS IoTGreengrass-Core-SDK für Python auf dem Core-Gerät zu installieren. Anschließend können Sie IhreFunktionen bereitstellen, ohne das SDK im Lambda-Funktionsbereitstellungspaket einschließen zumüssen. Weitere Informationen finden Sie unter greengrasssdk.

Note

Um pip zum Installieren des Python SDK zu verwenden, führen Sie in Ihrem Core-Geräte-Terminal den folgenden Befehl aus.



Ermöglicht lokalen Lambda-Funktionen, Machine Learning-Modelle zu nutzen, die für den GreengrassCore als maschinelles Lernmodell bereitgestellt werden. Lambda-Funktionen können das SDK zumAufrufen von und Interagieren mit einem lokalen Inferenz-Service verwenden, der dem Core alsKonnektor bereitgestellt wird. Weitere Informationen, darunter auch ein Code-Beispiel, in dem das SDKeingesetzt wird, finden Sie unter the section called “Bildklassifikation” (p. 313)-Konnektor.

In der folgenden Tabelle werden unterstützte Sprachen oder Plattformen und die Versionen der AWSIoT Greengrass Core-Software aufgeführt, die darauf ausgeführt werden können.

Programmiersprache oder Plattform GGC-Version

Python 2.7 1.7 or later

Informationen zum Download finden Sie unter the section called “AWS IoT Greengrass ML SDKSoftware” (p. 22).

AWS-SDKs

Aktiviert lokale Lambda-Funktionen für direkte Aufrufe an AWS-Services, wie etwa Amazon S3,DynamoDB, AWS IoT und AWS IoT Greengrass. Um ein AWS SDK in einer Greengrass Lambda-Funktion nutzen zu können, müssen Sie es in Ihr Bereitstellungspaket einschließen. Wenn Sie dasAWS SDK im selben Paket wie das AWS IoT Greengrass Core SDK verwenden, stellen Sie sicher,

177

https://github.com/aws/aws-greengrass-core-sdk-java/

https://github.com/aws/aws-greengrass-core-sdk-js/

https://github.com/aws/aws-greengrass-core-sdk-python/

https://github.com/aws/aws-greengrass-core-sdk-c/



AWS IoT Greengrass EntwicklerhandbuchMigrieren von cloudbasierten Lambda-Funktionen

dass Ihre Lambda-Funktionen die richtigen Namespaces verwenden. Greengrass Lambda-Funktionenkönnen nicht mit Cloudservices kommunizieren, wenn der Core offline ist.

Laden Sie die entsprechenden AWS SDKs aus dem Ressourcencenter für erste Schritte herunter.

Weitere Informationen zum Erstellen eines Bereitstellungspakets finden Sie unter the section called“Erstellen und Verpacken einer Lambda-Funktion” (p. 90) im Tutorial „Erste Schritte“ oder unter Erstelleneines Bereitstellungspakets im AWS Lambda Developer Guide.

Migrieren von cloudbasierten Lambda-FunktionenDas AWS IoT Greengrass Core SDK folgt dem AWS SDK-Programmiermodell, das die Portierung derLambda-Funktionen, die für die Cloud entwickelt wurden, in Lambda-Funktionen, die auf einem AWS IoTGreengrass-Core ausgeführt werden, vereinfacht.

Beispiel: Die folgende Python Lambda-Funktion nutzt das AWS SDK for Python, um eine Nachricht imThema some/topic in der Cloud zu veröffentlichen:

import boto3 client = boto3.client('iot-data')response = client.publish( topic = 'some/topic', qos = 0, payload = 'Some payload'.encode())

Um die Funktion für eine AWS IoT Greengrass-Core zu portieren, ändern Sie in der import-Anweisungund der client-Initialisierung den boto3-Modulnamen zu greengrasssdk, wie im folgenden Beispiel:

import greengrasssdk client = greengrasssdk.client('iot-data')response = client.publish( topic = 'some/topic', qos = 0, payload = 'Some payload'.encode())

Note

Das AWS IoT Greengrass Core SDK unterstützt nur das Senden von MQTT-Nachrichten mit QoS= 0.

Die Ähnlichkeit zwischen Programmiermodellen ermöglicht es Ihnen, Ihre Lambda-Funktionen in derCloud zu entwickeln und dann mit geringem Aufwand auf AWS IoT Greengrass zu migrieren. AusführbareLambda-Dateien (p. 190) können in der Cloud nicht ausgeführt werden. Daher können Sie das AWS SDKnicht verwenden, um sie vor der Bereitstellung in der Cloud zu entwickeln.

Lambda-Funktionen nach Alias oder Versionreferenzieren

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nach Versionreferenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, da die Abonnementtabelle

178

https://aws.amazon.com/getting-started/tools-sdks/

https://docs.aws.amazon.com/lambda/latest/dg/deployment-package-v2.html

https://docs.aws.amazon.com/lambda/latest/dg/deployment-package-v2.html

AWS IoT Greengrass EntwicklerhandbuchSteuern der Greengrass Lambda-Funktionsausführung

oder Gruppendefinition bei der Aktualisierung des Funktionscodes nicht geändert werden müssen.Stattdessen lassen Sie den Alias einfach auf die neue Funktionsversion verweisen.-Aliasse werdenwährend der Gruppenbereitstellung zu Versionsnummern aufgelöst. Bei Verwendung eines Alias wird dieaufgelöste Version auf die Version aktualisiert, auf die das Alias zum Zeitpunkt der Bereitstellung weist.

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen. $LATEST-Versionen sindnicht an unveränderliche, veröffentlichte Funktionsversionen gebunden und können jederzeit geändertwerden. Dies ist gegensätzlich zum AWS IoT Greengrass-Prinzip der Unveränderlichkeit von Versionen.

Eine gängige Praxis bei der regelmäßigen Aktualisierung Ihrer Greengrass Lambda-Funktionen mitCodeänderungen ist die Verwendung eines Alias mit dem Namen PRODUCTION in Ihrer Greengrass-Gruppe und Ihren Abonnements. Wenn Sie neue Versionen Ihrer Lambda-Funktion in die Produktionübergeben, weisen Sie den Alias auf die neueste stabile Version und stellen Sie die Gruppe erneut bereit.Sie können diese Methode auch für ein Rollback auf eine frühere Version verwenden.

Steuern der Ausführung von Greengrass Lambda-Funktionen mithilfe einer gruppenspezifischenKonfiguration

AWS IoT Greengrass bietet eine cloudbasierte Verwaltung von Greengrass Lambda-Funktionen. Siekönnen Details bezüglich des Verhaltens der Lambda-Funktion beim Ausführen in einer bestimmtenGruppe konfigurieren. Code und Abhängigkeiten einer Funktion werden zwar mit AWS Lambda verwaltet,AWS IoT Greengrass unterstützt aber die folgenden gruppenspezifischen Konfigurationseinstellungen:

Run as (Ausführen als)

Die Zugriffsidentität, die zum Ausführen jeder Lambda-Funktion verwendet wird. Standardmäßigwerden Lambda-Funktionen als Standardzugriffsidentität (p. 185) der Gruppe ausgeführt. In derRegel ist dies das standardmäßige AWS IoT Greengrass-Systemkonto (ggc_user und ggc_group).Sie können die Einstellung ändern und die Benutzer- und Gruppen-IDs auswählen, die über die fürdie Ausführung der Lambda-Funktion erforderlichen Berechtigungen verfügen. Sie können sowohldie UID als auch die GID oder durch Leerlassen eines der Felder nur eine davon überschreiben.Diese Einstellung bietet Ihnen eine genauere Kontrolle über den Zugriff auf Geräte-Ressourcen. Wirempfehlen Ihnen, Ihre Greengrass-Hardware mit geeigneten Ressourcen-Limits, Dateiberechtigungenund Datenträgerkontingenten für die Benutzer und Gruppen zu konfigurieren, deren Berechtigungenzum Ausführen von Lambda-Funktionen verwendet werden.


Important

Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolutnotwendig ist. Wenn Sie eine Lambda-Funktion als Root ausführen, erhöhen Sie das Risikounbeabsichtigter Änderungen, wie z. B. das versehentliche Löschen wichtiger Dateien.Darüber hinaus erhöhen sich bei Ausführung als Root die Risiken für Ihre Daten und Ihr Gerätdurch böswillige Personen. Wenn Sie eine Ausführung als Root wünschen, müssen Sie dieAWS IoT Greengrass-Konfiguration entsprechend aktualisieren. Weitere Informationen findenSie unter the section called “Ausführen einer Lambda-Funktion als Root” (p. 181).

UID (number) (UID (Nummer))

Die Benutzer-ID des Benutzers, der über die erforderlichen Berechtigungen zum Ausführen derLambda-Funktion verfügt. Diese Einstellung ist nur verfügbar, wenn Sie Run as another user

179

AWS IoT Greengrass EntwicklerhandbuchSteuern der Greengrass Lambda-Funktionsausführung

ID/group ID (Als eine andere Benutzer-ID/Gruppen-ID ausführen) auswählen. Sie können dieBenutzer-ID, die Sie zum Ausführen der Lambda-Funktion verwenden möchten, mit dem Befehlgetent passwd auf Ihrem AWS IoT Greengrass-Gerät suchen.

GID (Nummer) (GID (number))

Die Gruppen-ID der Gruppe, die über die erforderlichen Berechtigungen zum Ausführen derLambda-Funktion verfügt. Diese Einstellung ist nur verfügbar, wenn Sie Run as another userID/group ID (Als eine andere Benutzer-ID/Gruppen-ID ausführen) auswählen. Sie können dieGruppen-ID, die Sie zum Ausführen der Lambda-Funktion verwenden möchten, mit dem Befehlgetent group auf Ihrem AWS IoT Greengrass-Gerät suchen.

Containerization (Containerisierung)

Legen Sie fest, ob die Lambda-Funktion mit der Standard-Containerisierung für die Gruppe ausgeführtwerden soll, oder geben Sie die Containerisierung an, die immer für diese Lambda-Funktion verwendetwerden soll. Wenn Namespace und cgroup Ihres Geräte-Kernels bei der Ausführung nicht aktiviertwerden sollen, müssen Ihre Lambda-Funktionen ohne Containerisierung ausgeführt werden. Siekönnen dies leicht erreichen, indem Sie für die Gruppe die Standardeinstellung der Containerisierungfestlegen. Siehe the section called “Festlegen der Standard-Containerisierung für Lambda-Funktionenin einer Gruppe” (p. 186).


Note

Wir empfehlen, dass Sie Lambda-Funktionen in einem Greengrass-Container ausführen,es sei denn, Ihr Anwendungsfall verlangt, dass sie ohne Greengrass-Containerisierungausgeführt werden. Bei der Ausführung in einem Greengrass-Container können Sieverknüpfte Ressourcen verwenden und somit die Vorteile von Isolierung und erhöhterSicherheit nutzen. Bevor Sie die Containerisierung ändern, schlagen Sie unter thesection called “Überlegungen bei der Auswahl der Containerisierung von Lambda-Funktionen” (p. 182) nach.

Speicherlimit

Die Speicherzuweisung für die Funktion. Der Standardwert ist 16 MB.

Note

Diese Einstellung ist nicht verfügbar, wenn Sie eine Lambda-Funktion ohne Containerisierungausführen. Lambda-Funktionen, die ohne Containerisierung ausgeführt werden, besitzenkein Speicherlimit. Das maximale Arbeitsspeicherlimit wird verworfen, wenn Sie die Lambda-Funktion ohne Containerisierung ausführen.

Timeout

Die Dauer vor Beendigung der Funktion oder Anforderung. Standardmäßig ist ein Zeitraum von3 Sekunden festgelegt.

Lebenszyklus

Der Lebenszyklus einer Lambda-Funktion kann On-Demand oder langlebig sein. DieStandardeinstellung ist „On-Demand“.

Eine On-Demand-Lambda-Funktion startet bei Aufruf in einem neuen oder wiederverwendetenContainer. Anforderungen an die Funktion werden möglicherweise von allen verfügbaren Containernverarbeitet. Eine langlebige—oder angeheftete—Lambda-Funktion wird automatisch nach dem Startvon AWS IoT Greengrass gestartet und in ihrem eigenen Container (oder einer Sandbox) ausgeführt.Alle Anforderungen an die Funktion werden vom gleichen Container verarbeitet. Weitere Informationenfinden Sie unter the section called “Lebenszykluskonfiguration” (p. 189).

180

AWS IoT Greengrass EntwicklerhandbuchAusführen einer Lambda-Funktion als Root

Lesezugriff auf das /sys-Verzeichnis

Ob die Funktion auf den /sys-Ordner des Hosts zugreifen kann. Verwenden Sie diese Einstellung,wenn die Funktion Geräteinformationen aus /sys lesen muss. Der Standardwert lautet „false“.

Note

Diese Einstellung ist nicht verfügbar, wenn Sie eine Lambda-Funktion ohne Containerisierungausführen. Der Wert dieser Einstellung wird verworfen, wenn Sie die Lambda-Funktion soändern, dass sie ohne Containerisierung ausgeführt wird.

Eingeben des Nutzlast-Datentyps

Der erwartete Kodierungstyp der Eingabenutzlast für die Funktion: JSON oder Binär. Der Standardwertist JSON.

Unterstützung für den binären Kodierungstyp ist ab AWS IoT Greengrass Core-Software v1.5.0 undAWS IoT Greengrass Core SDK v1.1.0 verfügbar. Bei Funktionen die bei der Gerätedaten interagieren,kann es nützlich sein, binäre Eingabedaten zu akzeptieren, da es die eingeschränkten Hardware-Funktionen von Geräten oft schwierig oder gar unmöglich machen, einen JSON-Datentyp zu erstellen.

Note

Ausführbare Lambda-Dateien (p. 190) unterstützen nur den binären Kodierungstyp (nichtJSON).

Umgebungsvariablen

Schlüssel-Wert-Paare, die Einstellungen dynamisch an Funktionscode und -bibliothekenübergeben. Lokale Umgebungsvariablen funktionieren auf die gleiche Weise wie AWS Lambda-Funktionsumgebungsvariablen, sind aber in der Core-Umgebung verfügbar.

Resource access policies (Richtlinien für Ressourcenzugriff)

Eine Liste von bis zu 10 lokalen Ressourcen (p. 204), Secret-Ressourcen (p. 274) und MachineLearning-Ressourcen (p. 227), auf die die Lambda-Funktion zugreifen kann, und die zugehörigeread-only- oder read-write-Berechtigung. In der Konsole werden diese zugeordnetenRessourcen auf der Resources (Ressourcen)-Seite der Funktion aufgelistet.

Note

Ressourcen-Zugriffsrichtlinien gelten nur, wenn Lambda-Funktionen in einem Greengrass-Container ausgeführt werden. Wenn Sie Lambda-Funktionen ohne Containerisierungausführen, können Sie direkt auf lokale Ressourcen zugreifen. Auf Secret-Ressourcen kannbei Ausführung ohne Containerisierung zugegriffen werden.

Ausführen einer Lambda-Funktion als RootDiese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

Bevor Sie eine oder mehrere Lambda-Funktionen als Root ausführen können, müssen Sie zunächst dieAWS IoT Greengrass-Konfiguration so aktualisieren, dass diese unterstützt werden. Die Ausführung vonLambda-Funktionen als Root wird standardmäßig nicht unterstützt. Die Bereitstellung schlägt fehl, wennSie versuchen, eine Lambda-Funktion bereitzustellen und sie als Root auszuführen (UID und GID gleich 0),ohne die AWS IoT Greengrass-Konfiguration zuvor entsprechend aktualisiert zu haben. Im Laufzeitprotokoll(greengrass_root/ggc/var/log/system/runtime.log) wird ein Fehler ähnlich dem folgenden verzeichnet:

lambda(s)[list of function arns] are configured to run as root while Greengrass is not configured to run lambdas with root permissions

181

https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html


AWS IoT Greengrass EntwicklerhandbuchÜberlegungen bei der Auswahl der

Containerisierung von Lambda-Funktionen

Important

Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendigist. Wenn Sie eine Lambda-Funktion als Root ausführen, erhöhen Sie das Risiko unbeabsichtigterÄnderungen, wie z. B. das versehentliche Löschen wichtiger Dateien. Darüber hinaus erhöhensich bei Ausführung als Root die Risiken für Ihre Daten und Ihr Gerät durch böswillige Personen.

So ermöglichen Sie die Ausführung von Lambda-Funktionen als Root

1. Wechseln Sie auf Ihrem AWS IoT Greengrass-Gerät zum Ordner greengrass-root/config.Note

Standardmäßig ist greengrass-root das /greengrass-Verzeichnis.2. Aktualisieren Sie die Datei config.json, indem Sie "allowFunctionsToRunAsRoot" : "yes" zum

Feld runtime hinzufügen. Zum Beispiel:

{ "coreThing" : { ... }, "runtime" : { ... "allowFunctionsToRunAsRoot" : "yes" }, ...}

3. Starten Sie AWS IoT Greengrass mit den folgenden Befehlen neu:

cd /greengrass/ggc/coresudo ./greengrassd restart

Jetzt können Sie für die Benutzer-ID und die Gruppen-ID (UID/GID) der Lambda-Funktionen "0"festlegen, um diese Lambda-Funktion als Root auszuführen.

Sie können den Wert von "allowFunctionsToRunAsRoot" in "no" ändern und AWS IoT Greengrassneu starten, wenn Sie die Ausführung von Lambda-Funktionen als Root nicht zulassen möchten.

Überlegungen bei der Auswahl der Containerisierungvon Lambda-FunktionenDiese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

Standardmäßig werden Lambda-Funktionen in einem AWS IoT Greengrass-Container ausgeführt. DieserContainer schafft eine Isolierung zwischen Ihren Funktionen und dem Host und bietet zusätzliche Sicherheitsowohl für den Host als auch für die Funktionen im Container.

Wir empfehlen, dass Sie Lambda-Funktionen in einem Greengrass-Container ausführen, es sei denn,Ihr Anwendungsfall verlangt, dass sie ohne Greengrass-Containerisierung ausgeführt werden. Durch dieAusführung Ihrer Lambda-Funktionen in einem Greengrass-Container haben Sie mehr Kontrolle über dieEinschränkung des Zugriffs auf Ressourcen.

Es folgen einige Beispiel-Anwendungsfälle für die Ausführung ohne Containerisierung:

• Sie möchten AWS IoT Greengrass auf einem Gerät ausführen, das den Container-Modus nichtunterstützt (weil Sie beispielsweise eine spezielle Linux-Verteilung verwenden oder die Kernel-Version zualt ist).

182



• Sie möchten Ihre Lambda-Funktion in einer anderen Container-Umgebung mit eigenem OverlayFSausführen, bei der Ausführung in einem Greengrass-Container treten aber OverlayFS-Konflikte auf.

• Sie benötigen Zugriff auf lokale Ressourcen, deren Pfade zum Zeitpunkt der Bereitstellung nichtbestimmt werden oder sich nach der Bereitstellung ändern können, wie z. B. Plug-In-Geräte.

• Sie haben eine Legacy-Anwendung, die als Prozess geschrieben wurde, und es treten Probleme auf,wenn Sie sie als containerisierte Lambda-Funktion ausführen.

Containerisierungsunterschiede

Containerisierung Hinweise

AWS IoT Greengrass-Container • Alle AWS IoT Greengrass-Funktionen sindverfügbar, wenn Sie eine Lambda-Funktion ineinem Greengrass-Container ausführen.

• Lambda-Funktionen, die in einem Greengrass-Container ausgeführt werden, haben keinenZugriff auf den bereitgestellten Code andererLambda-Funktionen. Dies gilt auch dann, wennsie mit der gleichen Gruppen-ID ausgeführtwerden. Mit anderen Worten: Ihre Lambda-Funktionen werden stärkerer voneinander isoliertausführen.

• Da für alle Lambda-Funktionen, die in einemAWS IoT Greengrass-Container ausgeführtwerden, untergeordnete Prozesse im gleichenContainer wie die Lambda-Funktion vorhandensind, werden die untergeordnete Prozessebeendet, wenn die Lambda-Funktion beendetwird.

Kein Container • Es sind nicht alle AWS IoT Greengrass-Funktionen verfügbar, wenn Sie eine Lambda-Funktion ohne Containerisierung ausführen.Sie müssen direkt auf das Dateisystemzugreifen, anstatt verknüpfte lokale Geräte- undVolumenressourcen (p. 204) zu verwenden.Derzeit werden Machine Learning (ML)-Modellressourcen (p. 227) nicht ohneContainerisierung unterstützt.

• Die Lambda-Funktion hat schreibgeschütztenZugriff auf den bereitgestellten Code andererLambda-Funktionen, die mit der gleichenGruppen-ID ausgeführt werden.

• Lambda-Funktionen, die untergeordneteProzesse in einer anderen Prozesssitzunggenerieren oder einen überschriebenenSIGHUP-Handler (Signalauflegung) enthalten,wie dies z. B. für das Dienstprogramm nohup derFall ist, werden nicht automatisch von AWS IoTGreengrass beendet, wenn die übergeordneteLambda-Funktion beendet wird.

• Konnektoren (p. 297), lokale Geräteund Volume-Ressourcen, Lambda-Funktionsspeicher-Limits und ML-Modellressourcen werden nicht unterstützt, wenn

183



Containerisierung Hinweisedie Standard-Containerisierung der Lambda-Funktion auf No container (Kein Container)festgelegt ist. Diese Funktionen erfordern, dassAWS IoT Greengrass mit Containerisierungausgeführt wird.

Ändern der Containerisierung für eine Lambda-Funktion kann zu Problemen führen, wenn Sie siebereitstellen. Wenn Sie Ihrer Lambda-Funktion lokale Ressourcen zugewiesen hatten, die mit den neuenContainerisierungseinstellungen nicht mehr verfügbar sind, schlägt die Bereiststellung fehl.

• Wenn Sie für eine Lambda-Funktion die Ausführung in einem Greengrass-Container in die Ausführungohne Containierisierung ändern, werden die Speicherlimits für die Funktion verworfen. Sie müssendirekt auf das Dateisystem zugreifen, anstatt verknüpfte lokale Ressourcen zu verwenden. Vor derBereitstellung müssen Sie alle verknüpften Ressourcen entfernen.

• Wenn Sie für eine Lambda-Funktion die Ausführung ohne Containerisierung in die Ausführung in einemContainer ändern, verliert Ihre Lambda-Funktion den direkten Zugriff auf das Dateisystem. Sie müssenfür jede Funktion ein Speicherlimit definieren oder den Standard 16 MB übernehmen. Sie können dieseEinstellungen für jede Lambda-Funktion vor der Bereitstellung konfigurieren.

So ändern Sie die Containerisierungseinstellungen für eine Lambda-Funktion

1. Wählen Sie in der AWS IoT-Konsole die Option Greengrass und dann Groups (Gruppen) aus.2. Wählen Sie die Gruppe mit der Lambda-Funktion aus, deren Einstellungen Sie ändern möchten.3. Wählen Sie Lambdas.4. Wählen Sie auf der Lambda-Funktion, die Sie ändern möchten, die Auslassungspunkte (...) und

danach die Option Konfiguration bearbeiten aus.5. Ändern Sie die Containerisierungseinstellungen. Wenn Sie die Lambda-Funktion für die Ausführung

in einem Greengrass-Container konfigurieren, müssen Sie auch die Eigenschaften Speicherlimit undLesezugriff auf das /sys-Verzeichnis festlegen.

6. Wählen Sie Aktualisieren, um die Änderungen an Ihrer Lambda-Funktion zu speichern.

Die Änderungen werden wirksam, wenn die Gruppe bereitgestellt wird.

Sie können auch CreateFunctionDefinition und CreateFunctionDefinitionVersion in der AWS IoTGreengrass-API-Referenz verwenden. Wenn Sie die Containerisierungseinstellung ändern, müssen Sieauch die anderen Parameter aktualisieren. Wenn Sie beispielsweise von der Ausführung einer Lambda-Funktion in einem Greengrass-Container zur Ausführung ohne Containerisierung wechseln, müssen Sieden Wert des Parameters MemorySize löschen.

Bestimmen der von Ihrem Greengrass-Gerät unterstütztenIsolierungsmodiMithilfe des AWS IoT Greengrass-Abhängigkeitsprüfers können Sie bestimmen, welche Isolierungsmodi(Greengrass-Container/kein Container) von Ihrem Greengrass-Gerät unterstützt werden.

So führen Sie den AWS IoT Greengrass-Abhängigkeitsprüfer aus

1. Laden Sie den AWS IoT Greengrass-Abhängigkeitsprüfer vom GitHub-Repository herunter und führenSie ihn aus.

wget https://github.com/aws-samples/aws-greengrass-samples/raw/master/greengrass-dependency-checker-GGCv1.9.x.zip

184

https://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createfunctiondefinitionversion-post.html


AWS IoT Greengrass EntwicklerhandbuchFestlegen der Standardzugriffsidentitätfür Lambda-Funktionen in einer Gruppe

unzip greengrass-dependency-checker-GGCv1.9.x.zipcd greengrass-dependency-checker-GGCv1.9.xsudo modprobe configssudo ./check_ggc_dependencies | more

2. Wenn more erscheint, drücken Sie die Spacebar-Taste, um eine weitere Textseite anzuzeigen.

Weitere Information zum Befehl modprobe erhalten Sie, wenn Sie man modprobe im Terminal ausführen.

Festlegen der Standardzugriffsidentität für Lambda-Funktionen in einer GruppeDiese Funktion ist für AWS IoT Greengrass Core v1.8 und höher verfügbar.

Um den Zugriff auf Geräte-Ressourcen besser kontrollieren zu können, können Sie dieStandardzugriffsidentität zum Ausführen von Lambda-Funktionen in der Gruppe konfigurieren. DieseEinstellung bestimmt die Standardberechtigungen, die Ihren Lambda-Funktionen gewährt werden, wennsie auf dem Core-Gerät ausgeführt werden. Um die Einstellung für einzelne Funktionen in der Gruppezu überschreiben, können Sie die Run as (Ausführen als)-Eigenschaft der Gruppe verwenden. WeitereInformationen hierzu finden Sie unter Run as (Ausführen als) (p. 179).

Diese Einstellung auf Gruppenebene wird auch zur Ausführung der zugrunde liegenden AWS IoTGreengrass Core-Software verwendet. Es enthält System-Lambda-Funktionen zum Verwalten vonOperationen wie z. B. dem Nachrichtenrouting, der Synchronisierung des lokalen Schattens und derautomatischen IP-Erkennung.

Die Standardzugriffsidentität kann so konfiguriert werden, dass sie als Konten des AWS IoT Greengrass-Standardsystems (ggc_user und ggc_group) ausgeführt wird oder die Berechtigungen eines anderenBenutzers oder einer anderen Gruppe verwendet. Wir empfehlen Ihnen, Ihre Greengrass-Hardware mitgeeigneten Ressourcen-Limits, Dateiberechtigungen und Datenträgerkontingenten für beliebige Benutzerund Gruppen zu konfigurieren, deren Berechtigungen zum Ausführen von benutzerdefinierten oder System-Lambda-Funktionen verwendet werden.

So ändern Sie die Standardzugriffsidentität für Ihre AWS IoT Greengrass-Gruppe

1. Wählen Sie in der AWS IoT-Konsole die Option Greengrass und dann Groups (Gruppen) aus.2. Wählen Sie die Gruppe aus, deren Einstellungen Sie ändern möchten.3. Wählen Sie Settings aus.4. Wählen Sie unter Lambda Runtime Environment (-Laufzeitumgebung) für die Default Lambda function

user ID/group ID (Standard-Lambda-Funktion für die Benutzer-ID/Gruppen-ID) die Option Another userID/group ID (Eine weitere Benutzer-ID/Gruppen-ID) aus.

Wenn Sie diese Option wählen, werden die Felder UID (number) (UID (Zahl)) und GID (number) (GID(Zahl)) angezeigt.

5. Geben Sie eine Benutzer-ID, eine Gruppen-ID oder beides ein. Wenn Sie ein Feld leer lassen, wirddas entsprechende Greengrass-Systemkonto (ggc_user oder ggc_group) verwendet.

• Unter UID (number) (UID (Zahl)) geben Sie die Benutzer-ID für den Benutzer ein, der über dieBerechtigungen verfügt, die standardmäßig verwendet werden sollen, um Lambda-Funktionen in derGruppe auszuführen. Mit dem Befehl getent passwd auf Ihrem AWS IoT Greengrass-Gerät könnenSie die Benutzer-ID abrufen.

• Unter GID (number) (GID (Zahl)) geben Sie die Gruppen-ID für die Gruppe ein, die über dieBerechtigungen verfügt, die standardmäßig verwendet werden sollen, um Lambda-Funktionen in derGruppe auszuführen. Mit dem Befehl getent group auf Ihrem AWS IoT Greengrass-Gerät können Siedie Gruppen-ID abrufen.

185

AWS IoT Greengrass EntwicklerhandbuchFestlegen der Standard-Containerisierung

für Lambda-Funktionen in einer Gruppe

Important

Die Ausführung als Root-Benutzer erhöht die Risiken für Ihre Daten und Geräte. Nicht alsRoot-Benutzer (UID/GID = 0) ausführen, sofern es Ihr Business Case nicht erfordert. WeitereInformationen finden Sie unter the section called “Ausführen einer Lambda-Funktion alsRoot” (p. 181).


Festlegen der Standard-Containerisierung für Lambda-Funktionen in einer GruppeDiese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

Sie können die Gruppeneinstellungen ändern, um die Standard-Containerisierung für Lambda-Funktionenin der Gruppe anzugeben. Sie können diese Einstellung für eine oder mehrere Lambda-Funktionenin der Gruppe außer Kraft setzen, wenn Sie möchten, dass die Lambda-Funktionen anders als derGruppenstandard mit Containerisierung ausgeführt werden. Bevor Sie die Containerisierungseinstellungenändern, schlagen Sie unter the section called “Überlegungen bei der Auswahl der Containerisierung vonLambda-Funktionen” (p. 182) nach.

Important

Wenn Sie die Standard-Containerisierung für die Gruppe ändern möchten, eine oder mehrereFunktionen aber eine andere Containerisierung verwenden, ändern Sie zunächst die Einstellungenfür die Lambda-Funktionen, bevor Sie die Gruppeneinstellung ändern. Wenn Sie zuerst dieContainerisierungseinstellung der Gruppe ändern, werden die Werte für die EinstellungenSpeicherlimit und Lesezugriff auf das /sys-Verzeichnis verworfen.

So ändern Sie die Containerisierungseinstellungen für Ihre AWS IoT Greengrass-Gruppe

1. Wählen Sie in der AWS IoT-Konsole die Option Greengrass und dann Groups (Gruppen) aus.2. Wählen Sie die Gruppe aus, deren Einstellungen Sie ändern möchten.3. Wählen Sie Settings aus.4. Ändern Sie unter Lambda runtime environment (-Laufzeitumgebung) die Containerisierungseinstellung.


Kommunikationsströme für Greengrass Lambda-Funktionen

Greengrass Lambda-Funktionen unterstützen mehrere Methoden zur Kommunikation mit anderenMitgliedern der lokalen AWS IoT Greengrass-Gruppe, lokalen Services und Cloud-Services (einschließlichAWS-Services) interagieren.

Kommunikation über MQTT-NachrichtenLambda-Funktionen können MQTT-Nachrichten mithilfe eines Veröffentlichungs-/Abonnementmusters, dasüber Abonnements gesteuert wird, senden und empfangen.

186

AWS IoT Greengrass EntwicklerhandbuchAndere Kommunikationsströme

Dieser Kommunikationsfluss ermöglicht es Lambda-Funktionen, Nachrichten mit den folgenden Entitätenauszutauschen:

• Geräte in der Gruppe.• Konnektoren in der Gruppe.• Andere Lambda-Funktionen in der Gruppe.• AWS IoT• Lokaler Geräteschattenservice.

Ein Abonnement definiert eine Nachrichtenquelle, ein Meldeziel und ein Thema (oder Objekt), dasverwendet wird, um Nachrichten von der Quelle zum Ziel weiterzuleiten. Die an eine Lambda-Funktionveröffentlichten Nachrichten werden an den registrierten Handler der Funktion übergeben. Abonnementsbieten mehr Sicherheit und vorhersehbare Interaktionen. Weitere Informationen finden Sie unter the sectioncalled “Greengrass-Messaging – Workflow” (p. 430).

Note

Wenn der Core offline ist, können Greengrass Lambda-Funktionen Nachrichten mit Geräten,Konnektoren, anderen Funktionen und lokalen Schatten austauschen. Nachrichten an AWS IoTwerden allerdings in die Warteschlange verschoben. Weitere Informationen finden Sie unter thesection called “MQTT-Nachrichtenwarteschlange” (p. 58).

Andere Kommunikationsströme• Greengrass Lambda-Funktionen verwenden plattformspezifische Betriebssystem-Schnittstellen

für die Interaktion mit lokalen Ressourcen und Machine Learning-Modellen auf einem Core-Gerät.Beispielsweise können Sie die open -Methode im os-Modul in Python 2.7-Funktionen verwenden. Damiteine Funktion auf eine Ressource zugreifen kann, muss die Funktion der Ressource zugeordnet unddie Berechtigungen read-only oder read-write müssen gewährt werden. Weitere Informationendazu und zu den verfügbaren AWS IoT Greengrass-Core-Versionen finden Sie unter Zugriff auf lokaleRessourcen (p. 204) und Durchführen von Machine Learning-Inferenzen (p. 227).

Note

Wenn Sie Ihre Lambda-Funktion ohne Containerisierung verwenden, können Sie keineangefügten lokalen Ressourcen verwenden und müssen direkt darauf zugreifen. MachineLearning-Ressourcen sind für Lambda-Funktionen, die ohne Containerisierung ausgeführtwerden, nicht verfügbar.

• Greengrass Lambda-Funktionen können das AWS SDK für die Kommunikation mit AWS-Servicesverwenden. Weitere Informationen finden Sie unter AWS SDK (p. 177).

• Greengrass Lambda-Funktionen können Drittanbieter-Schnittstellen für die Kommunikation mit externenCloud-Services bereitstellen, die cloudbasierten Lambda-Funktionen ähneln.

Note

Greengrass Lambda-Funktionen können nicht mit AWS oder anderen Cloud-Serviceskommunizieren, wenn der Core offline ist.

Abrufen des Eingabe-MQTT-Themas (oder -Betreffs)

AWS IoT Greengrass verwendet Abonnements zum Steuern des Austauschs von MQTT-Nachrichtenzwischen Geräten, Lambda-Funktionen und Konnektoren in einer Gruppe und mit AWS IoT oder dem

187

https://docs.python.org/2/library/os.html

AWS IoT Greengrass EntwicklerhandbuchAbrufen des Eingabe-Themas (oder -Betreffs)

Service des lokalen Schattens. Abonnements definieren eine Nachrichtenquelle, ein Nachrichtenzielund ein MQTT-Thema, die zum Routen von Nachrichten verwendet werden. Wenn das Ziel eineLambda-Funktion ist, dann wird der Handler der Funktion aufgerufen, wenn die Quelle eine Nachrichtveröffentlicht. Weitere Informationen finden Sie unter the section called “Kommunikation über MQTT-Nachrichten” (p. 186).

Das folgende Beispiel zeigt, wie eine Lambda-Funktion das Eingabethema aus dem context, der an denHandler übergeben wurde, abrufen kann. Dies geschieht durch Zugriff auf den subject-Schlüssel ausder Kontexthierarchie (context.client_context.custom['subject']). In diesem Beispiel wirdaußerdem die Eingabe-JSON-Nachricht geparst und anschließend das geparste Thema und die Nachrichtveröffentlicht.

Note

In der AWS IoT Greengrass-API wird das Thema eines Abonnements durch die subject-Eigenschaft dargestellt.

import greengrasssdkimport logging


OUTPUT_TOPIC = 'test/topic_results'

def get_input_topic(context): try: topic = context.client_context.custom['subject'] except Exception as e: logging.error('Topic could not be parsed. ' + repr(e)) return topic def get_input_message(event): try: message = event['test-key'] except Exception as e: logging.error('Message could not be parsed. ' + repr(e)) return message

def function_handler(event, context): try: input_topic = get_input_topic(context) input_message = get_input_message(event) response = 'Invoked on topic "%s" with message "%s"' % (input_topic, input_message) logging.info(response) except Exception as e: logging.error(e)

client.publish(topic=OUTPUT_TOPIC, payload=response)

return

Um die Funktion zu testen, fügen Sie sie mithilfe der Standardkonfigurationseinstellungen Ihrer Gruppehinzu. Fügen Sie anschließend die folgenden Abonnements hinzu und stellen Sie die Gruppe bereit.Detaillierte Anweisungen finden Sie unter the section called “Modul 3 (Teil 1): Lambda-Funktionen auf AWSIoT Greengrass” (p. 89).

QuelleZielThemenfilter

IoTCloudDieseFunktiontest/input_message

188

https://docs.aws.amazon.com/greengrass/latest/apireference/definitions-subscription.html

AWS IoT Greengrass EntwicklerhandbuchLebenszykluskonfiguration

QuelleZielThemenfilter

DieseFunktionIoTCloudtest/topic_results

Nach Abschluss der Bereitstellung rufen Sie die Funktion auf.

1. Öffnen Sie in der AWS IoT-Konsole die Seite Test.2. Abonnieren Sie das test/topic_results-Thema.3. Veröffentlichen Sie eine Nachricht im test/input_message-Thema. In diesem Beispiel müssen Sie

die test-key-Eigenschaft in die JSON-Nachricht einbinden.

{ "test-key": "Some string value"}

Ist der Befehl erfolgreich, veröffentlicht die Funktion die Eingabethema- und Nachrichtenzeichenfolgeim test/topic_results-Thema.

Lebenszykluskonfiguration für Greengrass Lambda-Funktionen

Der Lebenszyklus der Greengrass Lambda-Funktion bestimmt, wann eine Funktion gestartet undwie sie erstellt und verwendet wird. Der Lebenszyklus legt außerdem fest, wie Variablen und dieVorverarbeitungslogik außerhalb des Funktionshandlers beibehalten werden.

AWS IoT Greengrass unterstützt die Lebenszyklen „On-Demand“ (Standard) oder „Langlebig“:

• On-Demand-Funktionen starten bei Aufruf und stoppen, wenn keine weiteren Aufgaben auszuführensind. Ein Aufruf der Funktion erstellt einen separaten Container (oder eine Sandbox) für die Verarbeitungder Aufrufe, es sei senn, ein vorhandener Container kann erneut verwendet werden. Daten, die an dieFunktion gesendet werden, können von jedem der Container abgerufen werden.

Es können mehrere Aufrufe einer On-Demand-Funktion parallel ausgeführt werden.

Variablen und die Vorverarbeitungslogik, die außerhalb des Funktionshandlers definiert sind, werdennicht beibehalten, wenn neue Container erstellt werden.

• Langlebige (oder angeheftete) Funktionen werden nach dem Start der AWS IoT Greengrass-Coreautomatisch gestartet und in einem einzelnen Container ausgeführt. Alle Daten, die an die Funktiongesendet werden, können vom selben Container abgerufen werden.

Mehrere Aufrufe werden so lange in eine Warteschlange verschoben, bis frühere Aufrufe ausgeführtwerden.

Variablen und die Vorverarbeitungslogik, die außerhalb des Funktionshandlers definiert sind, werden fürjeden Aufruf des Funktionshandlers beibehalten.

Langlebige Lambda-Funktionen sind nützlich, wenn Sie Arbeit ohne anfängliche Eingaben startenmüssen. Eine langlebige Funktion kann beispielsweise ein ML-Modell laden und mit dessen Verarbeitungbeginnen, um für den Empfang von Gerätedaten bereit zu sein.

189

AWS IoT Greengrass EntwicklerhandbuchAusführbare Lambda-Dateien

Note

Denken Sie daran, dass die Zeitüberschreitungen von langlebigen Funktionen den Aufrufenihrer Handler zugeordnet sind. Wenn Sie unbegrenzt laufenden Code ausführen möchten, musser außerhalb des Handlers gestartet werden. Stellen Sie sicher, dass kein blockierender Codeaußerhalb des Handlers vorhanden ist, der möglicherweise verhindert, dass die Funktion denInitialisierungsvorgang abschließt.Diese Funktionen werden ausgeführt, sofern der Core nicht unterbrochen wird (z. B. bei einerGruppenbereitstellung oder dem Neustart eines Geräts) oder die Funktion einen Fehlerstatusannimmt (z. B. wegen eines Handler-Timeouts, einer nicht abgefangenen Ausnahme oder wenndie Grenzen des Arbeitsspeichers erreicht sind).

Weitere Informationen zur Wiederverwendung von Containern finden Sie unter Wiederverwendung vonContainern in AWS Lambda im AWS Compute Blog.

Ausführbare Lambda-DateienDiese Funktion ist für AWS IoT Greengrass Core v1.6 und höher verfügbar.

Bei einer Ausführbare Lambda-Datei handelt es sich um eine Greengrass Lambda-Funktion, mit der SieBinärcode in der Core-Umgebung ausführen können. Damit können Sie gerätespezifische Funktionen innativer Weise ausführen und profitieren von dem kleineren Footprint des kompilierten Codes. AusführbareLambda-Dateien kann von Ereignissen aufgerufen werden, andere Funktionen aufrufen und auf lokaleRessourcen zugreifen.

Ausführbare Lambda-Dateien unterstützen nur den binären Kodierungstyp (nicht JSON), aber Sie könnensie wie andere Greengrass Lambda-Funktionen in Ihrer Greengrass-Gruppe verwalten und bereitstellen.Die Erstellung von Ausführbare Lambda-Dateien unterscheidet sich allerdings von der Erstellung vonPython-, Java- und Node.js-Lambda-Funktionen:

• Mit der AWS Lambda-Konsole können Sie keine Ausführbare Lambda-Datei erstellen (oder verwalten).Sie können einen Ausführbare Lambda-Datei lediglich mit der AWS Lambda-API erstellen.

• Sie laden den Funktionscode zu AWS Lambda als kompilierte ausführbare Datei mit dem AWS IoTGreengrass Core-SDK für Choch.

• Sie geben den Namen der ausführbaren Datei als Funktionshandler an.

Ausführbare Lambda-Dateien müssen bestimmte Aufrufe und Programmierparadigmen in ihrenFunktionscode implementieren. Folgendes muss beispielsweise von der main-Methode behandelt werden:

• Rufen Sie gg_global_init auf, um interne globale Variablen von Greengrass zu initialisieren. DieseFunktion muss aufgerufen werden, bevor Threads erstellt und andere AWS IoT Greengrass Core SDK-Funktionen aufgerufen werden.

• Rufen Sie gg_runtime_start auf, um den Funktionshandler mit der Lambda-Laufzeitumgebungvon Greengrass zu registrieren. Diese Funktion muss während der Initialisierung aufgerufen werden.Durch den Aufruf dieser Funktion wird der aktuelle Thread von der Laufzeit verwendet. Der optionaleGG_RT_OPT_ASYNC-Parameter weist diese Funktion an, nicht zu blockieren, sondern ein neues Threadsfür die Laufzeit zu erstellen. Diese Funktion verwendet einen SIGTERM-Handler.

Beim folgenden Codeausschnitt handelt es sich um die main-Methode aus dem simple_handler.c-Codebeispiel auf GitHub.

int main() {

190

http://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

http://aws.amazon.com/blogs/compute/container-reuse-in-lambda/

https://github.com/aws/aws-greengrass-core-sdk-c


https://github.com/aws/aws-greengrass-core-sdk-c/blob/master/aws-greengrass-core-sdk-c-example/simple_handler.c

AWS IoT Greengrass EntwicklerhandbuchErstellen einer ausführbaren Lambda-Datei

gg_error err = GGE_SUCCESS;

err = gg_global_init(0); if(err) { gg_log(GG_LOG_ERROR, "gg_global_init failed %d", err); goto cleanup; }

gg_runtime_start(handler, 0);

cleanup: return -1;}

Weitere Informationen über die Anforderungen, Einschränkungen und andere Implementierungsdetailsfinden Sie unter AWS IoT Greengrass Core-SDK für C.

Erstellen einer ausführbaren Lambda-DateiNachdem Sie Ihren Code zusammen mit dem SDK kompiliert haben, verwenden Sie AWS Lambda-API,um eine Lambda-Funktion zu erstellen und laden Sie Ihre kompilierte ausführbare Datei hoch.

Note

Ihre Funktion muss mit einem C89-kompatiblen Compiler kompiliert werden.

In folgendem Beispiel wird der CLI-Befehl create-function zum Erstellen einer Ausführbare Lambda-Dateiverwendet. Der Befehl gibt folgendes an:

• Der Name der ausführbaren Datei für den Handler. Es muss der genaue Name Ihrer kompiliertenausführbaren Datei sein.

• Der Pfad zur .zip-Datei mit der kompilierten ausführbaren Datei.• arn:aws:greengrass:::runtime/function/executable für die Laufzeit. Dies ist die

Laufzeitumgebung für alle Ausführbare Lambda-Dateien.

Note

Für role können Sie den ARN einer beliebigen Lambda-Ausführungsrolle angeben. AWS IoTGreengrass verwendet diese Rolle zwar nicht, der Parameter ist aber zum Erstellen der Funktionerforderlich. Weitere Informationen zu Lambda-Ausführungsrollen finden Sie unter AWS LambdaBerechtigungsmodell im AWS Lambda Developer Guide.

aws lambda create-function \--region aws-region \--function-name function-name \--handler executable-name \--role role-arn \--zip-file fileb://file-name.zip \--runtime arn:aws:greengrass:::runtime/function/executable

Verwenden Sie als Nächstes die AWS Lambda-API, um eine Version zu veröffentlichen und einen Alias zuerstellen.

• Verwenden Sie publish-version, um eine Funktionsversion zu veröffentlichen.

aws lambda publish-version \--function-name function-name \

191


https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html

https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html

https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html

https://docs.aws.amazon.com/cli/latest/reference/lambda/publish-version.html

AWS IoT Greengrass EntwicklerhandbuchAusführen von AWS IoT Greengrass

in einem Docker-Container

--region aws-region

• Verwenden Sie create-alias, um einen Alias zu erstellen, der auf die soeben veröffentlichte Version weist.Wir empfehlen, dass Sie Lambda-Funktionen nach Alias referenzieren, wenn Sie eine Greengrass-Gruppe hinzufügen.

aws lambda create-alias \--function-name function-name \--name alias-name \--function-version version-number \--region aws-region

Note

Die AWS Lambda-Konsole zeigt keine ausführbaren Lambda-Dateien an. Wenn Sie denFunktionscode aktualisieren, müssen Sie auch die Lambda-API verwenden.

Fügen Sie anschließend einer Greengrass-Gruppe die Ausführbare Lambda-Datei hinzu, konfigurierenSie sie in den gruppenspezifischen Einstellungen so, dass sie binäre Eingabedaten akzeptiert, und stellenSie die Gruppe bereit. Sie erreichen dies in der AWS IoT Greengrass-Konsole oder mithilfe der AWS IoTGreengrass-API.

Ausführen von AWS IoT Greengrass in einemDocker-Container


AWS IoT Greengrass kann zur Ausführung in einem Docker-Container konfiguriert werden.

Note

Konnektoren, lokale Geräte und Volume-Ressourcen und lokale Modellressourcen für MachineLearning können in einem Docker-Container nicht verwendet werden. Diese Funktionen werdennicht unterstützt, wenn die Lambda-Laufzeitumgebung für die Greengrass-Gruppe auf Nocontainer (Kein Container) (p. 183) eingestellt ist. Diese Einstellung ist zur Ausführung von AWSIoT Greengrass in einem Docker-Container erforderlich.

Sie können ein Dockerfile über Amazon CloudFront (p. 20) herunterladen, auf dem die AWS IoTGreengrass Core-Software und Abhängigkeiten installiert sind. Informationen dazu, wie Sie das Docker-Image zur Ausführung auf verschiedenen Plattformarchitekturen modifizieren oder die Größe des Docker-Images verringern, finden Sie in der README-Datei im Docker-Paketdownload.

Um Ihnen den Einstieg in das Experimentieren mit AWS IoT Greengrass zu erleichtern, stellt AWSdarüber hinaus ein vordefiniertes Docker-Image bereit, auf dem die AWS IoT Greengrass Core-Softwareund Abhängigkeiten installiert sind. Sie können das vordefinierte Image aus Docker Hub oder AmazonElastic Container Registry (Amazon ECR) herunterladen und auf Windows-, macOS- und Linux (x86_64)-Plattformen ausführen. In diesem Thema wird beschrieben, wie Sie das Image von Amazon ECRherunterladen. Dies umfasst die folgenden Schritte:

1. Anfordern des AWS IoT Greengrass-Container-Image von Amazon ECR (p. 193)2. Erstellen und Konfigurieren von Greengrass-Gruppe und -Core (p. 196)3. Lokales Ausführen von AWS IoT Greengrass (p. 196)4. Konfigurieren der "No container (Kein Container)"-Containerisierung für die Gruppe (p. 200)

192

https://docs.aws.amazon.com/cli/latest/reference/lambda/create-alias.html

https://www.docker.com/

https://hub.docker.com/r/amazon/aws-iot-greengrass

https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html

https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html


5. Bereitstellen von Lambda-Funktionen für den Docker-Container (p. 200)6. (Optional) Bereitstellen von Geräten, die mit der Greengrass-Ausführung im Docker-Container

interagieren (p. 201)

VoraussetzungenZum Ausführen dieses Tutorials müssen die folgende Software und die folgenden Versionen auf IhremHostcomputer installiert sein.

• Docker, Version 18.09 oder höher. Frühere Versionen funktionieren möglicherweise auch, aber Version18.09 oder höher wird bevorzugt.

• Python, Version 3.6 oder höher.• pip, Version 18.1 oder höher.• AWS CLI, Version 1.16 oder höher.

• Informationen zum Installieren und Konfigurieren der CLI finden Sie unter Installieren der AWSCommand Line Interface und Konfigurieren der AWS CLI im Benutzerhandbuch für AWS CommandLine Interface.

• Um auf die neueste Version der AWS CLI zu aktualisieren, führen Sie den folgenden Befehl aus:

pip install awscli --upgrade --user

Note

Wenn Sie die MSI-Installation der AWS CLI auf Windows verwenden, sollten Sie Folgendesbeachten:• Wenn die Installation nicht installiert werden kann, versuchen Sie es mit der Python- und pip-

Installation.• Um auf ein neuere CLI-Version zu aktualisieren, müssen Sie den MSI-Installationsvorgang

wiederholen.

Schritt 1: Anfordern des AWS IoT Greengrass-Container-Image von Amazon ECRAWS IoT Greengrass stellt ein Docker-Image mit installierter AWS IoT Greengrass Core-Software bereit.Um schrittweise Anleitungen zu erhalten, wie das Container-Image von Amazon ECR abzurufen ist, wählenSie Ihr Betriebssystem aus:

Abrufen des Container-Image (Linux)

Führen Sie die folgenden Befehle auf Ihrem Computer-Terminal aus.

1. Rufen Sie den erforderlichen Anmeldebefehl auf, der ein Autorisierungs-Token für die AWS IoTGreengrass-Registrierung in Amazon ECR enthält.

aws ecr get-login --registry-ids 216483018798 --no-include-email --region us-west-2

Die Ausgabe ist der docker login-Befehl, den Sie im nächsten Schritt verwenden.2. Authentifizieren Sie den Docker-Client gegenüber dem AWS IoT Greengrass-Container-Image in der

Registrierung, indem Sie den Befehl docker login aus der get-login-Ausgabe ausführen. DieBefehl sollte dem folgenden Beispiel ähnlich sein.

193

https://docs.docker.com/install/

https://www.python.org/downloads/

https://pip.pypa.io/en/stable/installing

https://docs.aws.amazon.com/cli/latest/userguide/installing.html


https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html

https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html#install-msi-on-windows

https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html#awscli-install-windows-pip

https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html#awscli-install-windows-pip

AWS IoT Greengrass EntwicklerhandbuchAnfordern des AWS IoT Greengrass-Container-Image von Amazon ECR

docker login -u AWS -p abCzYZ123... https://216483018798.dkr.ecr.us-west-2.amazonaws.com

3. Rufen Sie das AWS IoT Greengrass-Container-Image ab.

docker pull 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest

Note

Das Tag latest entspricht dem neuesten AWS IoT Greengrass-Container. Sie können auchandere Versionen per Pull aus dem Repository abrufen. Um alle Images aufzulisten, die imAWS IoT Greengrass-Repository verfügbar sind, verwenden Sie den Befehl aws ecr list-images. Zum Beispiel:

aws ecr list-images --region us-west-2 --registry-id 216483018798 --repository-name aws-iot-greengrass

4. Aktivieren Sie den symlink- und hardlink-Schutz. Wenn Sie mit dem Ausführen von AWS IoTGreengrass in einem Container experimentieren, können Sie die Einstellungen nur für den aktuellenStartvorgang aktivieren.

Note

Sie müssen diese Befehle möglicherweise mit sudo ausführen.

• Um die Einstellungen nur für den aktuellen Systemstart zu aktivieren:

echo 1 > /proc/sys/fs/protected_hardlinksecho 1 > /proc/sys/fs/protected_symlinks

• So aktivieren Sie die Einstellungen, damit sie über Neustarts hinweg beibehalten werden:

echo '# AWS Greengrass' >> /etc/sysctl.conf echo 'fs.protected_hardlinks = 1' >> /etc/sysctl.conf echo 'fs.protected_symlinks = 1' >> /etc/sysctl.conf

sysctl -p

5. Aktivieren Sie die IPv4-Netzwerkweiterleitung, die erforderlich ist, damit die AWS IoT Greengrass-Cloud-Bereitstellung und MQTT-Kommunikation auf Linux funktionieren. Legen Sie in der Datei /etc/sysctl.conf für net.ipv4.ip_forward "1" fest und laden Sie dann sysctls neu.

sudo nano /etc/sysctl.conf# set this net.ipv4.ip_forward = 1sudo sysctl -p

Note

Sie können anstelle von nano einen Editor Ihrer Wahl verwenden.

Abrufen des Container-Image (macOS)



194

AWS IoT Greengrass EntwicklerhandbuchAnfordern des AWS IoT Greengrass-Container-Image von Amazon ECR







Note



Abrufen des Container-Image (Windows)

Führen Sie in einem Eingabeaufforderungsfenster die folgenden Befehle aus. Um Docker-Befehle aufWindows verwenden zu können, muss der Docker-Desktop ausgeführt werden.








Note


195

AWS IoT Greengrass EntwicklerhandbuchErstellen und Konfigurieren vonGreengrass-Gruppe und -Core


Schritt 2: Erstellen und Konfigurieren von Greengrass-Gruppe und -CoreAuf dem Docker-Image ist die AWS IoT Greengrass Core-Software bereits installiert, Sie müssen abereine Greengrass-Gruppe und einen Greengrass-Core erstellen. Dazu gehören das Herunterladen vonZertifikaten und von der Core-Konfigurationsdatei.

• Führen Sie die Schritte unter the section called “Konfigurieren von AWS IoT Greengrass aufAWS IoT” (p. 82) aus. Überspringen Sie Schritt 8b, bei dem Sie die AWS IoT Greengrass Core-Software herunterladen. Die Software und ihre Laufzeitabhängigkeiten sind im Docker-Image bereitseingerichtet.

Schritt 3: Lokales Ausführen von AWS IoT GreengrassNachdem Ihre Gruppe konfiguriert wurde, können Sie den Core konfigurieren und starten. SchrittweiseAnleitungen hierzu erhalten Sie bei Auswahl Ihres Betriebssystems:

Lokales Ausführen von Greengrass (Linux)


1. Dekomprimieren Sie die Zertifikate und die Konfigurationsdatei (die beim Erstellen der Greengrass-Gruppe heruntergeladen wurde) an einem bekannten Speicherort, z. B. /tmp. Zum Beispiel:

tar xvzf hash-setup.tar.gz -C /tmp/

2. Überprüfen Sie die Dokumentation zu Server-Authentifizierung im AWS IoT-Core und wählen Sie dasentsprechende CA-Stammzertifikat. Wir empfehlen, Amazon Trust Services(ATS)-Endpunkte und CA-Zertifikate von ATS zu verwenden.

Laden Sie das CA-Stammzertifikat mit den folgenden Befehlen in das Verzeichnis herunter, in dem Siedie Zertifikate und Konfigurationsdatei dekomprimiert haben. Zertifikate ermöglichen es Ihrem Gerät,über TLS eine Verbindung zu AWS IoT herzustellen.

Ersetzen Sie /tmp mit dem Pfad zum Verzeichnis.

Important


• Laden Sie für ATS-Endpunkte (empfohlen) das entsprechende CA-Stammzertifikat von ATSherunter. Im folgenden Beispiel wird AmazonRootCA1.pem heruntergeladen.

cd /tmp/certs/sudo wget -O root.ca.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem

196


AWS IoT Greengrass EntwicklerhandbuchLokales Ausführen von AWS IoT Greengrass


cd /tmp/certs/sudo wget -O root.ca.pem https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

Note

Der Parameter wget -O ist der Großbuchstabe O3. Starten Sie AWS IoT Greengrass und stellen Sie die Zertifikate und die Konfigurationsdatei mit einem

Bind-Mount im Docker-Container bereit.

Ersetzen Sie /tmp durch den Pfad, in den Sie Ihre Zertifikate und Konfigurationsdatei dekomprimierthaben.

docker run --rm --init -it --name aws-iot-greengrass \--entrypoint /greengrass-entrypoint.sh \-v /tmp/certs:/greengrass/certs \-v /tmp/config:/greengrass/config \-p 8883:8883 \216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest

Die Ausgabe sollte in etwa wie folgt aussehen:

Setting up greengrass daemonValidating hardlink/softlink protectionWaiting for up to 30s for Daemon to start

Greengrass successfully started with PID: 10

Lokales Ausführen von Greengrass (macOS)Führen Sie die folgenden Befehle auf Ihrem Computer-Terminal aus.

1. Dekomprimieren Sie die Zertifikate und die Konfigurationsdatei (die beim Erstellen der Greengrass-Gruppe heruntergeladen wurde) an einem bekannten Speicherort, z. B. /tmp. Zum Beispiel:

tar xvzf hash-setup.tar.gz -C /tmp/



Ersetzen Sie /tmp mit dem Pfad zum Verzeichnis.Important

Der Typ Ihres CA-Zertifikat muss dem Endpunkt entsprechen. Sie müssen ein CA-Stammzertifikat von ATS mit einem ATS-Endpunkt (empfohlen) oder ein CA-Stammzertifikatvon Verisign mit einem Legacy-Endpunkt verwendet. Nur einige AWS-Regionen unterstützen

197



Legacy-Endpunkte. Weitere Informationen finden Sie unter the section called “Endpunktemüssen dem Zertifikattyp entsprechen” (p. 48).

• Laden Sie für ATS-Endpunkte (empfohlen) das entsprechende CA-Stammzertifikat von ATSherunter. Im folgenden Beispiel wird AmazonRootCA1.pem heruntergeladen.

cd /tmp/certs/sudo wget -O root.ca.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem


cd /tmp/certs/sudo wget -O root.ca.pem https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

Note

Der Parameter wget -O ist der Großbuchstabe O3. Starten Sie AWS IoT Greengrass und stellen Sie die Zertifikate und die Konfigurationsdatei mit einem

Bind-Mount im Docker-Container bereit.


docker run --rm --init -it --name aws-iot-greengrass \--entrypoint /greengrass-entrypoint.sh \-v /tmp/certs:/greengrass/certs \-v /tmp/config:/greengrass/config \-p 8883:8883 \216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest




Lokales Ausführen von Greengrass (Windows)

1. Verwenden Sie ein Dienstprogramm wie z. B. WinZip oder 7-Zip zum Dekomprimieren der Zertifikateund der Konfigurationsdatei, die Sie beim Erstellen Ihrer Greengrass-Gruppe heruntergeladen haben.Weitere Informationen finden Sie in der Dokumentation zu WinZip.

Suchen Sie die heruntergeladene Datei hash-setup.tar.gz auf Ihren Computer unddekomprimieren Sie die Datei in C:\Users\%USERNAME%\Downloads\.


198

https://www.winzip.com/win/en/tar-file.html




Important


• Laden Sie für ATS-Endpunkte (empfohlen) das entsprechende CA-Stammzertifikat von ATSherunter. Im folgenden Beispiel wird AmazonRootCA1.pem heruntergeladen.• Wenn curl installiert ist, führen Sie die folgenden Befehle im Eingabeaufforderungsfenster aus.

cd C:\Users\%USERNAME%\Downloads\certscurl https://www.amazontrust.com/repository/AmazonRootCA1.pem -o root.ca.pem

• Öffnen Sie andernfalls das Zertifikat Amazon Root CA 1 in einem Webbrowser. Speichern Sie dasDokument unter root.ca.pem im Verzeichnis C:\Users\%USERNAME%\Downloads\certs, indem die dekomprimierten Zertifikate enthalten sind.

Note

Speichern Sie die Datei abhängig von Ihrem Browser direkt über den Browser oderkopieren Sie den angezeigten Schlüssel in die Zwischenablage und speichern Sie ihn inNotepad.

• Laden Sie für Legacy-Endpunkte ein CA-Stammzertifikat von Verisign herunter. Auch wenn Legacy-Endpunkte für dieses Tutorial verwendet werden können, empfehlen wir, einen ATS-Endpunkt zuerstellen und ein CA-Stammzertifikat von ATS herunterzuladen.• Wenn curl installiert ist, führen Sie die folgenden Befehle im Eingabeaufforderungsfenster aus.

cd C:\Users\%USERNAME%\Downloads\certscurl https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem -o root.ca.pem

• Öffnen Sie andernfalls das CA-Stammzertifikat VeriSign Class 3 Public Primary G5 in einemWebbrowser. Speichern Sie das Dokument unter root.ca.pem im Verzeichnis C:\Users\%USERNAME%\Downloads\certs, in dem die dekomprimierten Zertifikate enthalten sind.

Note

Speichern Sie die Datei abhängig von Ihrem Browser direkt über den Browser oderkopieren Sie den angezeigten Schlüssel in die Zwischenablage und speichern Sie ihn inNotepad.

3. Starten Sie AWS IoT Greengrass und stellen Sie die Zertifikate und die Konfigurationsdatei miteinem Bind-Mount im Docker-Container bereit. Führen Sie in einem Eingabeaufforderungsfenster diefolgenden Befehle aus.

docker run --rm --init -it --name aws-iot-greengrass --entrypoint /greengrass-entrypoint.sh -v c:/Users/%USERNAME%/Downloads/certs:/greengrass/certs -v c:/Users/%USERNAME%/Downloads/config:/greengrass/config -p 8883:8883 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest

Geben Sie bei einer entsprechenden Docker-Eingabeaufforderung Ihr C:\-Laufwerk für den Docker-Daemon frei, sodass er das Verzeichnis C:\ innerhalb des Docker-Containers mit einem Bind-Mount

199

https://curl.haxx.se/download.html

https://www.amazontrust.com/repository/AmazonRootCA1.pem

https://curl.haxx.se/download.html

https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der "No container (Kein

Container)"-Containerisierung für die Gruppe

bereitstellen kann. Weitere Informationen finden Sie in der Docker-Dokumentation unter FreigegebeneLaufwerke.




Note

Wenn der Container die Shell nicht öffnet und sofort beendet, können Sie das Problemdebuggen, indem Sie ein Bind-Mount der Greengrass Runtime-Protokolle beim Start des Abbildserstellen. Weitere Informationen finden Sie unter the section called “Erhalten der Greengrass-Laufzeitprotokolle außerhalb des Docker-Containers” (p. 202).

Schritt 4: Konfigurieren der "No container (KeinContainer)"-Containerisierung für die Greengrass-GruppeWenn Sie AWS IoT Greengrass in einem Docker-Container ausführen, müssen alle Lambda-Funktionenohne Containerisierung ausgeführt werden. In diesem Schritt legen Sie als Standard-Containerisierung fürdie Gruppe No container (Kein Container) fest. Dies muss vor der erstmaligen Bereitstellung der Gruppegeschehen.

1. Wählen Sie in der AWS IoT-Konsole die Option Greengrass und dann Groups (Gruppen) aus.2. Wählen Sie die Gruppe aus, deren Einstellungen Sie ändern möchten.3. Wählen Sie Settings aus.4. Wählen Sie unter Lambda runtime environment (Lambda-Laufzeitumgebung) die Option No container

(Kein Container) aus.5. Wählen Sie Update default Lambda execution configuration (Lambda-

Standardausführungskonfiguration aktualisieren). Überprüfen Sie die Nachricht im Bestätigungsfensterund klicken Sie dann auf Weiter.

Weitere Informationen finden Sie unter the section called “Festlegen der Standard-Containerisierung fürLambda-Funktionen in einer Gruppe” (p. 186).

Note

Die Lambda-Funktionen verwenden standardmäßig die Gruppeneinstellung für dieContainerisierung. Wenn Sie die Einstellung No container (Kein Container) für beliebige derLambda-Funktionen überschreiben, wenn AWS IoT Greengrass in einem Docker-Containerausgeführt wird, schlägt die Bereitstellung fehl.

Schritt 5: Bereitstellen von Lambda-Funktionen für denAWS IoT Greengrass-Docker-ContainerSie können langlebige Lambda-Funktionen für den Greengrass-Docker-Container bereitstellen.

200

https://docs.docker.com/docker-for-windows/#shared-drives

https://docs.docker.com/docker-for-windows/#shared-drives

AWS IoT Greengrass Entwicklerhandbuch(Optional) Bereitstellen von Geräten, die mit der

Greengrass-Ausführung im Docker-Container interagieren

• Befolgen Sie die Schritte in the section called “Modul 3 (Teil 1): Lambda-Funktionen auf AWS IoTGreengrass” (p. 89) zur Bereitstellung einer langlebigen "Hello World"-Lambda-Funktion für denContainer.

Schritt 6: (Optional) Bereitstellen von Geräten, diemit der Greengrass-Ausführung im Docker-ContainerinteragierenSie können auch Greengrass-Geräte bereitstellen, die bei AWS IoT Greengrass interagieren, wenn es ineinem Docker-Container ausgeführt wird.

• Befolgen Sie die Schritte in the section called “Modul 4: Interaktion mit Geräten in einer AWS IoTGreengrass-Gruppe” (p. 116) zur Bereitstellung von Geräten, die eine Verbindung mit dem Coreherstellen und MQTT-Nachrichten senden.

Anhalten des AWS IoT Greengrass-Docker-ContainersUm den AWS IoT Greengrass-Docker-Container zu beenden, drücken Sie im Terminal- oderEingabeaufforderungsfenster Strg+C. Diese Aktion sendet SIGTERM zum Greengrass-Daemon-Prozess,um den Greengrass-Daemon-Prozess und alle Lambda-Prozesse, die vom Daemon-Prozess gestartetwurden, zu beenden. Der Docker-Container wird mit dem Prozess /dev/init als PID 1 initialisiert,wodurch alle verbliebenen Zombieprozesse entfernen werden. Weitere Informationen finden Sie in derReferenz zu docker run.

Fehlerbehebung bei AWS IoT Greengrass in einemDocker-ContainerVerwenden Sie die folgenden Informationen für die Problembehandlung mit der AWS IoT Greengrass-Ausführung in einem Docker-Container.

Fehler: Unbekannte Optionen: -no-include-emailLösung: Dieser Fehler kann auftreten, wenn Sie den Befehl aws ecr get-login ausführen. StellenSie sicher, dass die neueste AWS CLI-Version (z. B. run: pip install awscli --upgrade --user) installiert ist. Wenn Sie Windows verwenden und die CLI mit dem MSI-Installationsprogramminstalliert haben, müssen Sie den Installationsvorgang wiederholen. Weitere Informationen finden Sie unterInstallieren der AWS Command Line Interface unter Microsoft Windows im Benutzerhandbuch für AWSCommand Line Interface.

Warnung: IPv4 ist deaktiviert. Das Netzwerk wird nichtfunktionieren.Lösung: Sie können diese Warnung oder eine ähnliche Nachricht erhalten, wenn Sie AWS IoT Greengrassauf einem Linux-Computer ausführen. Aktivieren Sie die IPv4-Netzwerkweiterleitung wie in diesemSchritt (p. 194) beschrieben. Die AWS IoT Greengrass-Cloud Bereitstellung und MQTT-Kommunikationsind nicht funktionsfähig, wenn die IPv4-Weiterleitung nicht aktiviert ist. Weitere Informationen finden Sieunter Configure namespaced kernel parameters (sysctls) at runtime in der Docker-Dokumentation.

201

https://docs.docker.com/engine/reference/commandline/run/#options

https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html

https://docs.docker.com/engine/reference/commandline/run/#configure-namespaced-kernel-parameters-sysctls-at-runtime

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei AWS IoT

Greengrass in einem Docker-Container

Fehler: Eine Firewall blockiert die Freigabe von Dateien zwischenFenstern und den Containern.Lösung: Sie können diese Fehlermeldung oder eine Firewall Detected-Nachricht erhalten, wenn SieDocker auf einem Windows-Computer ausführen. Siehe Docker-Support-Fall Error: A firewall is blocking filesharing between Windows and the containers. Dies kann auch auftreten, wenn Sie an einem Virtual PrivateNetwork (VPN) angemeldet sind und Ihre Netzwerkeinstellungen die Bereitstellung des freigegebenenLaufwerks verhindern. Deaktivieren Sie in diesem Fall das VPN und führen Sie den Docker-Containererneut aus.

Hilfe zur allgemeinen Problembehebung für AWS IoT Greengrass finden Sie unter Fehlersuche (p. 500).

Debuggen von AWS IoT Greengrass in einem Docker-ContainerZum Debuggen von Problemen mit einem Docker-Container können Sie die Greengrass-Laufzeitprotokolleerhalten oder eine interaktive Shell an den Docker-Container anfügen.

Erhalten der Greengrass-Laufzeitprotokolle außerhalb des Docker-Containers

Sie können die AWS IoT Greengrass Docker-Container ausführen, nachdem Sie einen Bind-Mount mit dem/greengrass/ggc/var/log-Verzeichnis erstellt haben. Die Protokolle bleiben auch dann erhalten, wennder Container beendet oder entfernt wird.

Unter Linux oder macOS

Beenden Sie alle Greengrass-Docker-Container (p. 201), die auf dem Host ausgeführt werden, undführen Sie dann den folgenden Befehl in einem Terminal aus. Auf diese Weise wird ein Bind-Mountdes Greengrass log-Verzeichnisses erstellt und das Docker-Image gestartet.


docker run --rm --init -it --name aws-iot-greengrass \ --entrypoint /greengrass-entrypoint.sh \ -v /tmp/certs:/greengrass/certs \ -v /tmp/config:/greengrass/config \ -v /tmp/log:/greengrass/ggc/var/log \ -p 8883:8883 \ 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest

Anschließend können Sie Ihre Protokolle auf Ihrem Host unter /tmp/log überprüfen, um zu sehen,welche Entwicklungen in Greengrass während der Ausführung des Docker-Containers eingetretensind.

Unter Windows

Beenden Sie alle Greengrass-Docker-Container (p. 201), die auf dem Host ausgeführt werden, undführen Sie dann den folgenden Befehl in einem Befehlszeilenfenster aus. Auf diese Weise wird einBind-Mount des Greengrass log-Verzeichnisses erstellt und das Docker-Image gestartet.

cd C:\Users\%USERNAME%\Downloadsmkdir logdocker run --rm --init -it --name aws-iot-greengrass --entrypoint /greengrass-entrypoint.sh -v c:/Users/%USERNAME%/Downloads/certs:/greengrass/certs -v c:/Users/%USERNAME%/Downloads/config:/greengrass/config -v c:/Users/%USERNAME%/Downloads/log:/greengrass/ggc/var/log -p 8883:8883 216483018798.dkr.ecr.us-west-2.amazonaws.com/aws-iot-greengrass:latest

202

https://success.docker.com/article/error-a-firewall-is-blocking-file-sharing-between-windows-and-the-containers


AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei AWS IoT

Greengrass in einem Docker-Container

Anschließend können Sie Ihre Protokolle auf Ihrem Host unter C:/Users/%USERNAME%/Downloads/log überprüfen, um zu sehen, welche Entwicklungen in Greengrass während derAusführung des Docker-Containers eingetreten sind.

Anfügen einer Interaktiven Shell an den Docker-Container

Sie können eine interaktive Shell an einen AWS IoT Greengrass-Docker-Container anfügen. Auf dieseWeise können Sie den Status des Greengrass Docker-Containers untersuchen.

Unter Linux oder macOS

Führen Sie den folgenden Befehl in einem separaten Terminal aus, während der Greengrass-Docker-Container ausgeführt wird.

docker exec -it $(docker ps -a -q -f "name=aws-iot-greengrass") /bin/bash

Unter Windows

Führen Sie die folgenden Befehle in einem separaten Befehlszeilenfenster aus, während derGreengrass-Docker-Container ausgeführt wird.

docker ps -a -q -f "name=aws-iot-greengrass"

Ersetzen Sie gg-container-ID mit dem container_id-Ergebnis des vorherigen Befehls.

docker exec -it gg-container-id /bin/bash

203

AWS IoT Greengrass EntwicklerhandbuchUnterstützte Ressourcentypen

Zugriff auf lokale Ressourcen mitLambda-Funktionen und Konnektoren


Mit AWS IoT Greengrass können Sie AWS Lambda-Funktionen erstellen und Konnektoren (p. 297)in der Cloud konfigurieren und auf Core-Geräten zur lokalen Ausführung bereitstellen. Auf Greengrass-Kernen unter Linux können diese lokal bereitgestellten Lambda-Funktionen und Konnektoren auf lokaleRessourcen zugreifen, die physisch auf dem Greengrass Core-Gerät vorhanden sind. Beispielsweisekönnen Sie für die Kommunikation mit Geräten, die über Modbus oder CANBus verbunden sind, dieLambda-Funktion für den Zugriff auf den seriellen Port des Core-Geräts einrichten. Um den sicheren Zugriffauf lokale Ressourcen zu konfigurieren, müssen Sie die Sicherheit der physischen Hardware sowie desBetriebssystems des Greengrass Core-Geräts gewährleisten.

Die ersten Schritte zum Zugriff auf lokale Ressourcen finden Sie in den folgenden Tutorials:

• Konfigurieren des lokalen Ressourcenzugriffs mithilfe der AWS Command Line Interface (AWSCLI) (p. 206)

• Konfigurieren des lokalen Ressourcenzugriffs mithilfe der AWS Management Console (p. 211)

Unterstützte RessourcentypenSie können auf zwei Arten lokaler Ressourcen zugreifen: Volume-Ressourcen und Geräteressourcen.

Volume-Ressourcen

Dateien und Verzeichnisse auf dem Stammdateisystem (außer unter /sys, /dev oder /var). Dazuzählen:• Ordner oder Dateien zum Lesen/Schreiben von Informationen in Greengrass Lambda-Funktionen

(zum Beispiel /usr/lib/python2.x/site-packages/local).• Ordner oder Dateien unter dem /proc-Dateisystem des Hosts (z. B. /proc/net oder /proc/stat).

In v1.6 or later unterstützt. Zusätzliche Anforderungen finden Sie unter the section called “Volume-Ressourcen im /proc-Verzeichnis” (p. 205).

Tip

Um die Verzeichnisse /var, /var/run und /var/lib als Volume-Ressourcen zukonfigurieren, mounten Sie zunächst das Verzeichnis in einen anderen Ordner undkonfigurieren diesen Ordner als Volume-Ressource.

Wenn Sie Volume-Ressourcen konfigurieren, geben Sie einen Pfad für source (Quelle) und einen Pfadfür destination (Ziel) an. Der Quellpfad ist der absolute Pfad der Ressource auf dem Host. Der Zielpfadist der absolute Pfad der Ressource in der Lambda-Namespace-Umgebung. Dies ist der Container, indem eine Funktion oder ein Konnektor von Greengrass Lambda ausgeführt werden. Änderungen amZielpfad werden im Quellpfad des Dateisystems auf dem Host-Dateisystem wiedergegeben.

Note

Dateien im Zielpfad werden nur im Lambda-Namespace angezeigt. Sie können sie in einemregulären Linux-Namespace nicht sehen.

204


Geräteressourcen

Dateien unter /dev. Nur zeichenorientierte Geräte oder Blockgeräte unter /dev sind alsGeräteressourcen zulässig. Dazu zählen:• Serielle Ports, die für die Kommunikation mit über serielle Ports angeschlossenen Geräten

verwendet werden (zum Beispiel /dev/ttyS0, /dev/ttyS1).• USB, die zum Anschließen von USB-Peripheriegeräten verwendet werden (zum Beispiel. /dev/ttyUSB0 oder /dev/bus/usb).

• GPIOs, die für Sensoren und Aktuatoren über GPIO verwendet werden (zum Beispiel /dev/gpiomem).

• GPUs, die verwendet werden, um Machine Learning über integrierte GPUs zu beschleunigen (zumBeispiel /dev/nvidia0).

• Kameras, mit denen Bilder und Videos erfasst werden (zum Beispiel /dev/video0).

Note

/dev/shm ist eine Ausnahme. Sie kann nur als eine Volume-Ressource konfiguriert werden.Ressourcen unter /dev/shm muss die Berechtigung rw erteilt werden.

AWS IoT Greengrass unterstützt auch Ressourcentypen, die für die Durchführung von Machine Learning-Inferenz verwendet werden. Weitere Informationen finden Sie unter Durchführen von Machine Learning-Inferenzen (p. 227).

VoraussetzungenDie folgenden Anforderungen gelten für die Konfiguration des sicheren Zugriffs auf lokale Ressourcen:

• Sie müssen die AWS IoT Greengrass Core-Software v1.3 or later verwenden. Sie müssen v1.6 or laterverwenden, um Ressourcen für das /proc-Verzeichnis des Hosts zu erstellen.

• Die lokale Ressource (einschließlich aller erforderlichen Treiber und Bibliotheken) muss ordnungsgemäßauf dem Greengrass Core-Gerät installiert sein und während der gesamten Nutzung zur Verfügungstehen.

• Die gewünschte Operation der Ressource und der Zugriff auf die Ressource dürfen keine Root-Berechtigungen erfordern.

• Nur die Berechtigung read oder read and write ist verfügbar. Lambdafunktionen können keineprivilegierten Operationen für die Ressourcen ausführen.

• Sie müssen den vollständigen Pfad der lokalen Ressource im Betriebssystem des Greengrass Core-Geräts bereitstellen.

• Der Name oder die ID einer Ressource kann maximal 128 Zeichen umfassen und muss dem Muster [a-zA-Z0-9:_-]+ entsprechen.

Volume-Ressourcen im /proc-VerzeichnisDie folgenden Überlegungen gelten für Volume-Ressourcen im /proc-Verzeichnis des Hosts.

• Sie müssen die AWS IoT Greengrass Core-Software v1.6 or later verwenden.• Sie können Lesezugriff für Lambda-Funktionen aber keinen Lese-Schreib-Zugriff erteilen. Diese

Zugriffsebene wird von AWS IoT Greengrass verwaltet.• Möglicherweise müssen Sie auch Betriebssystemgruppen Berechtigungen erteilen, um Lesezugriff im

Dateisystem zu aktivieren. Nehmen wir beispielsweise an, dass Ihr Quellverzeichnis oder Ihre Quelldatei

205

AWS IoT Greengrass EntwicklerhandbuchDateizugriffsberechtigungen des Gruppenbesitzers

über die Dateiberechtigung „660“ verfügt. Dies bedeutet, dass nur der Eigentümer bzw. der Benutzer inder Gruppe Lese- (oder Schreib)-Zugriff darauf hat. In diesem Fall müssen Sie die Berechtigungen desBesitzers der Betriebssystemgruppe der Ressource hinzufügen. Weitere Informationen finden Sie unterthe section called “Dateizugriffsberechtigungen des Gruppenbesitzers” (p. 206).

• Die Host-Umgebung und der Lambda-Namespace enthalten beide ein /proc-Verzeichnis. Stellen Siedaher sicher, dass Namenskonflikte vermieden werden, wenn Sie den Zielpfad angeben. Wenn/procbeispielsweise der Quellpfad ist, können Sie /host-proc als Zielpfad angeben (oder einen beliebigenanderen Namen anstelle von „/proc“).

Dateizugriffsberechtigungen des GruppenbesitzersEin Prozess einer AWS IoT Greengrass Lambda-Funktion wird normalerweise als ggc_user undggc_group ausgeführt. Sie können jedoch für den Lambda-Funktionsprozess wie folgt zusätzlicheDateizugriffsberechtigungen in der lokalen Ressourcendefinition erteilen:

• Verwenden Sie den Parameter GroupOwnerSetting#AutoAddGroupOwner oder die KonsolenoptionAutomatisch Betriebssystemgruppenberechtigungen der Linux-Gruppe hinzufügen, zu der die Ressourcegehört, um die Berechtigungen der Linux-Gruppe hinzuzufügen, zu der die Ressource gehört.

• Verwenden Sie den Parameter GroupOwnerSetting#GroupOwner oder die KonsolenoptionGeben Sie eine andere Betriebssystemgruppe an, um eine Berechtigung hinzuzufügen, um dieBerechtigungen einer anderen Linux-Gruppe hinzuzufügen. Der Wert GroupOwner wird ignoriert, wennGroupOwnerSetting#AutoAddGroupOwner auf "true" gesetzt ist.

Ein AWS IoT Greengrass Lambda-Funktionsprozess erbt alle Dateisystemberechtigungen von ggc_user,ggc_group und der Linux-Gruppe (sofern hinzugefügt). Damit die Lambda-Funktion auf eine Ressourcezugreifen kann, muss der Lambda-Funktionsprozess über die erforderlichen Berechtigungen für dieRessource verfügen. Sie können die Berechtigung der Ressource gegebenenfalls mit dem chmod(1)-Befehl ändern.

Weitere Informationen finden Sie auch unter:• AWS IoT Greengrass-Limits in der Allgemeinen AWS-Referenz

Konfigurieren des lokalen Ressourcenzugriffsmithilfe der AWS Command Line Interface (AWSCLI)


Um eine lokale Ressource zu verwenden, müssen Sie eine Ressourcendefinition zur Gruppendefinitionhinzufügen, die auf Ihrem Greengrass Core-Gerät bereitgestellt wird. Die Gruppendefinition muss ebenfallseine Lambda-Funktionsdefinition enthalten, in der Sie Ihren Lambda-Funktionen Zugriffsberechtigungenfür lokale Ressourcen erteilen. Weitere Informationen einschließlich Anforderungen und Einschränkungenfinden Sie unter Zugriff auf lokale Ressourcen mit Lambda-Funktionen und Konnektoren (p. 204).

In diesem Tutorial wird beschrieben, wie Sie eine lokale Ressource erstellen und den Zugriff darauf mithilfeder AWS-Befehlszeilenschnittstelle (CLI) konfigurieren. Sie müssen bereits eine Greengrass-Gruppe wiein Erste Schritte mit AWS IoT Greengrass (p. 69) beschrieben erstellt haben, um die Schritte im Tutorialauszuführen.

206

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_greengrass

AWS IoT Greengrass EntwicklerhandbuchErstellen lokaler Ressourcen

Ein Tutorial, in dem die AWS Management Console verwendet wird, finden Sie unter Konfigurieren deslokalen Ressourcenzugriffs mithilfe der AWS Management Console (p. 211).

Erstellen lokaler RessourcenZuerst erstellen Sie eine Ressourcendefinition, die die Ressourcen festlegt, auf die mit dem BefehlCreateResourceDefinition zugegriffen wird. In diesem Beispiel erstellen wir die beiden RessourcenTestDirectory und TestCamera:

aws greengrass create-resource-definition --cli-input-json '{ "Name": "MyLocalVolumeResource", "InitialVersion": { "Resources": [ { "Id": "data-volume", "Name": "TestDirectory", "ResourceDataContainer": { "LocalVolumeResourceData": { "SourcePath": "/src/LRAtest", "DestinationPath": "/dest/LRAtest", "GroupOwnerSetting": { "AutoAddGroupOwner": true, "GroupOwner": "" } } } }, { "Id": "data-device", "Name": "TestCamera", "ResourceDataContainer": { "LocalDeviceResourceData": { "SourcePath": "/dev/video0", "GroupOwnerSetting": { "AutoAddGroupOwner": true, "GroupOwner": "" } } } } ] }}'

Resources: eine Liste von Resource-Objekten in der Greengrass-Gruppe. Eine Greengrass-Gruppe kannbis zu 50 Ressourcen aufweisen.

Resource#Id: die eindeutige Kennung der Ressource. Die ID wird verwendet, um auf eine Ressource in derKonfiguration der Lambda-Funktion zu verweisen. Maximale Länge: 128 Zeichen. Muster: [a-zA-Z0-9:_-]+.

Resource#Name: der Name der Ressource. Die Ressourcenname wird in der Greengrass-Konsoleangezeigt. Maximale Länge: 128 Zeichen. Muster: [a-zA-Z0-9:_-]+.

LocalDeviceResourceData#SourcePath: der lokale absolute Pfad der Geräteressource. Der Quellpfad füreine Geräteressource kann nur auf ein zeichenorientiertes Gerät oder Blockgerät unter /dev verweisen.

LocalVolumeResourceData#SourcePath: Der lokale absolute Pfad der Volume-Ressource auf demGreengrass Core-Gerät. Dieser Speicherort befindet sich außerhalb des Containers (p. 180), indem dieFunktion ausgeführt wird. Der Quellpfad für einen Volume-Ressourcentyp darf nicht mit /sys beginnen.

207

https://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinition-post.html

AWS IoT Greengrass EntwicklerhandbuchErstellen der Greengrass-Funktion

LocalVolumeResourceData#DestinationPath: der absolute Pfad der Volume-Ressource in der Lambda-Umgebung. Dieser Speicherort befindet sich innerhalb des Containers, indem die Funktion ausgeführt wird.

GroupOwnerSetting: ermöglicht die Konfiguration zusätzlicher Gruppenberechtigungen für den Lambda-Prozess. Dies ist ein optionales Feld. Weitere Informationen finden Sie unter Dateizugriffsberechtigungendes Gruppenbesitzers (p. 206).

GroupOwnerSetting#AutoAddGroupOwner: Wenn diese Option aktiviert ist, fügt Greengrass automatischden angegebenen Besitzer der Linux-Betriebssystemgruppe der Ressource zu den Berechtigungen für denLambda-Prozess hinzu. Auf diese Weise erhält der Lambda-Prozess die Dateizugriffsberechtigungen derhinzugefügten Linux-Gruppe.

GroupOwnerSetting#GroupOwner: gibt den Namen der Linux-Betriebssystemgruppe an, derenBerechtigungen zum Lambda-Prozess hinzugefügt werden. Dies ist ein optionales Feld.

Der ARN einer Ressourcendefinitionsversion wird durch CreateResourceDefinition zurückgegeben.Der ARN sollte beim Aktualisieren einer Gruppendefinition verwendet werden. Beispiel:

{ "LatestVersionArn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/definition/resources/ab14d0b5-116e-4951-a322-9cde24a30373/versions/a4d9b882-d025-4760-9cfe-9d4fada5390d", "Name": "MyLocalVolumeResource", "LastUpdatedTimestamp": "2017-11-15T01:18:42.153Z", "LatestVersion": "a4d9b882-d025-4760-9cfe-9d4fada5390d", "CreationTimestamp": "2017-11-15T01:18:42.153Z", "Id": "ab14d0b5-116e-4951-a322-9cde24a30373", "Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/ab14d0b5-116e-4951-a322-9cde24a30373"}

Erstellen der Greengrass-FunktionErstellen Sie nach der Erstellung der Ressourcen mithilfe des CreateFunctionDefinition-Befehls dieGreengrass-Funktion und erteilen Sie der Funktion Zugriff auf die Ressource:

aws greengrass create-function-definition --cli-input-json '{ "Name": "MyFunctionDefinition", "InitialVersion": { "Functions": [ { "Id": "greengrassLraTest", "FunctionArn": "arn:aws:lambda:us-west-2:012345678901:function:lraTest:1", "FunctionConfiguration": { "Pinned": false, "MemorySize": 16384, "Timeout": 30, "Environment": { "ResourceAccessPolicies": [ { "ResourceId": "data-volume", "Permission": "rw" }, { "ResourceId": "data-device", "Permission": "ro" } ], "AccessSysfs": true }

208



AWS IoT Greengrass EntwicklerhandbuchHinzufügen der Lambda-Funktion zur Gruppe

} } ] }}'

ResourceAccessPolicies: enthält die resourceId und permission, die der Lambda-Funktion Zugriff aufdie Ressource erteilen. Eine Lambda-Funktion kann über maximal 10 Ressourcen verfügen.

ResourceAccessPolicy#Permission: gibt an, welche Berechtigungen für die Ressource die Lambda-Funktion hat. Die verfügbaren Optionen sind rw (lesen/schreiben) oder ro (schreibgeschützt).

AccessSysfs: Wenn wahr, kann der Lambda-Prozess über Lesezugriff auf den /sys-Ordner aufdem Greengrass Core-Gerät verfügen. Dies wird in Fällen verwendet, in denen Greengrass LambdaGeräteinformationen aus /sys lesen muss.

Auch hier gibt CreateFunctionDefinition den ARN einer Funktionsdefinitionsversion zurück. DerARN sollte in Ihrer Gruppendefinitionsversion verwendet werden.

{ "LatestVersionArn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/definition/functions/3c9b1685-634f-4592-8dfd-7ae1183c28ad/versions/37f0d50e-ef50-4faf-b125-ade8ed12336e", "Name": "MyFunctionDefinition", "LastUpdatedTimestamp": "2017-11-22T02:28:02.325Z", "LatestVersion": "37f0d50e-ef50-4faf-b125-ade8ed12336e", "CreationTimestamp": "2017-11-22T02:28:02.325Z", "Id": "3c9b1685-634f-4592-8dfd-7ae1183c28ad", "Arn": "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/3c9b1685-634f-4592-8dfd-7ae1183c28ad"}

Hinzufügen der Lambda-Funktion zur GruppeFügen Sie zum Schluss die Funktion mit CreateGroupVersion zur Gruppe hinzu. Beispiel:

aws greengrass create-group-version --group-id "b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5" \--resource-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/resources/db6bf40b-29d3-4c4e-9574-21ab7d74316c/versions/31d0010f-e19a-4c4c-8098-68b79906fb87" \--core-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/cores/adbf3475-f6f3-48e1-84d6-502f02729067/versions/297c419a-9deb-46dd-8ccc-341fc670138b" \--function-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/d1123830-da38-4c4c-a4b7-e92eec7b6d3e/versions/a2e90400-caae-4ffd-b23a-db1892a33c78" \--subscription-definition-version-arn "arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/subscriptions/7a8ef3d8-1de3-426c-9554-5b55a32fbcb6/versions/470c858c-7eb3-4abd-9d48-230236bfbf6a"

Es wird eine neue Gruppenversion zurückgegeben:

{ "Arn": "arn:aws:greengrass:us-west-2:012345678901:/greengrass/groups/b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5/versions/291917fb-ec54-4895-823e-27b52da25481", "Version": "291917fb-ec54-4895-823e-27b52da25481", "CreationTimestamp": "2017-11-22T01:47:22.487Z", "Id": "b36a3aeb-3243-47ff-9fa4-7e8d98cd3cf5"}

209


https://docs.aws.amazon.com/greengrass/latest/apireference/creategroupversion-post.html

AWS IoT Greengrass EntwicklerhandbuchFehlersuche

Die Greengrass-Gruppe enthält nun die Lambda-Funktion lraTest, die auf zwei Ressourcen zugreifen kann:"TestDirectory" und "TestCamera".

Diese in Python geschriebene Lambda-Beispielfunktion lraTest.py schreibt in die lokale Volume-Ressource:

# Demonstrates a simple use case of local resource access.# This Lambda function writes a file "test" to a volume mounted inside# the Lambda environment under "/dest/LRAtest". Then it reads the file and # publishes the content to the AWS IoT "LRA/test" topic.

import sysimport greengrasssdkimport platformimport osimport logging

# Create a Greengrass Core SDK client.client = greengrasssdk.client('iot-data')volumePath = '/dest/LRAtest'

def function_handler(event, context): client.publish(topic='LRA/test', payload='Sent from AWS IoT Greengrass Core.') try: volumeInfo = os.stat(volumePath) client.publish(topic='LRA/test', payload=str(volumeInfo)) with open(volumePath + '/test', 'a') as output: output.write('Successfully write to a file.\n') with open(volumePath + '/test', 'r') as myfile: data = myfile.read() client.publish(topic='LRA/test', payload=data) except Exception as e: logging.error("Experiencing error :{}".format(e)) return

Diese Befehle werden von der Greengrass-API bereitgestellt, um Ressourcendefinitionen undRessourcendefinitionsversionen zu erstellen und zu verwalten:

• CreateResourceDefinition• CreateResourceDefinitionVersion• DeleteResourceDefinition• GetResourceDefinition• GetResourceDefinitionVersion• ListResourceDefinitions• ListResourceDefinitionVersions• UpdateResourceDefinition

Fehlersuche• F: Warum schlägt meine Greengrass-Gruppenbereitstellung mit einer Fehlermeldung wie der folgenden

fehl:

group config is invalid: ggc_user or [ggc_group root tty] don't have ro permission on the file: /dev/tty0

A: Dieser Fehler gibt an, dass der Lambda-Prozess nicht für den Zugriff auf die angegebeneRessource berechtigt ist. Die Lösung besteht darin, die Dateiberechtigung der Ressource zu ändern,

210


https://docs.aws.amazon.com/greengrass/latest/apireference/createresourcedefinitionversion-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/deleteresourcedefinition-delete.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinitionversion-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitions-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/listresourcedefinitionversions-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/updateresourcedefinition-put.html

AWS IoT Greengrass EntwicklerhandbuchÜber die Konsole

sodass Lambda darauf zugreifen kann. (Für Einzelheiten vgl. Dateizugriffsberechtigungen desGruppenbesitzers (p. 206)).

• F: Warum startet die Lambda-Funktion nicht und gibt eine Fehlermeldung in "runtime.log" aus, wenn ich/var/run als Volume-Ressource konfiguriere?

[ERROR]-container_process.go:39,Runtime execution error: unable to start lambda container. container_linux.go:259: starting container process caused "process_linux.go:345: container init caused \"rootfs_linux.go:62: mounting \\\"/var/run\\\" to rootfs \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys\\\" at \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys/run\\\" caused \\\"invalid argument\\\"\""

A: AWS IoT Greengrass-Core unterstützt derzeit nicht die Konfiguration von /var, /var/run und /var/lib als Volume-Ressourcen. Um dieses Problem zu umgehen, können Sie zuerst /var, /var/run oder /var/lib in einen anderen Ordner mounten und anschließend den Ordner als Volume-Ressource konfigurieren.

• F: Warum startet die Lambda-Funktion nicht und gibt eine Fehlermeldung in „runtime.log“ aus, wenn ich/dev/shm als Volume-Ressource mit Berechtigung für den schreibgeschützten Zugriff konfiguriere?

[ERROR]-container_process.go:39,Runtime execution error: unable to start lambda container. container_linux.go:259: starting container process caused "process_linux.go:345: container init caused \"rootfs_linux.go:62: mounting \\\"/dev/shm\\\" to rootfs \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys\\\" at \\\"/greengrass/ggc/packages/1.3.0/rootfs_sys/dev/shm\\\" caused \\\"operation not permitted\\\"\""”

A: /dev/shm kann nur mit Lese-/Schreibzugriff konfiguriert werden. Ändern Sie dieRessourcenberechtigung zu rw, um dieses Problem zu beheben.

Konfigurieren des lokalen Ressourcenzugriffsmithilfe der AWS Management Console


Sie können Lambda-Funktionen für den sicheren Zugriff auf lokale Ressourcen auf dem Greengrass Core-Gerät, das als Host fungiert, konfigurieren. Zu lokalen Ressourcen zählen Busse und Peripheriegeräte,die sich physisch auf dem Host befinden, oder Dateisystemvolumes auf dem Hostbetriebssystem. WeitereInformationen einschließlich Anforderungen und Einschränkungen finden Sie unter Zugriff auf lokaleRessourcen mit Lambda-Funktionen und Konnektoren (p. 204).

In diesem Tutorial wird beschrieben, wie Sie mithilfe der AWS Management Console den Zugriff auf lokaleRessourcen eines AWS IoT Greengrass-Core-Geräts konfigurieren. Es enthält die folgenden allgemeinenSchritte:

1. <a></a>2. <a></a>3. <a></a>4. <a></a>5. <a></a>6. Bereitstellen der Gruppe (p. 222)

211


Ein Tutorial, in dem die AWS Command Line Interface verwendet wird, finden Sie unter Konfigurieren deslokalen Ressourcenzugriffs mithilfe der AWS Command Line Interface (AWS CLI) (p. 206).


• Eine Greengrass-Gruppe und ein Greengrass-Core (v1.3 or later). Weitere Informationen zum Erstelleneiner Greengrass-Gruppe oder eines Greengrass-Cores finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69).

• Die folgenden Verzeichnisse auf dem Greengrass Core-Gerät:• /src/LRAtest• /dest/LRAtest

Die Besitzergruppe dieser Verzeichnisse muss über Lese- und Schreibzugriff auf die Verzeichnisseverfügen. Sie können den folgenden Befehl verwenden, um Zugriff zu erteilen:

sudo chmod 0775 /src/LRAtest

Schritt 1: Erstellen eines Bereitstellungspakets für eineLambda-FunktionIn diesem Schritt erstellen Sie ein Bereitstellungspaket für eine Lambda-Funktion. Dabei handelt es sich umeine ZIP-Datei mit dem Code der Funktion und allen zugehörigen Abhängigkeiten. Zudem laden Sie dasAWS IoT Greengrass Core SDK herunter, das als Abhängigkeit im Paket berücksichtigt wird.

1. Kopieren Sie auf Ihrem Computer folgendes Python-Skript in eine lokale Datei mit dem NamenlraTest.py. Dies ist die App-Logik für die Lambda-Funktion.

# Demonstrates a simple use case of local resource access.# This Lambda function writes a file "test" to a volume mounted inside# the Lambda environment under "/dest/LRAtest". Then it reads the file and # publishes the content to the AWS IoT "LRA/test" topic.

import sysimport greengrasssdkimport platformimport osimport logging

# Create a Greengrass Core SDK client.client = greengrasssdk.client('iot-data')volumePath = '/dest/LRAtest'

def function_handler(event, context): client.publish(topic='LRA/test', payload='Sent from AWS IoT Greengrass Core.') try: volumeInfo = os.stat(volumePath) client.publish(topic='LRA/test', payload=str(volumeInfo)) with open(volumePath + '/test', 'a') as output: output.write('Successfully write to a file.\n') with open(volumePath + '/test', 'r') as myfile: data = myfile.read() client.publish(topic='LRA/test', payload=data) except Exception as e: logging.error("Experiencing error :{}".format(e))

212

AWS IoT Greengrass EntwicklerhandbuchErstellen und Veröffentlichen einer Lambda-Funktion

return


3. Entpacken Sie das heruntergeladene Paket, um das SDK zu erhalten. Das SDK ist dergreengrasssdk-Ordner.

4. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen lraTestLambda.zip:

• lraTest.py aus. App-Logik.• greengrasssdk aus. Erforderliche Bibliothek für alle Python-Lambda-Funktionen.

Die Datei lraTestLambda.zip ist Ihr Lambda-Funktionsbereitstellungspaket. Nun können Sie eineLambda-Funktion erstellen und das Bereitstellungspaket hochladen.

Schritt 2: Erstellen und Veröffentlichen einer Lambda-FunktionIn diesem Schritt erstellen Sie mithilfe der AWS Lambda-Konsole eine Lambda-Funktion und konfigurierendiese zur Verwendung des Bereitstellungspakets. Anschließend veröffentlichen Sie eine Funktionsversionund erstellen einen Alias.

Zunächst erstellen Sie die Lambda-Funktion.

1. Wählen Sie in der AWS Management Console Services und öffnen Sie die AWS Lambda-Konsole.2. Wählen Sie Create function aus.3. Wählen Sie Author from scratch.4. Geben Sie im Abschnitt Basic information (Basisinformationen) folgende Werte ein:

a. Geben Sie für Function name (Funktionsname) TestLRA ein.b. Wählen Sie für Runtime die Option Python 2.7 aus.c. Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eine

Ausführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wirdnicht von AWS IoT Greengrass verwendet.

5. Wählen Sie Create function.

213


Laden Sie nun das Bereitstellungspaket für die Lambda-Funktion hoch und registrieren Sie denHandler.

6. Geben Sie in der Registerkarte Configuration (Konfiguration) für die Funktion unter Function code(Funktionscode) folgende Werte an.

a. Wählen Sie für Code entry type (Codeeingabetyp) die Option Upload a .ZIP file (Eine ZIP-Dateihochladen) aus.

b. Wählen Sie für Runtime die Option Python 2.7 aus.c. Geben Sie unter Handler die Einstellung lraTest.function_handler ein.

7. Wählen Sie Upload.

8. Wählen Sie das Bereitstellungspaket lraTestLambda.zip aus.9. Wählen Sie oben auf der Seite Save aus.

Note

Die Schaltfläche Test auf der AWS Lambda-Konsole kann für diese Funktion nicht verwendetwerden. Das AWS IoT Greengrass Core SDK enthält keine Module, die erforderlichsind, um Ihre Greengrass Lambda-Funktionen unabhängig in der AWS Lambda-Konsoleauszuführen. Diese Module (beispielsweise greengrass_common) werden auf dieFunktionen angewendet, nachdem sie auf Greengrass Core bereitgestellt wurden.Sie sehen Ihren Code im Abschnitt Function code (Funktionscode), indem Sie im Menü Codeentry type (Codeeingabetyp) die Option Edit code inline (Code inline bearbeiten) auswählen.

Als Nächstes veröffentlichen Sie die erste Version der Lambda-Funktion. Anschließend erstellen Sieeinen Alias für die Version.

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nachVersion referenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, da dieAbonnementtabelle oder Gruppendefinition bei der Aktualisierung des Funktionscodes nicht geändertwerden müssen. Stattdessen lassen Sie den Alias einfach auf die neue Funktionsversion verweisen.

10. Wählen Sie im Menü Actions (Aktionen) die Option Publish new version (Neue Version veröffentlichen)aus.

11. Geben Sie unter Version description (Versionsbeschreibung) den Wert First version ein undwählen Sie dann Publish.

214



12. Wählen Sie auf der Konfigurationsseite für TestLRA: 1 unter Actions (Aktionen) die Option Create alias(Alias erstellen) aus.

13. Geben Sie auf der Seite Create a new alias (Einen neuen Alias erstellen) für Name test ein. GebenSie für Version 1 ein.

Note

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen.14. Wählen Sie Create aus.

Nun können Sie die Lambda-Funktion zur Greengrass-Gruppe hinzufügen.

Schritt 3: Hinzufügen der Lambda-Funktion zurGreengrass-GruppeIn diesem Schritt fügen Sie die Funktion Ihrer Gruppe hinzu und konfigurieren dann den Lebenszyklus derFunktion.

Zunächst fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu.

1. Wählen Sie in der AWS IoT-Konsole Greengrass und dann Groups.

215


2. Wählen Sie die Greengrass-Gruppe aus, der die Lambda-Funktion hinzugefügt werden soll.3. Klicken Sie auf der Gruppenkonfigurationsseite auf Lambdas und wählen Sie dann Add Lambda.

4. Fügen Sie Ihrer Seite „Greengrass-Gruppe“ ein Lambda hinzu und wählen Sie Use existing Lambda.

216


5. Wählen Sie auf der Seite Use existing Lambda TestLRA und dann Next.6. Wählen Sie auf der Seite Select a Lambda version Alias:test und dann Finish.

Als Nächstes konfigurieren Sie den Lebenszyklus der Lambda-Funktion.7. Wählen Sie auf der Seite Lambdas die Lambda-Funktion „TestLRA“ aus.

8. Wählen Sie auf der Konfigurationsseite für TestLRA die Option Edit aus.9. Geben Sie auf der Seite Group-specific Lambda configuration (Gruppenspezifische Lambda-

Konfiguration) folgende Werte an.

a. Wählen Sie für Timeout 30 seconds (30 Sekunden).b. Wählen Sie unter Lambda lifecycle (Lambda-Lebenszyklus) die Option Make this function long-

lived and keep it running indefinitely (Machen Sie diese Funktion langlebig und lassen Sie sieauf unbestimmte Zeit laufen) aus. Weitere Informationen finden Sie unter the section called“Lebenszykluskonfiguration” (p. 189).

217

AWS IoT Greengrass EntwicklerhandbuchHinzufügen einer lokalen Ressource zur Gruppe

Important

Lambda-Funktionen, die lokale Ressourcen verwenden (wie in diesem Verfahrenbeschrieben), müssen in einem Greengrass-Container ausgeführt werden. Andernfallswird die Bereitstellung der Funktion fehlschlagen. Weitere Informationen finden Sie unterContainerization (Containerisierung) (p. 180).

10. Wählen Sie unten auf der Seite Update aus.

Schritt 4: Hinzufügen einer lokalen Ressource zurGreengrass-GruppeIn diesem Schritt fügen Sie eine lokale Volume-Ressource der Greengrass-Gruppe hinzu und erteilender Funktion Lese- und Schreibzugriff auf die Ressource. Eine lokale Ressource verfügt über einenGruppenebenen-Bereich. Sie können jeder beliebigen Lambda-Funktion in der Gruppe Berechtigungen fürden Zugriff auf die Ressource erteilen.

1. Wählen Sie auf der Gruppenkonfigurationsseite die Option Ressourcen aus.

218

AWS IoT Greengrass EntwicklerhandbuchHinzufügen einer lokalen Ressource zur Gruppe

2. Wählen Sie in der Registerkarte Local (Lokal) Add a local resource (Eine lokale Ressourcehinzufügen).

3. Geben Sie auf der Seite Create a local resource (Erstellen einer lokalen Ressource) folgende Wertean.

a. Geben Sie für Resource name (Ressourcenname) testDirectory ein.b. Wählen Sie für Resource type (Ressourcentyp) die Option Volume aus.c. Geben Sie für Source path (Quellpfad) /src/LRAtest ein. Dieser Pfad muss auf dem Host-

Betriebssystem vorhanden sein.

Der Quellpfad ist der lokale absolute Pfad der Ressource auf dem Dateisystem des Core-Geräts. Dieser Speicherort befindet sich außerhalb des Containers (p. 180), indem die Funktionausgeführt wird. Der Pfad darf nicht mit /sys beginnen.

d. Geben Sie für Destination path (Zielpfad) /dest/LRAtest ein. Dieser Pfad muss auf dem Host-Betriebssystem vorhanden sein.

Der Zielpfad ist der absolute Pfad der Ressource im Lambda-Namespace. Dieser Speicherortbefindet sich innerhalb des Containers, indem die Funktion ausgeführt wird.

e. Wählen Sie unter Group owner file access permission (Dateizugriffsberechtigung desGruppenbesitzers) die Option Automatically add OS group permissions of the Linux group thatowns the resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppehinzufügen, zu der die Ressource gehört) aus.

Mit der Option Group owner file access permission (Dateizugriffsberechtigung desGruppenbesitzers) können Sie zusätzliche Dateizugriffsberechtigungen für den Lambda-Prozess erteilen. Weitere Informationen finden Sie unter Dateizugriffsberechtigungen desGruppenbesitzers (p. 206).

4. Wählen Sie unter Lambda function affiliations (Lambda-Funktionszuordnungen) die Option Auswählenaus.

5. Wählen Sie TestLRA, Read and write access (Lese- und Schreibzugriff) und dann Done (Fertig) aus.

219

AWS IoT Greengrass EntwicklerhandbuchHinzufügen von Abonnements zur Gruppe

6. Wählen Sie unten auf der Seite Save aus. Auf der Seite Resources wird die neue Ressource"testDirectory" angezeigt.

Schritt 5: Hinzufügen von Abonnements zurGreengrass-GruppeIn diesem Schritt fügen Sie zwei Abonnements zur Greengrass-Gruppe hinzu. Mit diesen Abonnementswird die bidirektionale Kommunikation zwischen der Lambda-Funktion und AWS IoT eingerichtet.

Zuerst erstellen Sie ein Abonnement für die Lambda-Funktion, damit Nachrichten an AWS IoT gesendetwerden können.

1. Klicken Sie auf der Gruppenkonfigurationsseite auf Subscriptions und wählen Sie dann AddSubscription.

2. Konfigurieren Sie auf der Seite Select your source and target die Quelle und das Ziel wie folgt:

a. Wählen Sie für Select a source (Eine Quelle auswählen) die Option Lambdas und dann TestLRAaus.

b. Wählen Sie für Select a target (Ein Ziel auswählen) die Option Services und dann IoT Cloud aus.c. Wählen Sie Next.

220


3. Geben Sie auf der Seite Filter your data with a topic (Ihre Daten nach einem Thema filtern) für Optionaltopic filter (Optionaler Themenfilter) LRA/test ein und wählen Sie dann Next.

4. Wählen Sie Finish aus Auf der Seite Subscriptions wird das neue Abonnement angezeigt.

Als Nächstes konfigurieren Sie ein Abonnement, mit dem die Funktion aus AWS IoT aufgerufenwerden kann.

5. Wählen Sie auf der Seite Subscriptions Add Subscription.6. Konfigurieren Sie auf der Seite Select your source and target die Quelle und das Ziel wie folgt:

a. Wählen Sie für Select a source (Eine Quelle auswählen) die Option Services und dann IoT Cloudaus.

b. Wählen Sie für Select a target (Ein Ziel auswählen) die Option Lambdas und dann TestLRA aus.c. Wählen Sie Next.

221

AWS IoT Greengrass EntwicklerhandbuchBereitstellen der Gruppe

7. Geben Sie auf der Seite Filter your data with a topic (Ihre Daten nach einem Thema filtern) für Optionaltopic filter (Optionaler Themenfilter) invoke/LRAFunction ein und wählen Sie dann Next.

8. Wählen Sie Finish aus. Auf der Seite Subscriptions werden die beiden Abonnements angezeigt.

Schritt 6: Bereitstellen der AWS IoT Greengrass-GruppeIn diesem Schritt stellen Sie die aktuelle Version der Gruppendefinition bereit.

1. Stellen Sie sicher, dass die AWS IoT Greengrass-Core ausgeführt wird. Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus, falls nötig.




Note

Die Version in dem Pfad hängt von der AWS IoT Greengrass-Core-Softwareversion ab,die auf Ihrem Core-Gerät installiert ist.

222




2. Wählen Sie auf der Gruppenkonfigurationsseite Deployments (Bereitstellungen) und Actions (Aktionen)die Option Deploy (Bereitstellen) aus.

Note

Die Bereitstellung schlägt fehl, wenn Sie Ihre Lambda-Funktion ohne Containerisierungausführen und versuchen, auf zugeordnete lokale Ressourcen zuzugreifen.

3. Wählen Sie auf der Seite Configure how devices discover your core die Option Automatic detection.

Damit können Geräte automatisch Core-Verbindungsinformationen abrufen, z. B. die IP-Adresse,DNS und die Portnummer. Die automatische Ermittlung wird empfohlen, aber AWS IoT Greengrassunterstützt auch manuell angegebene Endpunkte. Sie werden nur bei der ersten Bereitstellung derGruppe zur Angabe der Ermittlungsmethode aufgefordert.

Note

Wenn Sie dazu aufgefordert werden, erteilen Sie die Berechtigung zur Erstellung derGreengrass-Service-Rolle (p. 432) und verknüpfen diese mit Ihrem AWS-Konto in deraktuellen AWS-Region. Diese Rolle ermöglicht es AWS IoT Greengrass, auf Ihre Ressourcenin AWS-Services zuzugreifen. Pro AWS-Konto ist nur eine Greengrass-Service-Rolleerforderlich. Diese muss jedoch in jeder AWS-Region, in der Sie AWS IoT Greengrassverwenden, mit Ihrem AWS-Konto verknüpft sein.

Auf der Seite Deployments werden der Zeitstempel, die Versions-ID und der Status der Bereitstellungangegeben. Nach Abschluss ist der Bereitstellungsstatus Successfully completed (Erfolgreichabgeschlossen(.


223

AWS IoT Greengrass EntwicklerhandbuchTesten des lokalen Ressourcenzugriffs

Testen des lokalen RessourcenzugriffsNun können Sie prüfen, ob der Zugriff auf die lokale Ressource korrekt konfiguriert ist. Um zu testen,abonnieren Sie das Thema LRA/test und veröffentlichen Sie im invoke/LRAFunction-Thema. DerTest ist erfolgreich, wenn die Lambda-Funktion die erwartete Nutzlast an AWS IoT sendet.

1. Wählen Sie auf der AWS IoT-Konsole-Startseite im linken Fenster Test.

2. Geben Sie im Abschnitt Subscriptions (Abonnements) unter Subscription topic (Abonnementthema)LRA/test ein. Wählen Sie für MQTT payload display (MQTT-Nutzlast-Anzeige) die Option Displaypayloads as strings (Nutzlasten als Zeichenfolgen anzeigen) aus.

3. Wählen Sie Subscribe to topic. Ihre Lambda-Funktion veröffentlicht an das LRA/test-Thema.

224


4. Geben Sie im Bereich Publish (Veröffentlichen) invoke/LRAFunction ein, und wählen Sie dannPublish to topic, um Ihre Lambda-Funktion aufzurufen. Der Test ist erfolgreich, wenn auf der Seite diedrei Nachrichtennutzlasten der Funktion angezeigt werden.

225


Die von der Lambda-Funktion erstellte Testdatei befindet sich im Verzeichnis /src/LRAtest auf demGreengrass-Core-Gerät. Obwohl die Lambda-Funktion in eine Datei im Verzeichnis /dest/LRAtestschreibt, ist diese Datei nur im Lambda-Namespace sichtbar. Sie können sie in einem regulären Linux-Namespace nicht sehen. Alle Änderungen am Zielpfad werden im Quellpfad des Dateisystems reflektiert.


226

AWS IoT Greengrass EntwicklerhandbuchWie AWS IoT Greengrass-ML-Inferenz funktioniert

Durchführen von Machine Learning-Inferenzen

Diese Funktion ist für AWS IoT Greengrass Core v1.6 or later verfügbar.

Sie können mit AWS IoT Greengrass Machine Learning (ML)-Inferenz am Edge-Standort mit lokalgenerierten Daten mithilfe von Cloud-geschulten Modellen durchführen. Sie können von der niedrigenLatenz und Kosteneinsparungen der Ausführung von lokaler Inferenz profitieren und trotzdem die Cloud-Rechenleistung für Schulungsmodelle und komplexe Verarbeitung nutzen.

Hinweise zur Durchführung von lokaler Inferenz finden Sie unter the section called “So konfigurieren SieMachine Learning-Inferenz” (p. 232).

Wie AWS IoT Greengrass-ML-Inferenz funktioniertSie können Ihre Inferenzmodelle überall schulen. Stellen Sie sie als machine learning resources lokalin einer Greengrass-Gruppe bereit und greifen Sie über die Greengrass-Lambda-Funktionen darauf zu.Sie können beispielsweise Deep-Learning-Modelle in Amazon SageMaker erstellen und schulen undsie in Ihrem Greengrass Core bereitstellen. Ihre Lambda-Funktionen können dann die lokalen Modelleverwenden, um Inferenz auf verbundene Geräte durchzuführen und neue Schulungsdaten zurück in dieCloud zu senden.

Das folgende Diagramm zeigt den AWS IoT Greengrass-ML-Inferenz-Workflow.

Die AWS IoT Greengrass-ML-Inferenz vereinfacht die einzelnen Schritte des ML-Workflows, darunter:

• Die Entwicklung und Bereitstellung von ML-Framework-Prototypen.• Der Zugriff auf Cloud-geschulte Modelle und die deren Bereitstellung in Greengrass Core-Geräten.• Erstellen von Inferenz-Apps, die auf Hardware-Beschleuniger (z. B. GPUs und FPGAs) als lokale

Ressourcen (p. 204) zugreifen können.

227

https://console.aws.amazon.com/sagemaker

AWS IoT Greengrass EntwicklerhandbuchMachine Learning-Ressourcen

Machine Learning-RessourcenMachine Learning-Ressourcen stehen für Cloud-geschulte Inferenzmodelle, die in einer AWS IoTGreengrass-Core bereitgestellt werden. Zur Bereitstellung von Machine Learning-Ressourcen fügen Siedie Ressourcen zuerst einer Greengrass-Gruppe hinzu und definieren dann, wie Lambda-Funktionen inder Gruppe auf diese zugreifen können. Während der Gruppenbereitstellung ruft AWS IoT Greengrass dieQuellmodellpakete aus der Cloud ab und extrahiert diese in Verzeichnisse innerhalb des Lambda-Laufzeit-Namespace. Anschließend verwenden Greengrass-Lambda-Funktionen die lokal bereitgestellten Modellefür die Durchführung der Inferenz.

Um ein lokal bereitgestelltes Modell zu aktualisieren, aktualisieren Sie zuerst das Quellmodell (in derCloud), das mit der Machine Learning-Ressource übereinstimmt, und stellen Sie dann die Gruppe bereit.Während der Bereitstellung überprüft AWS IoT Greengrass die Quelle auf Änderungen. Wenn Änderungenerkannt werden, dann aktualisiert AWS IoT Greengrass das lokale Modell.

Unterstützte ModellquellenAWS IoT Greengrass unterstützt Amazon SageMaker und Amazon S3-Quellmodelle für Machine Learning-Ressourcen.

Die folgenden Anforderungen gelten für Modellquellen:

• S3-Buckets, die Ihre Amazon SageMaker- und Amazon S3-Modellquellen speichern, dürfen nicht mitSSE-C verschlüsselt werden. Bei Buckets mit serverseitiger Verschlüsselung unterstützt die AWS IoTGreengrass ML-Inferenz derzeit nur die SSE-S3- oder SSE-KMS-Verschlüsselungsoptionen. WeitereInformationen zur serverseitigen Verschlüsselung finden Sie unter Schutz von Daten durch serverseitigeVerschlüsselung im Entwicklerhandbuch für Amazon Simple Storage Service.

• Die Namen von S3-Buckets, die Ihre Amazon SageMaker- und Amazon S3-Modellquellen speichern,dürfen keine Punkte („.“) enthalten. Weitere Informationen finden Sie in der Regel über die Verwendungvon virtuell gehosteten Buckets mit SSL unter Regeln für die Bucket-Benennung im Entwicklerhandbuchfür Amazon Simple Storage Service.

• AWS-Regions-Unterstützung auf Service-Level muss sowohl für AWS IoT Greengrass als auch fürAmazon SageMaker verfügbar sein. Siehe die folgende Tabelle.

AWS-Region Amazon SageMaker-Modelle Amazon S3-Modelle

USA Ost (Ohio)

USA Ost (Nord-Virginia)

USA West (Oregon)

Asien-Pazifik (Mumbai)

Asien-Pazifik (Seoul)

Asien-Pazifik (Singapur)

Asien-Pazifik (Sydney)

Asien-Pazifik (Tokio)

228

https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules


https://docs.aws.amazon.com/general/latest/gr/rande.html#sagemaker_region

AWS IoT Greengrass EntwicklerhandbuchUnterstützte Modellquellen

AWS-Region Amazon SageMaker-Modelle Amazon S3-Modelle

EU (Frankfurt)

EU (Irland)

EU (London)

• AWS IoT Greengrass muss über read-Berechtigungen für die Modellquelle, wie in den folgendenAbschnitten beschrieben, verfügen.

Amazon SageMaker

AWS IoT Greengrass unterstützt Modelle, die als Amazon SageMaker-Schulungsaufträge gespeichertwerden.

Wenn Sie Ihre Amazon SageMaker-Umgebung durch Erstellen eines Buckets konfigurieren,dessen Name sagemaker enthält, dann verfügt AWS IoT Greengrass über ausreichendeBerechtigungen für den Zugriff auf Ihre Amazon SageMaker-Schulungsaufträge. Die verwalteteRichtlinie AWSGreengrassResourceAccessRolePolicy erlaubt den Zugriff auf Buckets, derenName die Zeichenfolge sagemaker enthält. Diese Richtlinie ist der Greengrass-Service-Rolleangefügt.

Andernfalls müssen Sie AWS IoT Greengrass die read-Berechtigung für den Bucket gewähren, indem Ihr Schulungsauftrag gespeichert ist. Betten Sie zu diesem Zweck die folgende eingebundeneRichtlinie in die Greengrass-Service-Rolle ein. Sie können mehrere Bucket-ARNs in einer Listeanzeigen.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] } ]}

Amazon SageMaker ist ein vollständig verwalteter ML-Service, mit dem Sie Modelle mit vordefiniertenoder benutzerdefinierten Algorithmen erstellen und schulen können. Weitere Informationen finden Sieunter Was ist Amazon SageMaker? im Amazon SageMaker Entwicklerhandbuch.

Amazon S3

AWS IoT Greengrass unterstützt Modelle, die in Amazon S3 als tar.gz- oder .zip-Dateiengespeichert werden.

Um AWS IoT Greengrass den Zugriff auf Modelle zu erlauben, die in Amazon S3-Buckets gespeichertsind, müssen Sie AWS IoT Greengrass die read-Berechtigung für den Zugriff auf die Bucketsgewähren, indem Sie einen der folgenden Schritte ausführen:• Speichern Sie Ihr Modell in einem Bucket, dessen Name greengrass enthält.

229

https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html

https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html


Die verwaltete Richtlinie AWSGreengrassResourceAccessRolePolicy erlaubt den Zugriff aufBuckets, deren Name die Zeichenfolge greengrass enthält. Diese Richtlinie ist der Greengrass-Service-Rolle angefügt.

• Betten Sie eine eingebundene Richtlinie in die Greengrass-Service-Rolle ein.

Wenn Ihr Bucket-Name nicht greengrass enthält, fügen Sie die folgende eingebundene Richtliniender Service-Rolle hinzu. Sie können mehrere Bucket-ARNs in einer Liste anzeigen.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::my-bucket-name" ] } ]}

Weitere Informationen finden Sie unter Embedding Inline Policies im IAM-Benutzerhandbuch.

VoraussetzungenDie folgenden Anforderungen gelten für die Erstellung und Verwendung von Machine Learning-Ressourcen:

• Sie müssen AWS IoT Greengrass Core v1.6 or later verwenden.• Lambda-Funktionen können auf der Ressource read- oder read and write-Operationen ausführen.

Berechtigungen für andere Operationen sind nicht verfügbar.• Lambda-Funktionen, die mit Zugriff auf ML-Modell-Ressourcen konfiguriert sind, können nicht in einem

nicht-containerisierten Modus ausgeführt werden.• Sie müssen den vollständigen Pfad der Ressource im Betriebssystem des Core-Geräts bereitstellen.• Der Name oder die ID einer Ressource kann maximal 128 Zeichen umfassen und muss dem Muster [a-zA-Z0-9:_-]+ entsprechen.

Laufzeiten und vorkompilierte Framework-Bibliotheken für ML-Inferenz

Zum schnellen Einstieg in das Experimentieren mit ML-Inferenz bietet AWS IoT Greengrass Laufzeiten undvorkompilierte Framework-Bibliotheken.

• Amazon SageMaker Neo Deep Learning Runtime (p. 231) (Lizenzvereinbarung für die GreengrassCore-Software)

• Apache MXNet (Apache License 2.0)• TensorFlow (Apache License 2.0)

230

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console



https://aws.amazon.com/mxnet/

https://aws.amazon.com/tensorflow/

AWS IoT Greengrass EntwicklerhandbuchAmazon SageMaker Neo Deep Learning Runtime

• Chainer (MIT License)

Diese Laufzeiten und vorkompilierten Bibliotheken können auf den Plattformen NVIDIA Jetson TX2, IntelAtom und Raspberry Pi installiert werden. Die Laufzeiten und Bibliotheken sind auf der Seite AWS IoTGreengrass Machine Learning-Laufzeiten und vorkompilierte Bibliotheken (p. 21)-Downloads verfügbar. Siekönnen sie direkt in Ihrem Core installieren oder als Teil der Software in Ihrer Greengrass-Gruppe nutzen.

Lesen Sie die folgenden Informationen zu Kompatibilität und Einschränkungen.

Amazon SageMaker Neo Deep Learning RuntimeMit Amazon SageMaker Neo Deep Learning Runtime können Sie Inferenzen mit optimierten MachineLearning-Modellen auf Ihren AWS IoT Greengrass-Geräten durchführen. Diese Modelle sind mithilfeder Amazon SageMaker Neo Deep Learning Compiler optimiert, um die Machine Learning-Inferenz-Voraussage zu verbessern. Weitere Informationen zur Modelloptimierung in Amazon SageMaker finden Siein der Amazon SageMaker-Neo-Dokumentation.

Note

Derzeit können Sie Machine Learning-Modelle mithilfe von Neo Deep Learning Compiler nur inden AWS-Regionen USA West (Oregon), USA Ost (Nord-Virginia) und EU (Irland) optimieren. Siekönnen die Neo Deep Learning Runtime mit optimierten Modellen jedoch in allen AWS-Regionenverwenden, in denen AWS IoT Greengrass-Core unterstützt wird. Weitere Informationen findenSie unter So konfigurieren Sie Optimized Machine Learning-Inferenz (p. 252).

MXNet-VersioningApache MXNet stellt derzeit keine Aufwärtskompatibilität sicher, sodass Modelle, die Sie mit späterenVersionen des Frameworks schulen, möglicherweise in früheren Versionen des Frameworks nichtordnungsgemäß funktionieren. Verwenden Sie zur Vermeidung von Konflikten zwischen denModellschulungs- und Modellbereitstellungsstufen und für die Bereitstellung einer konsistenten End-to-End-Erfahrung in beiden Stufen dieselbe MXNet Framework Version.

MXNet auf Raspberry PiGreengrass Lambda-Funktionen, die auf lokale MXNet-Modelle zugreifen, müssen folgendeUmgebungsvariable festlegen:

MXNET_ENGINE_TYPE=NaiveEngine

Sie können die Umgebungsvariable im Funktionscode festlegen oder zur gruppenspezifischenKonfiguration der Funktion hinzufügen. Ein Bespiel, bei dem dieses im Rahmen derKonfigurationseinstellung hinzugefügt wird, finden Sie in diesem Schritt (p. 239).

Note

Bei einer allgemeinen Verwendung des MXNet-Frameworks, beispielsweise bei der Ausführungeines Code-Beispiels eines Drittanbieters, muss die Umgebungsvariable auf dem Raspberry Pikonfiguriert werden.

TensorFlow-Modellbereitstellungsbeschränkungen aufdem Raspberry PiDerzeit unterstützt das AWS IoT Greengrass TensorFlow-Installationsprogramm nur die Installation auf32-Bit-Laptop- oder Desktop-Betriebssystemen. Informationen, wie Sie TensorFlow auf 64-Bit-Plattformeneinrichten, finden Sie unter Installieren von TensorFlow in der TensorFlow-Dokumentation.

231

https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html

https://www.tensorflow.org/install/#installing_from_sources

AWS IoT Greengrass EntwicklerhandbuchSo konfigurieren Sie Machine Learning-Inferenz

Die folgenden Empfehlungen zur Verbesserung von Inferenzergebnissen basieren auf unseren Tests mitden 32-Bit-ARM-vorkompilierten Bibliotheken auf der Raspberry Pi-Plattform. Diese Empfehlungen sind fürerfahrene Benutzer nur zur Referenz ohne Gewährleistung jedweder Art bestimmt.

• Modelle, die mit dem Checkpoint-Format geschult werden, sollten vor der Bereitstellung imProtokollpufferformat "eingefroren" werden. Ein Beispiel finden Sie in der TensorFlow-Slim-Abbildklassifikations-Modellbibliothek.

• Verwenden Sie die TF-Estimator- und TF-Slim-Bibliotheken nicht in Schulungen oder Inferenzcodes.Stattdessen verwenden Sie das Modellbereitstellungsmuster der .pb-Datei wie im folgenden Beispielgezeigt.

graph = tf.Graph() graph_def = tf.GraphDef()graph_def.ParseFromString(pb_file.read()) with graph.as_default(): tf.import_graph_def(graph_def)

Note

Weitere Informationen zu unterstützten Plattformen für TensorFlow finden Sie unter Installierenvon TensorFlow in der TensorFlow-Dokumentation.

So konfigurieren Sie Machine Learning-Inferenz mitder AWS Management Console

Um die Schritte in diesem Tutorial ausführen zu können, müssen Sie AWS IoT Greengrass Core v1.6 orlater verwenden.

Sie können Machine Learning (ML)-Inferenz lokal auf einem Greengrass Core-Gerät mit Datenvon verbundenen Geräten durchführen. Weitere Informationen einschließlich Anforderungen undEinschränkungen finden Sie unter Durchführen von Machine Learning-Inferenzen (p. 227).

In diesem Tutorial wird beschrieben, wie Sie die AWS Management Console für die Konfiguration einerGreengrass-Gruppe verwenden, um eine Lambda-Inferenz-App auszuführen, die Kamerabilder lokalerkennt, ohne dass Daten in die Cloud gesendet werden. Die Inferenz-App greift auf das Kameramodul aufeinem Raspberry Pi zu und führt Inferenz mithilfe des Open Source SqueezeNet-Modells aus.


1. Konfigurieren des Raspberry Pi (p. 233).2. Installieren des MXNet Framework (p. 234).3. Erstellen eines Modellpakets (p. 235).4. Erstellen und Veröffentlichen einer Lambda-Funktion (p. 235).5. Hinzufügen der Lambda-Funktion zur Gruppe (p. 239).6. Hinzufügen von Ressourcen zur Gruppe (p. 241).7. Hinzufügen eines Abonnements zur Gruppe (p. 245).8. Bereitstellen der Gruppe (p. 247).


232

https://www.tensorflow.org/get_started/checkpoints

https://github.com/tensorflow/models/tree/master/research/slim

https://github.com/tensorflow/models/tree/master/research/slim



https://github.com/DeepScale/SqueezeNet

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren des Raspberry Pi

• Raspberry Pi 3 Modell B+ oder Modell B für die Verwendung mit AWS IoT Greengrass eingerichtet undkonfiguriert. Wie Sie Ihren Raspberry Pi mit AWS IoT Greengrass einrichten, erfahren Sie unter Modul 1und Modul 2 in Erste Schritte mit AWS IoT Greengrass (p. 69).

Note

Der Raspberry Pi erfordert möglicherweise ein 2,5 A-Netzgerät, um die Deep Learning-Frameworks auszuführen, die in der Regel für die Imageklassifizierung verwendet werden. EinNetzgerät mit geringerer Leistung könnte dazu führen, dass das Gerät neu gestartet wird.

• Raspberry Pi Kameramodul V2 – 8 Megapixel, 1080p. Weitere Informationen zum Einrichten der Kamerafinden Sie unter Verbinden der Kamera in der Raspberry Pi-Dokumentation.

• Eine Greengrass-Gruppe und ein Greengrass Core. Weitere Informationen zum Erstellen einerGreengrass-Gruppe oder eines Greengrass-Cores finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69).

Note

Dieses Tutorial verwendet ein Raspberry Pi, aber AWS IoT Greengrass unterstützt anderePlattformen, wie z. B. Intel Atom und NVIDIA Jetson TX2 (p. 251). Beim Jetson TX2-Beispielkönnen statische Bilder anstelle von Bildern verwendet werden, die von einer Kamera gestreamtwerden.

Schritt 1: Konfigurieren des Raspberry PiIn diesem Schritt installieren Sie Updates für das das Rasbian-Betriebssystem, installieren dieKameramodulsoftware und Python-Abhängigkeiten und aktivieren die Kameraschnittstelle. Führen Sie imRaspberry Pi-Terminal die folgenden Befehle aus.

1. Installieren von Updates für Raspbian.

sudo apt-get updatesudo apt-get dist-upgrade

2. Installieren Sie die Picamera-Schnittstelle für das Kameramodul und andere Python-Bibliotheken, diefür dieses Tutorial erforderlich sind.

sudo apt-get install -y python-dev python-setuptools python-pip python-picamera

3. Starten Sie den Raspberry Pi neu.

sudo reboot

4. Öffnen Sie das Raspberry Pi-Konfigurations-Tool.

sudo raspi-config

5. Verwenden Sie die Pfeiltasten zum Öffnen von Interfacing Options (Verbindungsoptionen) undaktivieren Sie die Kameraschnittstelle. Wenn Sie dazu aufgefordert werden, lassen Sie den Neustartdes Geräts zu.

6. Geben Sie den folgenden Befehl ein, um die Einrichtung der Kamera zu testen.

raspistill -v -o test.jpg

Dies öffnet ein Vorschaufenster auf dem Raspberry Pi, speichert ein Bild namens test.jpg in IhremVerzeichnis /home/pi und zeigt Informationen über die Kamera im Terminal des Raspberry Pi an.

233



https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html


https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/

https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS

https://www.raspberrypi.org/documentation/usage/camera/

AWS IoT Greengrass EntwicklerhandbuchInstallieren des MXNet Framework

Schritt 2: Installieren des MXNet FrameworkIn diesem Schritt laden Sie vorkompilierte Apache MXNet-Bibliotheken herunter und installieren sie aufIhrem Raspberry Pi.

Note

Dieses Tutorial verwendet Bibliotheken für das MXNet ML Framework, es stehen jedochauch Bibliotheken für TensorFlow zur Verfügung. Weitere Informationen, einschließlichEinschränkungen, finden Sie unter the section called “Laufzeiten und vorkompilierte Framework-Bibliotheken für ML-Inferenz” (p. 230).

1. Suchen Sie auf der Seite AWS IoT Greengrass Machine Learning-Laufzeiten und vorkompilierteBibliotheken (p. 21)-Downloads die MXNet-Version 1.2.1 für Raspberry Pi. Wählen Sie Herunterladenaus.

Note

Mit dem Herunterladen dieser Software erklären Sie sich mit den Bedingungen der Apache-Lizenz 2.0 einverstanden

2. Übertragen Sie die heruntergeladene Datei ggc-mxnet-v1.2.1-python-raspi.tar.gz vonIhrem Computer auf Ihren Raspberry Pi.

Note

Methoden, dies auf anderen Plattformen zu tun, finden Sie in diesem Schritt (p. 86) imAbschnitt Erste Schritte. Beispielsweise können Sie den folgenden scp-Befehl verwenden:

scp ggc-mxnet-v1.2.1-python-raspi.tar.gz pi@IP-address:/home/pi

3. Entpacken Sie die übertragene Datei in Ihrem Raspberry Pi-Terminal.

tar -xzf ggc-mxnet-v1.2.1-python-raspi.tar.gz

4. Installieren Sie das MXNet Framework.

cd ggc-mxnet-v1.2.1-python-raspi/./mxnet_installer.sh

Note

Sie können mit the section called “Erstellen eines Modellpakets” (p. 235) fortfahren,während das Framework installiert wird, aber Sie müssen warten, bis die Installationabgeschlossen ist, bevor Sie mit the section called “Erstellen und Veröffentlichen einerLambda-Funktion” (p. 235) fortfahren.Sie haben auch die Möglichkeit, Komponententests auszuführen, um die Installationzu überprüfen. Fügen Sie dazu die Option -u dem vorherigen Befehl hinzu. Bei Erfolgprotokolliert jeder Test eine Zeile im Terminal, die mit ok endet. Wenn alle Tests erfolgreichsind, enthält die endgültige Protokollanweisung OK. Beachten Sie, dass durch die Ausführungvon Komponententests die Installationsdauer verlängert wird.

Das Skript erstellt außerdem ein Bereitstellungspaket für die Lambda-Funktion mit dem NamengreengrassObjectClassification.zip, das den Funktionscode und die Abhängigkeiten enthält.Sie laden dieses Bereitstellungspaket zu einem späteren Zeitpunkt hoch.

5. Wenn Ihre Installation abgeschlossen ist, übertragen SiegreengrassObjectClassification.zip auf Ihren Computer. Abhängig von Ihrer Umgebungkönnen Sie den scp-Befehl oder ein Dienstprogramm wie WinSCP verwenden.

234



https://winscp.net/eng/download.php

AWS IoT Greengrass EntwicklerhandbuchErstellen eines Modellpakets

Schritt 3: Erstellen eines MXNet-ModellpaketsIn diesem Schritt laden Sie Dateien für eine Stichprobe pretrained MXNet Modell, und speichern Sie sie alseine .zip-Datei. AWS IoT Greengrass kann Modelle aus Amazon S3 verwenden, sofern diese das Formattar.gz oder .zip verwenden.

1. Laden Sie die folgenden Dateien auf Ihren Computer herunter:

• squeezenet_v1.1-0000.params. Eine Parameterdatei, in der die Gewichtungen der Verbindungbeschrieben werden.

• squeezenet_v1.1-symbol.json. Ein Symboldatei, in der die neuronale Netzwerkstruktur beschriebenwird.

• synset.txt. Eine Synset-Datei, die anerkannte Klassen-IDs den lesbaren Klassennamen zuweist.

Note

Alle MXNet-Modellpakete nutzen diese drei Dateitypen, aber der Inhalt von TensorFlow-Modellpaketen variiert.

2. Komprimieren Sie die drei Dateien und nennen Sie die komprimierte Datei squeezenet.zip. Sieladen dieses Modellpaket auf Amazon S3 in the section called “Hinzufügen von Ressourcen zurGruppe” (p. 241) hoch.

Schritt 4: Erstellen und Veröffentlichen einer Lambda-FunktionIn diesem Schritt erstellen Sie eine Lambda-Funktion und konfigurieren diese zur Verwendung desBereitstellungspakets. Anschließend veröffentlichen Sie eine Funktionsversion und erstellen einen Alias.

Der Name des Lambda-Funktionsbereitstellungspakets ist greengrassObjectClassification.zip.Dies ist die zip-Datei, die während der Installation des MXNet-Frameworks in Schritt 2: Installieren desMXNet Framework (p. 234) generiert wurde. Es enthält eine Inferenz-App, die allgemeine Aufgabenwie das Laden von Modellen, das Importieren von Apache MXNet und das Durchführen von Aktionenbasierend auf Voraussagen ausführt. Die App enthält die folgenden Schlüsselkomponenten:

• App-Logik:• load_model.py. Lädt MXNet-Modelle.• greengrassObjectClassification.py. Führt Prognosen auf Bilder aus, die von der Kamera gestreamt

werden.• Abhängigkeiten:

• greengrasssdk. Das AWS IoT GreengrassCore-SDK für Python, das von der Funktion zumVeröffentlichen von MQTT-Nachrichten verwendet wird.

Note

Die mxnet-Bibliothek wurde während der Installation des MXNet-Frameworks auf dem Core-Gerät installiert.

Zunächst erstellen Sie die Lambda-Funktion.

1. Wählen Sie in AWS IoT-Konsole im Navigationsbereich Greengrass und dann Groups (Gruppen).

235

https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/squeezenet_v1.1-0000.params

https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/squeezenet_v1.1-symbol.json

https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt



4. Fügen Sie Ihrer Seite „Greengrass-Gruppe“ ein Lambda hinzu und wählen Sie Create new Lambda.Daraufhin wird die AWS Lambda-Konsole geöffnet.

236


5. Wählen Sie Author from scratch und verwenden Sie die folgenden Werte zum Erstellen der Funktion:

• Geben Sie in Function name (Funktionsname) greengrassObjectClassification ein.• Wählen Sie für Runtime die Option Python 2.7 aus.

Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eineAusführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nichtvon AWS IoT Greengrass verwendet.


Laden Sie nun das Bereitstellungspaket für die Lambda-Funktion hoch und registrieren Sie denHandler.

7. Geben Sie in der Registerkarte Configuration (Konfiguration) für die FunktiongreengrassObjectClassification unter Function code (Funktionscode) folgende Werte an:


• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie in Handler (Handler) greengrassObjectClassification.function_handler ein.


237


9. Wählen Sie das Bereitstellungspaket greengrassObjectClassification.zip aus.10. Wählen Sie Save aus.

Als Nächstes veröffentlichen Sie die erste Version der Lambda-Funktion. Anschließend erstellen Sieeinen Alias für die Version.

Note


11. Wählen Sie im Menü Actions die Option Publish new version aus.


13. Wählen Sie auf der Konfigurationsseite für greengrassObjectClassification: 1 im Menü Aktionen dieOption Create alias (Alias erstellen) aus.

14. Geben Sie auf der Seite Create a new alias (Neuen Alias erstellen) folgende Werte an:

• Geben Sie in Name (Name) mlTest ein.• Geben Sie in Version (Version) 1 ein.

Note


238



Fügen Sie nun die Lambda-Funktion zur Greengrass-Gruppe hinzu.

Schritt 5: Hinzufügen der Lambda-Funktion zurGreengrass-GruppeIn diesem Schritt fügen Sie die Lambda-Funktion der Gruppe hinzu und konfigurieren dann denLebenszyklus und die Umgebungsvariablen.


1. Öffnen Sie in der AWS IoT-Konsole die Gruppenkonfigurationsseite.2. Wählen Sie Lambdas und dann Add Lambda.


239


4. Wählen Sie greengrassObjectClassification und dann Next.5. Wählen Sie auf der Seite Select a Lambda version (Auswählen einer Lambda-Version) Alias:mlTest

und dann Finish aus.

Konfigurieren Sie dann den Lebenszyklus und die Umgebungsvariablen der Lambda-Funktion.6. Wählen Sie auf der Seite Lambdas die Funktion greengrassObjectClassification Lambda.

7. Wählen Sie auf der Konfigurationsseite für greengrassObjectClassification die Option Edit (Bearbeiten)aus.

8. Geben Sie auf der Seite Group-specific Lambda configuration folgende Werte an:

• Geben Sie in Memory Limit (Speicherlimit) 96 MB ein.• Geben Sie in Timeout (Zeitüberschreitung) 10 seconds ein.• Wählen Sie in Lambda lifecycle (IAM-Lebenszklus) die Option Make this function long-lived and keep

it running indefinitely (Diese Funktion dauerhaft festlegen und unbegrenzt ausführen).• Wählen Sie in Read access to /sys directory (Lesezugriff auf /sys-Verzeichnis) die Option Enable

(Aktivieren) aus.

Weitere Informationen finden Sie unter the section called “Lebenszykluskonfiguration” (p. 189).

240

AWS IoT Greengrass EntwicklerhandbuchHinzufügen von Ressourcen zur Gruppe

9. Erstellen Sie in Environment variables (Umgebungsvariablen) ein Schlüssel-Wert-Paar. Ein Schlüssel-Wert-Paar ist für Funktionen erforderlich, die mit MXNet-Modellen auf einem Raspberry PI interagieren.

Verwenden Sie als Schlüssel MXNET_ENGINE_TYPE. Verwenden Sie als Wert „NaiveEngine“.

Note

Für eigene benutzerdefinierte Lambda-Funktionen können Sie die Umgebungsvariableoptional im Funktionscode festlegen.

10. Übernehmen Sie die Standardwerte für alle anderen Eigenschaften und wählen Sie Update(Aktualisieren).

Schritt 6: Hinzufügen von Ressourcen zur Greengrass-GruppeIn diesem Schritt erstellen Sie Ressourcen für das Kameramodul und das ML-Inferenz-Modell. Sie könnenauch die Ressourcen der Lambda-Funktion zuordnen, wodurch der Funktion der Zugriff auf die Ressourcenauf dem Core-Gerät ermöglicht wird.

Erstellen Sie zunächst zwei lokale Geräteressourcen für die Kamera: eine für den gemeinsam genutztenSpeicher und eine für die Geräteschnittstelle. Weitere Informationen zum Zugriff auf lokale Ressourcenfinden Sie unter Zugriff auf lokale Ressourcen mit Lambda-Funktionen und Konnektoren (p. 204).


241


2. Wählen Sie in der Registerkarte Local (Lokal) Add a local resource (Eine lokale Ressourcehinzufügen).

3. Geben Sie auf der Seite Create a local resource (Lokale Ressource erstellen) folgende Werte an:

• Geben Sie in Resource name (Ressourcenname) videoCoreSharedMemory ein.• Wählen Sie in Resource type (Ressourcentyp) die Option Device (Gerät) aus.• Geben Sie in Device Pfad (Gerätepfad) /dev/vcsm ein.

Der Gerätepfad ist der lokale absolute Pfad der Geräteressource. Dieser Pfad kann nur auf einzeichenorientiertes Gerät oder ein Blockgerät unter /dev verweisen.

• Wählen Sie für Group owner file access permission (Dateizugriffsberechtigung desGruppenbesitzers) die Option Automatically add OS group permissions of the Linux group that ownsthe resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppe hinzufügen, zuder die Ressource gehört) aus.

Mit der Option Group owner file access permission können Sie zusätzlicheDateizugriffsberechtigungen für den Lambda-Prozess erteilen. Weitere Informationen finden Sieunter Dateizugriffsberechtigungen des Gruppenbesitzers (p. 206).

242



5. Wählen Sie greengrassObjectClassification, Read and write access (Lese- und Schreibzugriff) unddann Done (Fertig) aus.

Als nächstes fügen Sie eine lokale Geräteressource für die Kameraschnittstelle hinzu.6. Wählen Sie Add another resource (Eine weitere Ressource hinzufügen).7. Geben Sie auf der Seite Create a local resource (Lokale Ressource erstellen) folgende Werte an:

• Geben Sie in Resource name (Ressourcenname) videoCoreInterface ein.• Wählen Sie in Resource type (Ressourcentyp) die Option Device (Gerät) aus.• Geben Sie in Device Pfad (Gerätepfad) /dev/vchiq ein.• Wählen Sie für Group owner file access permission (Dateizugriffsberechtigung des

Gruppenbesitzers) die Option Automatically add OS group permissions of the Linux group that ownsthe resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppe hinzufügen, zuder die Ressource gehört) aus.

243



9. Wählen Sie greengrassObjectClassification, Read and write access (Lese- und Schreibzugriff) unddann Done (Fertig) aus.

10. Wählen Sie unten auf der Seite Save aus.

Fügen Sie nun das Inferenz-Modell als Machine Learning-Ressource hinzu. Dieser Schritt umfasst dasHochladen des squeezenet.zip-Modellpakets in Amazon S3.

1. Wählen Sie auf der Seite Resources (Ressourcen) für Ihre Gruppe die Option Machine Learning undanschließend Add a machine learning resource (Machine Learning-Ressource hinzufügen).

2. Geben Sie auf der Seite Create a machine learning resource (Eine Ressource für maschinelles Lernenerstellen) für Resource name (Ressourcenname) squeezenet_model ein.

3. Wählen Sie für Model Source (Modellquelle) die Option Upload a model in S3 (Ein Modell in S3hochladen) aus.

4. Wählen Sie unter Model from S3 (Modell aus S3) die Option Select (Auswählen).

244

AWS IoT Greengrass EntwicklerhandbuchHinzufügen eines Abonnements zur Gruppe

5. Wählen Sie Upload a model (Ein Modell hochladen). Auf diese Weise wird eine neue Registerkarte inder Amazon S3-Konsole geöffnet.

6. Laden Sie auf der Registerkarte der Amazon S3-Konsole die Datei squeezenet.zip in einenAmazon S3-Bucket hoch. Weitere Informationen finden Sie unter Wie lade ich Dateien und Ordner ineinen S3-Bucket hoch?

Note

Um den Zugriff auf den Bucket-Namen zu ermöglichen, muss der Bucket-Name dieZeichenfolge greengrass enthalten. Wählen Sie einen eindeutigen Namen (wie z. B.:greengrass-bucket-user-id-epoch-time). Verwenden Sie keinen Punkt (.) imBucket-Namen.

7. Suchen Sie in der Registerkarte der AWS IoT Greengrass-Konsole Ihren Amazon S3-Bucket undwählen Sie ihn aus. Suchen Sie Ihre hochgeladene Datei squeezenet.zip und wählen Sie Select(Auswählen). Möglicherweise müssen Sie die Refresh (Aktualisieren) wählen, um die Liste derverfügbaren Buckets und Dateien zu aktualisieren.

8. Geben Sie für Local Path (Lokaler Pfad) /greengrass-machine-learning/mxnet/squeezenetein.

Dies ist das Ziel für das lokale Modell im Lambda-Laufzeit-Namespace. Wenn Sie die Gruppebereitstellen, ruft AWS IoT Greengrass das Quellmodellpaket ab und extrahiert dann den Inhalt in dasangegebene Verzeichnis. Die Beispiel-Lambda-Funktion für dieses Tutorial ist bereits so konfiguriert,dass sie diesen Pfad (in der model_path-Variable) verwendet.


10. Wählen Sie greengrassObjectClassification, Read-only access (Schreibgeschützter Zugriff) und dannDone (Fertig) aus.

11. Wählen Sie Save aus.

Verwenden von Amazon SageMaker-geschulten ModellenDieses Tutorial verwendet ein Modell, das in Amazon S3 gespeichert ist, aber Sie können auch einfachAmazon SageMaker-Modelle nutzen. Die AWS IoT Greengrass-Konsole bietet eine integrierte AmazonSageMaker-Integration, sodass Sie diese Modelle nicht manuell in Amazon S3 hochladen müssen.Anforderungen und Einschränkungen für die Nutzung von Amazon SageMaker-Modellen siehe the sectioncalled “Unterstützte Modellquellen” (p. 228).

So verwenden Sie ein Amazon SageMaker-Modell:

• Klicken Sie für Model source (Modellquelle) auf die Option Use an existing SageMaker model (Einvorhandenes SageMaker-Modell verwenden) und wählen Sie dann den Namen des Schulungsauftragsdes Modells aus.

• Für Local path (Lokaler Pfad) geben Sie den Pfad zum Verzeichnis ein, in dem Ihre Lambda-Funktionnach dem Modell sucht.

Schritt 7: Hinzufügen eines Abonnements zurGreengrass-GruppeIn diesem Schritt fügen Sie der Gruppe ein Abonnement hinzu. Dieses Abonnement ermöglicht derLambda-Funktion Prognoseergebnisse durch Veröffentlichung in einem MQTT-Thema an AWS IoT zusenden.

245

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html


AWS IoT Greengrass EntwicklerhandbuchHinzufügen eines Abonnements zur Gruppe



a. Wählen Sie unter Select a source (Eine Quelle auswählen) die Option Lambdas und danngreengrassObjectClassification aus.

b. Wählen Sie unter Select a target (Ein Ziel auswählen) die Option Services und dann IoT Cloudaus.

c. Wählen Sie Next.

3. Geben Sie auf der Seite Filter your data with a topic (Filtern Sie Ihre Daten nach einem Thema.) inTopic filter (Themenfilter) hello/world ein und wählen Sie dann Next (Weiter).

4. Wählen Sie Finish.

246


Schritt 8: Bereitstellen der Greengrass-GruppeIn diesem Schritt stellen Sie die aktuelle Version der Gruppendefinition für das Greengrass-Core-Gerätbereit. Die Definition enthält die Lambda-Funktion, Ressourcen und Abonnementkonfigurationen, die Siehinzugefügt haben.





Note




2. Klicken Sie auf der Gruppenkonfigurationsseite auf Deployments (Bereitstellungen) und wählen Sie imMenü Aktionen die Option Bereitstellen aus.



247

AWS IoT Greengrass EntwicklerhandbuchTesten der Anwendung

Note


Auf der Seite Deployments werden der Zeitstempel, die Versions-ID und der Status der Bereitstellungangegeben. Nach abgeschlossener Bereitstellung sollte der Status Successfully completed (Erfolgreichabgeschlossen) lauten.


Testen der InferenzanwendungNun können Sie prüfen, ob die Bereitstellung korrekt konfiguriert ist. Abonnieren Sie zum Testen dasThema hello/world und zeigen Sie die Prognoseergebnisse an, die von der Lambda-Funktionveröffentlicht werden.

Note

Wenn ein Bildschirm mit dem Raspberry Pi verbunden ist, wird das Livebild der Kamera in einemVorschaufenster angezeigt.

1. Wählen Sie in der AWS IoT-Konsole Test aus.

248


2. Verwenden Sie für Subscriptions (Abonnements) die folgenden Werte:

• Verwenden Sie als Abonnementthema „hello/world“.• Wählen Sie in MQTT payload display (MQTT-Nutzlastanzeige) die Option Display payloads as

strings (Nutzlasten als Zeichenfolgen anzeigen) aus.3. Wählen Sie Subscribe to topic.

Wenn der Test erfolgreich ist, werden die Nachrichten von der Lambda-Funktion unten auf der Seiteangezeigt. Jede Nachricht enthält die ersten fünf der gesamten Prognoseergebnisse des Abbildes imFormat: Wahrscheinlichkeit, prognostizierte Klassen-ID und zugehöriger Klassenname.

249


Fehlerbehebung bei AWS IoT Greengrass-ML-InferenzWenn der Test nicht erfolgreich ist, können Sie folgende Schritte ausführen, um den Fehler zu beheben.Führen Sie im Raspberry Pi-Terminal die Befehle aus.

Fehlerprotokolle prüfen

1. Wechseln Sie zum Root-Benutzer und navigieren Sie zum Verzeichnis log. Der Zugriff auf AWS IoTGreengrass-Protokolle erfordert Root-Berechtigungen.


2. Prüfen Sie runtime.log oder python_runtime.log.

Weitere Informationen finden Sie unter the section called “Fehlerbehebung mit Protokollen” (p. 514).

Fehler beim Entpacken in „runtime.log“

Wenn runtime.log einen Fehler enthält, der wie folgt aussieht, stellen Sie sicher, dass Ihr tar.gz-Quellmodellpaket über ein übergeordnetes Verzeichnis verfügt.

Greengrass deployment error: unable to download the artifact model-arn: Error while processing. Error while unpacking the file from /tmp/greengrass/artifacts/model-arn/path to /greengrass/ggc/deployment/path/model-arn,error: open /greengrass/ggc/deployment/path/model-arn/squeezenet/squeezenet_v1.1-0000.params: no such file or directory

Wenn Ihr Paket über kein übergeordnetes Verzeichnis verfügt, das die Modelldateien enthält, verwendenSie den folgenden Befehl, um das Modell erneut zu verpacken:

tar -zcvf model.tar.gz ./model

Zum Beispiel:

#$ tar -zcvf test.tar.gz ./test./test./test/some.file./test/some.file2./test/some.file3

Note

Verwenden Sie keine abschließenden /*-Zeichen in diesem Befehl.

Stellen Sie sicher, dass die Lambda-Funktion erfolgreich bereitgestellt wird

1. Listen Sie den Inhalt der bereitgestellten Lambda im /lambda-Verzeichnis auf. Ersetzen Sie diePlatzhalterwerte, bevor Sie den Befehl ausführen.

cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-versionls -la

250

AWS IoT Greengrass EntwicklerhandbuchNächste Schritte

2. Überprüfen Sie, ob das Verzeichnis denselben Inhalt wie dasgreengrassObjectClassification.zip-Bereitstellungspaket enthält, das Sie in Schritt 4:Erstellen und Veröffentlichen einer Lambda-Funktion (p. 235) hochgeladen haben.

Stellen Sie sicher, dass sich die .py-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.

Stellen Sie sicher, dass das Inferenzmodell erfolgreich bereitgestellt wird

1. Finden Sie die Prozessidentifikationsnummer (PID) des Lambda-Laufzeitprozesses:

ps aux | grep lambda-function-name

In der Ausgabe wird die PID in der zweiten Spalte der Zeile für den Lambda-Laufzeitprozessangezeigt.

2. Geben Sie den Lambda-Laufzeit-Namespace ein. Stellen Sie sicher, den pid-Wert des Platzhalters zuersetzen, bevor Sie den Befehl ausführen.

Note

Dieses Verzeichnis und sein Inhalt befinden sich im Lambda-Laufzeit-Namespace, daher sindsie nicht in einem regulären Linux-Namespace sichtbar.

sudo nsenter -t pid -m /bin/bash

3. Listen Sie den Inhalt des lokalen Verzeichnisses, das Sie für die ML-Ressource angegeben haben,auf.

cd /greengrass-machine-learning/mxnet/squeezenet/ls -ls

Die Dateien sollten folgendermaßen aussehen:

32 -rw-r--r-- 1 ggc_user ggc_group 31675 Nov 18 15:19 synset.txt32 -rw-r--r-- 1 ggc_user ggc_group 28707 Nov 18 15:19 squeezenet_v1.1-symbol.json4832 -rw-r--r-- 1 ggc_user ggc_group 4945062 Nov 18 15:19 squeezenet_v1.1-0000.params

Nächste SchritteErkunden Sie dann weitere Inferenz-Apps. AWS IoT Greengrass bietet weitere Lambda-Funktionen, mitdenen Sie lokale Inferenz ausprobieren können. Sie finden das Beispielpaket im Ordner der vorkompiliertenBibliotheken, den Sie unter the section called “Installieren des MXNet Framework” (p. 234)heruntergeladen haben.

Konfigurieren eines NVIDIA Jetson TX2Zum Ausführen dieses Tutorials auf einem NVIDIA Jetson TX2 stellen Sie Quellbilder bereit undkonfigurieren die Lambda-Funktion. Bei Verwendung der GPU müssen Sie zusätzlich lokaleGeräteressourcen hinzufügen.

Weitere Informationen darüber, wie Sie Ihr Jetson-Gerät konfigurieren, damit die AWS IoT GreengrassCore-Software installiert werden kann, finden Sie unter the section called “Einrichten andererGeräte” (p. 80).

251

AWS IoT Greengrass EntwicklerhandbuchSo konfigurieren Sie Optimized Machine Learning-Inferenz

1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion für die Bildklassifizierung herunter.Die App funktioniert am besten mit kleinen Bilddateien. Alternativ können Sie eine Kamera auf derJetson-Karte instrumentieren, um die Quellbilder zu erfassen.

Speichern Sie Ihre Bilddateien in dem Verzeichnis mit dergreengrassObjectClassification.py-Datei (oder in einem Unterverzeichnis diesesVerzeichnisses). Dies ist im Bereitstellungspaket der Lambda-Funktion enthalten, das Sie in thesection called “Erstellen und Veröffentlichen einer Lambda-Funktion” (p. 235) hochgeladen haben.

2. Bearbeiten Sie die Konfiguration der Lambda-Funktion, um den Wert für das Memory limit(Speicherlimit) zu erhöhen. Verwenden Sie 500 MB für die CPU oder 2048 MB für die GPU. Folgen Siedem Verfahren unter the section called “Hinzufügen der Lambda-Funktion zur Gruppe” (p. 239).

3. Nur GPU: Fügen Sie die folgenden lokalen Geräteressourcen hinzu. Folgen Sie dem Verfahren unterthe section called “Hinzufügen von Ressourcen zur Gruppe” (p. 241).

Für jede Ressource:

• Wählen Sie in Resource type (Ressourcentyp) die Option Device (Gerät) aus.• Wählen Sie für Group owner file access permission (Dateizugriffsberechtigung des


• Erteilen Sie für Lambda function affiliationst Read and write access für Ihre Lambda-Funktion.

Name Gerätepfad

nvhost-strg /dev/nvhost-strg

nvhost-gpu /dev/nvhost-gpu

nvhost-strg-gpu /dev/nvhost-strg-gpu

nvhost-dbg-gpu /dev/nvhost-dbg-gpu

nvhost-prof-gpu /dev/nvhost-prof-gpu

nvmap /dev/nvmap

So konfigurieren Sie Optimized Machine Learning-Inferenz mit der AWS Management Console

Um die Schritte in diesem Tutorial ausführen zu können, müssen Sie AWS IoT Greengrass Core v1.6 orlater verwenden.

Sie können den Amazon SageMaker Neo Deep Learning Compiler zur Optimierung der Effizienz dieVorhersage von nativen Machine-Learning-Inferenz-Modellen in vielen Frameworks verwenden. Siekönnen dann das optimierte Modell herunterladen und die Amazon SageMaker Neo Deep LearningRuntime installieren und auf Ihren AWS IoT Greengrass-Geräten für eine schnellere Inferenz einsetzen.

In diesem Tutorial wird beschrieben, wie Sie die AWS Management Console für die Konfiguration einerGreengrass-Gruppe verwenden, um eine Lambda-Beispiel-Inferenz auszuführen, die Kamerabilder lokalerkennt, ohne dass Daten in die Cloud gesendet werden. Das Inferenzbeispiel greift auf das Kameramodulauf einem Raspberry Pi zu. In diesem Tutorial laden Sie ein vorkonfiguriertes Modell herunter, das von

252


Resnet-50 trainiert und im Neo Deep Learning Compiler optimiert wird. Anschließend führen Sie mit demModell eine lokale Bildklassifikation auf Ihrem AWS IoT Greengrass-Gerät durch.


1. Konfigurieren des Raspberry Pi (p. 253).2. Installieren der Amazon SageMaker Neo Deep Learning Runtime (p. 254)3. Erstellen Sie eine Inferenz-Lambda-Funktion (p. 255).4. Hinzufügen der Lambda-Funktion zur Gruppe (p. 259).5. Fügen Sie die Amazon SageMaker Neo-optimierte Modellressource der Gruppe hinzu (p. 260).6. Fügen Sie die Ressourcen der Kamera zur Gruppe hinzu (p. 261).7. Fügen Sie Abonnements zur Gruppe hinzu (p. 264)8. Bereitstellen der Gruppe (p. 265).


• Raspberry Pi 3 Modell B+ oder Modell B für die Verwendung mit AWS IoT Greengrass eingerichtet undkonfiguriert. Wie Sie Ihren Raspberry Pi mit AWS IoT Greengrass einrichten, erfahren Sie unter Modul 1und Modul 2 in Erste Schritte mit AWS IoT Greengrass (p. 69).

Note

Der Raspberry Pi erfordert möglicherweise ein 2,5 A-Netzgerät, um die Deep Learning-Frameworks auszuführen, die in der Regel für die Imageklassifizierung verwendet werden. EinNetzgerät mit geringerer Leistung könnte dazu führen, dass das Gerät neu gestartet wird.

• Raspberry Pi Kameramodul V2 – 8 Megapixel, 1080p. Weitere Informationen zum Einrichten der Kamerafinden Sie unter Verbinden der Kamera in der Raspberry Pi-Dokumentation.

• Eine Greengrass-Gruppe und ein Greengrass Core. Weitere Informationen zum Erstellen einerGreengrass-Gruppe oder eines Greengrass-Cores finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69).

Note

Dieses Tutorial verwendet ein Raspberry Pi, aber AWS IoT Greengrass unterstützt anderePlattformen, wie z. B. Intel Atom (p. 268) und NVIDIA Jetson TX2 (p. 269).

Schritt 1: Konfigurieren des Raspberry PiIn diesem Schritt installieren Sie Updates für das das Raspbian-Betriebssystem, installieren dieKameramodulsoftware und Python-Abhängigkeiten und aktivieren die Kameraschnittstelle.

Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus.

1. Installieren von Updates für Raspbian.

sudo apt-get updatesudo apt-get dist-upgrade

2. Installieren Sie die Picamera-Schnittstelle für das Kameramodul und andere Python-Bibliotheken, diefür dieses Tutorial erforderlich sind.

sudo apt-get install -y python-dev python-setuptools python-pip python-picamera

253





https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/

https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS

https://www.raspberrypi.org/documentation/usage/camera/

AWS IoT Greengrass EntwicklerhandbuchInstallieren der Neo Deep Learning Runtime

3. Starten Sie den Raspberry Pi neu.

sudo reboot

4. Öffnen Sie das Raspberry Pi-Konfigurations-Tool.

sudo raspi-config

5. Verwenden Sie die Pfeiltasten zum Öffnen von Interfacing Options (Verbindungsoptionen) undaktivieren Sie die Kameraschnittstelle. Wenn Sie dazu aufgefordert werden, lassen Sie den Neustartdes Geräts zu.

6. Geben Sie den folgenden Befehl ein, um die Einrichtung der Kamera zu testen.

raspistill -v -o test.jpg

So werden ein Vorschaufenster im Raspberry Pi geöffnet, ein Bild mit dem Namen test.jpg inIhrem aktuellen Verzeichnis gespeichert und Informationen über die Kamera im Raspberry Pi-Terminalangezeigt.

Schritt 2: Installieren der Amazon SageMaker NeoDeep Learning RuntimeIn diesem Schritt laden Sie die Neo Deep Learning Runtime herunter und installieren sie auf IhremRaspberry Pi.

1. Suchen Sie auf der Seite AWS IoT Greengrass Machine Learning-Laufzeiten und vorkompilierteBibliotheken (p. 21)-Downloads die Deep Learning Runtime Version 1.0.0 für Raspberry Pi. WählenSie Herunterladen aus.

2. Übertragen Sie die heruntergeladene Datei dlr-1.0-py2-armv7l.tar.gz von Ihrem Computer aufIhren Raspberry Pi. Sie können auch den folgenden Befehl scp mit einem Pfad zum Speichern IhrerDatei verwenden, z.B. /home/pi/:

scp dlr-1.0-py2-armv7l.tar.gz pi@your-device-ip-address:path-to-save-file

3. Verwenden Sie die folgenden Befehle, um sich remote an Ihrem Raspberry Pi anzumelden und dieInstallationsdateien zu entpacken.

ssh pi@your-device-ip-addresscd path-to-save-filetar -xvzf dlr-1.0-py2-armv7l.tar.gz

4. Installieren Sie die Neo Deep Learning Runtime.

cd dlr-1.0-py2-armv7l/chmod 755 install-dlr.shsudo ./install-dlr.sh

Dieses Paket enthält ein Verzeichnis examples, das mehrere Dateien enthält, die Sie zum Ausführendieses Tutorials verwenden. Dieses Verzeichnis enthält auch Version 1.2.0 des AWS IoT Greengrass-Core-SDK für Python. Sie können auch die neueste Version des SDKs von der Seite AWS IoTGreengrassCore-SDK (p. 21)-Downloads herunterladen.

254

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Lambda-Inferenzfunktion

Schritt 3: Erstellen einer Lambda-InferenzfunktionIn diesem Schritt erstellen Sie ein Bereitstellungspaket und eine Lambda-Funktion, die für die Verwendungdes Bereitstellungspakets konfiguriert ist. Anschließend veröffentlichen Sie eine Funktionsversion understellen einen Alias.

1. Entpacken Sie auf Ihrem Computer die heruntergeladene Datei dlr-1.0-py2-armv7l.tar.gz, dieSie zuvor auf Ihren Raspberry Pi kopiert haben.

cd path-to-downloaded-runtimetar -xvzf dlr-1.0-py2-armv7l.tar.gz

2. Das resultierende Verzeichnis dlr-1.0-py2-armv7l enthält einen examples-Ordner mit Dateien,einschließlich inference.py, dem Beispiel-Code, der in diesem Tutorial für Inferenz verwendetwird. Sie können diesen Code als Anwendungsbeispiel zum Erstellen Ihres eigenen Inferenz-Codeseinsehen.

Komprimieren Sie die Dateien im Ordner examples in eine Datei namensoptimizedImageClassification.zip.

Note

Wenn Sie die Zip-Datei erstellen, vergewissern Sie sich, dass sich die Datei .py files und dieAbhängigkeiten im Stammverzeichnis des Verzeichnisses befinden.

cd path-to-downloaded-runtime/dlr-1.0-py2-armv7l/exampleszip -r optimizedImageClassification.zip .

Diese .zip-Datei ist Ihr Bereitstellungspaket. Dieses Paket enthält den Funktionscode und dieAbhängigkeiten, einschließlich des Codebeispiels, das die Neo Deep Learning Runtime-Python-APIsaufruft, um die Inferenz mit den Neo Deep Learning Compiler-Modellen durchzuführen. Sie ladendieses Bereitstellungspaket zu einem späteren Zeitpunkt hoch.

3. Erstellen Sie jetzt die Lambda-Funktion.

Wählen Sie in AWS IoT-Konsole im Navigationsbereich Greengrass und dann Groups (Gruppen).

255



6. Fügen Sie Ihrer Seite „Greengrass-Gruppe“ ein Lambda hinzu und wählen Sie Create new Lambda.Daraufhin wird die AWS Lambda-Konsole geöffnet.

256


7. Wählen Sie Author from scratch und verwenden Sie die folgenden Werte zum Erstellen der Funktion:

• Geben Sie in Function name (Funktionsname) optimizedImageClassification ein.• Wählen Sie für Runtime die Option Python 2.7 aus.

Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eineAusführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nichtvon AWS IoT Greengrass verwendet.


Laden Sie nun das Bereitstellungspaket für die Lambda-Funktion hoch und registrieren Sie den Handler.

1. Geben Sie in der Registerkarte Configuration (Konfiguration) für die FunktionoptimizedImageClassification unter Function code (Funktionscode) folgende Werte an:


• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie in Handler (Handler) inference.handler ein.


257


3. Wählen Sie das Bereitstellungspaket optimizedImageClassification.zip aus.4. Wählen Sie Save aus.

Als Nächstes veröffentlichen Sie die erste Version der Lambda-Funktion. Anschließend erstellen Sie einenAlias für die Version.

Note

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nachVersion referenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, da dieAbonnementtabelle oder Gruppendefinition bei der Aktualisierung des Funktionscodes nichtgeändert werden müssen. Stattdessen lassen Sie den Alias einfach auf die neue Funktionsversionverweisen.

1. Wählen Sie im Menü Actions die Option Publish new version aus.


3. Wählen Sie auf der Konfigurationsseite für optimizedImageClassification: 1 im Menü Actions (Aktionen)die Option Create alias (Alias erstellen) aus.

4. Geben Sie auf der Seite Create a new alias folgende Werte an:

• Geben Sie in Name (Name) mlTestOpt ein.• Geben Sie in Version (Version) 1 ein.

Note


Fügen Sie nun die Lambda-Funktion zur Greengrass-Gruppe hinzu.

258



Schritt 4: Hinzufügen der Lambda-Funktion zurGreengrass-GruppeIn diesem Schritt fügen Sie die Lambda-Funktion der Gruppe hinzu und konfigurieren dann denLebenszyklus.



2. Wählen Sie optimizedImageClassification und dann Next.3. Wählen Sie auf der Seite Select a Lambda version (Auswählen einer Lambda-Version) Alias:mlTestOpt

und dann Finish aus.

Als Nächstes konfigurieren Sie den Lebenszyklus der Lambda-Funktion.

1. Wählen Sie auf der Seite Lambdas die Funktion optimizedImageClassification Lambda.

2. Wählen Sie auf der Konfigurationsseite für optimizedImageClassification die Option Edit (Bearbeiten)aus.

3. Geben Sie auf der Seite Group-specific Lambda configuration folgende Werte an:

• Geben Sie in Memory Limit (Arbeitsspeicher-Limit) 1024 MB ein.• Geben Sie in Timeout (Zeitüberschreitung) 10 seconds ein.• Wählen Sie in Lambda lifecycle (IAM-Lebenszklus) die Option Make this function long-lived and keep

it running indefinitely (Diese Funktion dauerhaft festlegen und unbegrenzt ausführen).• Wählen Sie in Read access to /sys directory (Lesezugriff auf /sys-Verzeichnis) die Option Enable

(Aktivieren) aus.

Weitere Informationen finden Sie unter the section called “Lebenszykluskonfiguration” (p. 189).4. Wählen Sie Update aus.

259

AWS IoT Greengrass EntwicklerhandbuchHinzufügen Neo-optimierter Modellressource zur Gruppe

Schritt 5: Hinzfügen Amazon SageMaker Neo-optimierter Modellressource zur Greengrass-GruppeIn diesem Schritt erstellen Sie eine Ressource für das optimierte ML-Inferenzmodell und laden sie in einenAmazon S3 Bucket hoch. Danach suchen Sie das hochgeladene Amazon S3-Modell in der AWS IoTGreengrass-Konsole und ordnen die neu erstellte Ressource mit der Lambda-Funktion zu. Dies ermöglichtes der Funktion, auf ihre Ressourcen auf dem Core-Gerät zuzugreifen.

1. Navigieren Sie auf Ihrem Computer zum Neo Deep Learning Runtime-Installationspaket, das Sie zuvorentpackt haben. Navigieren Sie zum Verzeichnis resnet50.

cd path-to-downloaded-runtime/dlr-1.0-py2-armv7l/models/resnet50

Dieses Verzeichnis enthält vorkompilierte Modellartefakte für ein mit Resnet-50 trainiertesBildklassifikationsmodell. Komprimieren Sie die Dateien im Verzeichnis resnet50, umresnet50.zip zu erstellen.

zip -r resnet50.zip .

2. Wählen Sie auf der Gruppenkonfigurationsseite für Ihre AWS IoT Greengrass-Gruppe Resources(Ressourcen) aus. Navigieren Sie zum Abschnitt Machine Learning und wählen Sie Add machinelearning resource (Maschinelle Lernressource hinzufügen) aus. Geben Sie auf der Seite Createa machine learning resource (Maschinelle Lernressource erstellen) unter Resource name(Ressourcenname) resnet50_model ein.

3. Wählen Sie für Model Source (Modellquelle) die Option Upload a model in S3 (Ein Modell in S3hochladen) aus.

4. Wählen Sie unter Model from S3 (Modell aus S3) die Option Select (Auswählen).

Note

Derzeit werden optimierte Amazon SageMaker-Modelle automatisch in Amazon S3gespeichert. Sie können Ihr optimiertes Modell mit dieser Option in Ihrem Amazon S3-Bucketfinden. Weitere Informationen zur Modelloptimierung in Amazon SageMaker finden Sie in derAmazon SageMaker-Neo-Dokumentation.

5. Wählen Sie Upload a model (Ein Modell hochladen). Auf diese Weise wird eine neue Registerkarte inder Amazon S3-Konsole geöffnet.

6. Laden Sie in der Registerkarte der Amazon S3-Konsole Ihre ZIP-Datei in einen Amazon S3-Buckethoch. Weitere Informationen finden Sie unter Wie lade ich Dateien und Ordner in einen S3-Buckethoch?

260




AWS IoT Greengrass EntwicklerhandbuchHinzufügen Ihrer Kamerageräte-Ressource zur Gruppe

Note

Ihr Bucket-Name muss die Zeichenkette greengrass enthalten, damit der Bucket zugänglichist. Wählen Sie einen eindeutigen Namen (wie z. B.: greengrass-dlr-bucket-user-id-epoch-time). Verwenden Sie keinen Punkt (.) im Bucket-Namen.

7. Suchen Sie in der Registerkarte der AWS IoT Greengrass-Konsole Ihren Amazon S3-Bucket undwählen Sie ihn aus. Suchen Sie Ihre hochgeladene Datei resnet50.zip und wählen Sie Select(Auswählen). Möglicherweise müssen Sie die Seite aktualisieren, um die Liste der verfügbarenBuckets und Dateien zu aktualisieren.

8. Geben Sie für Local Path (Lokaler Pfad) /ml_model ein.

Dies ist das Ziel für das lokale Modell im Lambda-Laufzeit-Namespace. Wenn Sie die Gruppebereitstellen, ruft AWS IoT Greengrass das Quellmodellpaket ab und extrahiert dann den Inhalt in dasangegebene Verzeichnis.

Note

Wir empfehlen Ihnen dringend, den genauen Pfad für Ihren lokalen Pfad zu verwenden. DieVerwendung eines anderen lokalen Modellzielverzeichnisses in diesem Schritt führt dazu,dass einige in diesem Tutorial enthaltene Befehle zur Fehlerbehebung ungenau sind. WennSie einen anderen Pfad verwenden, müssen Sie eine MODEL_PATH-Umgebungsvariableeinrichten, die genau den von Ihnen hier angegebenen Pfad verwendet. WeitereInformationen zu Umgebungsvariablen finden Sie unter AWS Lambda-Umgebungsvariablen.


10. Wählen Sie optimizedImageClassification, Read-only access (Schreibgeschützter Zugriff) und dannDone (Fertig) aus.


Schritt 6: Hinzufügen einer Kamerageräte-Ressourcezur Greengrass-GruppeIn diesem Schritt erstellen Sie eine Ressource für das Kameramodul und verknüpfen sie mit der Lambda-Funktion, damit die Ressource auf dem AWS IoT Greengrass-Core zugänglich ist.


261



2. Wählen Sie in der Registerkarte Local Resources (Lokale Ressourcen) die Option Add local resource(Lokale Ressource hinzufügen) aus.

3. Geben Sie auf der Seite Create a local resource folgende Werte an:

• Geben Sie in Resource name (Ressourcenname) videoCoreSharedMemory ein.• Wählen Sie in Resource type (Ressourcentyp) die Option Device (Gerät) aus.• Geben Sie im Feld Device path (Gerätepfad) /dev/vcsm ein.

Der Device path (Gerätepfad) ist der lokale absolute Pfad der Geräteressource. Dieser Pfad kannnur auf ein zeichenorientiertes Gerät oder Blockgerät unter /dev verweisen.

• Wählen Sie für Group owner file access permission (Dateizugriffsberechtigung desGruppenbesitzers) die Option Automatically add OS group permissions of the Linux group that ownsthe resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppe hinzufügen, zuder die Ressource gehört) aus.

Mit der Option Group owner file access permission können Sie zusätzlicheDateizugriffsberechtigungen für den Lambda-Prozess erteilen. Weitere Informationen finden Sieunter Dateizugriffsberechtigungen des Gruppenbesitzers (p. 206).

262



5. Wählen Sie optimizedImageClassification, Read and write access (Lese- und Schreibzugriff) und dannDone (Fertig) aus.

Als nächstes fügen Sie eine lokale Geräteressource für die Kameraschnittstelle hinzu.6. Wählen Sie unten auf der Seite Add another resource (Eine weitere Ressource hinzufügen) aus.7. Geben Sie auf der Seite Create a local resource folgende Werte an:

• Geben Sie in Resource name (Ressourcenname) videoCoreInterface ein.• Wählen Sie in Resource type (Ressourcentyp) die Option Device (Gerät) aus.• Geben Sie in Device path (Gerätepfad) /dev/vchiq ein.• Wählen Sie für Group owner file access permission (Dateizugriffsberechtigung des


263



9. Wählen Sie optimizedImageClassification, Read and write access (Lese- und Schreibzugriff) und dannDone (Fertig) aus.


Schritt 7: Hinzufügen von Abonnements zurGreengrass-GruppeIn diesem Schritt fügen Sie der Gruppe Abonnements hinzu. Diese Abonnements ermöglichen der Lambda-Funktion Prognoseergebnisse durch Veröffentlichung in einem MQTT-Thema an AWS IoT zu senden.



a. Wählen Sie unter Select a source (Eine Quelle auswählen) die Option Lambdas und dannoptimizedImageClassification aus.

264


b. Wählen Sie unter Select a target (Ein Ziel auswählen) die Option Services und dann IoT Cloudaus.

c. Wählen Sie Next.

3. Geben Sie auf der Seite Filter your data with a topic (Ihre Daten nach einem Thema filtern) in Optionaltopic filter (Optionaler Themenfilter) /resnet-50/predictions ein und wählen Sie dann Next.

4. Wählen Sie Finish aus.5. Hinzufügen eines zweiten Abonnements. Konfigurieren Sie auf der Seite Select your source and target

die Quelle und das Ziel wie folgt:

a. Wählen Sie unter Select a source (Quelle auswählen) die Option Services und dann IoT Cloudaus.

b. Wählen Sie unter Select a target (Ein Ziel auswählen) die Option Lambdas und dannoptimizedImageClassification aus.

c. Wählen Sie Next.6. Geben Sie auf der Seite Filter your data with a topic (Ihre Daten nach einem Thema filtern) in Optional

topic filter (Optionaler Themenfilter) /resnet-50/test ein und wählen Sie dann Next.7. Wählen Sie Finish aus.

Schritt 8: Bereitstellen der Greengrass-GruppeIn diesem Schritt stellen Sie die aktuelle Version der Gruppendefinition für das Greengrass-Core-Gerätbereit. Die Definition enthält die Lambda-Funktion, Ressourcen und Abonnementkonfigurationen, die Siehinzugefügt haben.



265



Wenn die Ausgabe einen root-Eintrag für /greengrass/ggc/packages/latest-core-version/bin/daemon enthält, dann wird der Daemon ausgeführt.






Note


Auf der Seite Deployments (Bereitstellungen) werden der Zeitstempel, die Versions-ID und der Statusder Bereitstellung angegeben. Nach abgeschlossener Bereitstellung sollte der Status Successfullycompleted (Erfolgreich abgeschlossen) lauten.

266

AWS IoT Greengrass EntwicklerhandbuchTesten des Beispiels


Testen des InferenzbeispielsNun können Sie prüfen, ob die Bereitstellung korrekt konfiguriert ist. Um zu testen, abonnieren Sie dasThema /resnet-50/predictions und veröffentlichen Sie jede Nachricht zum /resnet-50/test-Thema. Dies löst die Lambda-Funktion aus, um ein Foto mit Ihrer Raspberry Pi aufzunehmen und dieInferenz auf das aufgenommene Bild auszuführen.

Note

Wenn ein Bildschirm mit dem Raspberry Pi verbunden ist, wird das Livebild der Kamera in einemVorschaufenster angezeigt.

1. Wählen Sie auf der AWS IoT-Konsole-Startseite die Option Test.

267

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren eines Intel Atom

2. Wählen Sie in Subscriptions (Abonnements) Subscribe to a Topic aus. Verwenden Sie die folgendenWerte. Übernehmen Sie für die verbleibenden Optionen die Standardwerte.

• Geben Sie in Subscription topic (Abonnementthema) /resnet-50/predictions ein.• Wählen Sie für MQTT-Nutzlast-Anzeige die Option Nutzlasten als Zeichenfolgen anzeigen aus.

3. Wählen Sie Subscribe to topic.4. Geben Sie auf der Seite /resnet-50/predictions das Thema /resnet-50/test an, zu dem

veröffentlicht werden soll. Wählen Sie Publish to topic aus.5. Wenn der Test erfolgreich ist, veranlasst die veröffentlichte Nachricht die Raspberry Pi-Kamera,

ein Bild aufzunehmen. Eine Meldung der Lambda-Funktion erscheint unten auf der Seite. DieseMeldung enthält das Vorhersageergebnis des Bildes im Format: vorhergesagter Klassenname,Wahrscheinlichkeit und maximaler Speicherverbrauch.

Konfigurieren eines Intel AtomZum Ausführen dieses Tutorials auf einem Intel Atom-Gerät stellen Sie Quellbilder bereit und konfigurierendie Lambda-Funktion. Damit Sie die GPU für Inferenz verwenden können, muss OpenCL Version 1.0 oderhöher auf Ihrem Gerät installiert sein. Sie müssen auch lokale Geräteressourcen hinzufügen.

1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion für die Bildklassifizierung herunter.Das Beispiel funktioniert am besten mit kleinen Bilddateien.

Speichern Sie Ihre Bilddateien in dem Verzeichnis mit der inference.py-Datei (oder in einemUnterverzeichnis dieses Verzeichnisses). Dies ist im Bereitstellungspaket der Lambda-Funktionenthalten, das Sie in the section called “Erstellen einer Lambda-Inferenzfunktion” (p. 255)hochgeladen haben.

Note

Bei Verwendung von Amazon DeepLens können Sie auf Wunsch stattdessen die integrierteKamera verwenden oder Ihre eigene Kamera mounten, um Bilder aufzunehmen und Inferenz

268

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren eines NVIDIA Jetson TX2

für sie durchzuführen. Es wird jedoch dringend empfohlen, das Beispiel zuerst bei statischenBildern auszuprobieren.

2. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter the sectioncalled “Hinzufügen der Lambda-Funktion zur Gruppe” (p. 259).

a. Erhöhen Sie den Wert für Speicherlimit auf 3000 MB.b. Erhöhen Sie den Wert für Timeout auf 2 Minuten. Dadurch wird sichergestellt, dass die Zeit für die

Anforderung nicht zu früh überschritten wird. Wenn die Inferenz erstmalig nach dem Durchführender Einrichtung auf dem Intel Atom ausgeführt wird, kann dies etwas dauern.

c. Wählen Sie Enable für die Option Lesezugriff auf das /sys-Verzeichnis.d. Wählen Sie für Lambda-Lebenszyklus die Option Make this function long-lived and keep it running

indefinitely aus.3. Fügen Sie die folgende lokale Geräteressource hinzu.

a. Wählen Sie im Navigationsbereich Ressourcen und Add a local resource aus.

b. Für die Ressource:


Gruppenbesitzers) die Option Automatically add OS group permissions of the Linux group thatowns the resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppehinzufügen, zu der die Ressource gehört) aus.


Name Gerätepfad

renderD128 /dev/dri/renderD128

Konfigurieren eines NVIDIA Jetson TX2Zum Ausführen dieses Tutorials auf einem NVIDIA Jetson TX2 stellen Sie Quellbilder bereit undkonfigurieren die Lambda-Funktion. Wenn Sie die GPU für Inferenzzwecke verwenden, müssen Sie CUDA9.0 und cuDNN 7.0 auf Ihrem Gerät installieren, wenn Sie Ihre Karte mit Jetpack 3.3 abbilden. Sie müssenauch lokale Geräteressourcen hinzufügen.

269

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren eines NVIDIA Jetson TX2

Weitere Informationen darüber, wie Sie Ihr Jetson-Gerät konfigurieren, damit die AWS IoT GreengrassCore-Software installiert werden kann, finden Sie unter the section called “Einrichten andererGeräte” (p. 80).

1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion für die Bildklassifizierung herunter.Das Beispiel funktioniert am besten mit kleinen Bilddateien.

Speichern Sie Ihre Bilddateien in dem Verzeichnis mit der inference.py-Datei (oder in einemUnterverzeichnis dieses Verzeichnisses). Dies ist im Bereitstellungspaket der Lambda-Funktionenthalten, das Sie in the section called “Erstellen einer Lambda-Inferenzfunktion” (p. 255)hochgeladen haben.

Note

Sie können auf Wunsch stattdessen eine Kamera auf der Jetson-Karte instrumentieren,um die Quellbilder zu erfassen. Es wird jedoch dringend empfohlen, das Beispiel zuerst beistatischen Bildern auszuprobieren.

2. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter the sectioncalled “Hinzufügen der Lambda-Funktion zur Gruppe” (p. 259).

a. Erhöhen Sie den Wert für Speicherlimit. Für die Verwendung des bereitgestellten Modells im GPU-Modus verwenden Sie 2048 MB.

b. Erhöhen Sie den Wert für Timeout auf 5 Minuten. Dadurch wird sichergestellt, dass die Zeit für dieAnforderung nicht zu früh überschritten wird. Wenn die Inferenz erstmalig nach dem Durchführender Einrichtung auf dem Jetson ausgeführt wird, kann dies etwas dauern.

c. Wählen Sie für Lambda-Lebenszyklus die Option Make this function long-lived and keep it runningindefinitely aus.

d. Wählen Sie für Lesezugriff auf das /sys-Verzeichnis die Option Enable.3. Fügen Sie die folgenden lokalen Geräteressourcen hinzu.

a. Wählen Sie im Navigationsbereich Ressourcen und Add a local resource aus.

b. Für jede Ressource:


Gruppenbesitzers) die Option Automatically add OS group permissions of the Linux group thatowns the resource (Automatisch Betriebssystemgruppenberechtigungen der Linux-Gruppehinzufügen, zu der die Ressource gehört) aus.


270

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei AWS IoT Greengrass-ML-Inferenz

Name Gerätepfad

nvhost-strg /dev/nvhost-strg

nvhost-gpu /dev/nvhost-gpu

nvhost-strg-gpu /dev/nvhost-strg-gpu

nvhost-dbg-gpu /dev/nvhost-dbg-gpu

nvhost-prof-gpu /dev/nvhost-prof-gpu

nvmap /dev/nvmap

Note

Die erste Inferenz nach Abschluss der Einrichtung kann einige Minuten in Anspruch dauern.

Fehlerbehebung bei AWS IoT Greengrass-ML-InferenzWenn der Test nicht erfolgreich ist, können Sie folgende Schritte ausführen, um den Fehler zu beheben.Führen Sie im Raspberry Pi-Terminal die Befehle aus.

Fehlerprotokolle prüfen1. Wechseln Sie zum Root-Benutzer und navigieren Sie zum Verzeichnis log. Der Zugriff auf AWS IoT

Greengrass-Protokolle erfordert Root-Berechtigungen.


2. Überprüfen Sie runtime.log auf Fehler.

cat system/runtime.log | grep 'ERROR'

Sie können auch im benutzerdefinierten Lambda-Funktionsprotokoll nach Fehlern suchen:

cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'

Weitere Informationen finden Sie unter the section called “Fehlerbehebung mit Protokollen” (p. 514).

Stellen Sie sicher, dass die Lambda-Funktion erfolgreichbereitgestellt wird1. Listen Sie den Inhalt der bereitgestellten Lambda im /lambda-Verzeichnis auf. Ersetzen Sie die

Platzhalterwerte, bevor Sie den Befehl ausführen.

cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version

271

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei AWS IoT Greengrass-ML-Inferenz

ls -la

2. Überprüfen Sie, ob das Verzeichnis denselben Inhalt wie dasoptimizedImageClassification.zip-Bereitstellungspaket enthält, das Sie in Schritt 3: Erstelleneiner Lambda-Inferenzfunktion (p. 255) hochgeladen haben.

Stellen Sie sicher, dass sich die .py-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.

Stellen Sie sicher, dass das Inferenzmodell erfolgreichbereitgestellt wird1. Finden Sie die Prozessidentifikationsnummer (PID) des Lambda-Laufzeitprozesses:

ps aux | grep lambda-function-name

In der Ausgabe wird die PID in der zweiten Spalte der Zeile für den Lambda-Laufzeitprozessangezeigt.

2. Geben Sie den Lambda-Laufzeit-Namespace ein. Stellen Sie sicher, den pid-Wert des Platzhalters zuersetzen, bevor Sie den Befehl ausführen.

Note

Dieses Verzeichnis und sein Inhalt befinden sich im Lambda-Laufzeit-Namespace, daher sindsie nicht in einem regulären Linux-Namespace sichtbar.

sudo nsenter -t pid -m /bin/bash

3. Listen Sie den Inhalt des lokalen Verzeichnisses, das Sie für die ML-Ressource angegeben haben,auf.

Note

Wenn Ihr ML-Ressourcenpfad anders als ml_model lautet, müssen Sie ihn hier ersetzen.

cd /ml_modells -ls

Die Dateien sollten folgendermaßen aussehen:

56 -rw-r--r-- 1 ggc_user ggc_group 56703 Oct 29 20:07 model.json196152 -rw-r--r-- 1 ggc_user ggc_group 200855043 Oct 29 20:08 model.params 256 -rw-r--r-- 1 ggc_user ggc_group 261848 Oct 29 20:07 model.so 32 -rw-r--r-- 1 ggc_user ggc_group 30564 Oct 29 20:08 synset.txt

Die Lambda-Funktion kann /dev/dri/renderD128 nichtfinden.Dies kann passieren, wenn OpenCL keine Verbindung zu den benötigten GPU-Geräten herstellen kann.Für die für Ihre Lambda-Funktion erforderlichen Geräte müssen Sie Geräte-Ressourcen erstellen.

272


Nächste SchritteErkunden Sie als nächstes andere optimierte Modelle. Weitere Informationen finden Sie in der AmazonSageMaker-Neo-Dokumentation.

273




Secrets für AWS IoT GreengrassCore bereitstellen


AWS IoT Greengrass ermöglicht Ihnen die Authentifizierung bei Services und Anwendungen ausGreengrass-Geräten, ohne Passwörter, Token oder andere Secrets fest kodieren zu müssen.

AWS Secrets Manager ist ein Service, mit dem Sie Ihre Secrets sicher in der Cloud speichern undverwalten können. AWS IoT Greengrass erweitert Secrets Manager auf Greengrass Core-Geräten, sodassIhre Konnektoren (p. 297) und Lambda-Funktionen für die Interaktion mit Services und Anwendungenlokale Secrets verwenden können. So verwendet beispielsweise der Twilio-Benachrichtigungen-Konnektorein lokal gespeichertes Authentifizierungstoken.

Um ein Secret in eine Greengrass-Gruppe zu integrieren, erstellen Sie eine Gruppen-Ressource, die aufdas Secrets Manager-Secret verweist. Diese geheime Ressource verweist über ARN auf das Cloud-Secret.Weitere Informationen zum Erstellen, Verwalten und Verwenden von Secret-Ressourcen finden Sie unterthe section called “Arbeiten mit Secret-Ressourcen” (p. 278).

AWS IoT Greengrass verschlüsselt Ihre Secrets während der Übertragung und im Ruhezustand. Währendder Gruppenbereitstellung ruft AWS IoT Greengrass das Secret von Secrets Manager ab und erstelltauf dem Greengrass Core eine lokale verschlüsselte Kopie. Nachdem Sie Ihre Cloud-Secrets in SecretsManager rotiert haben, stellen Sie die Gruppe erneut bereit, um die aktualisierten Werte an den Kern zuübertragen.

Das folgende Diagramm zeigt den High-Level-Prozess der Bereitstellung eines Secrets im Kern. Secretswerden während der Übertragung und im Ruhezustand verschlüsselt.

Die Verwendung von AWS IoT Greengrass zur lokalen Speicherung Ihrer Secrets bietet die folgendenVorteile:

• Entkoppelung vom Code (nicht fest programmiert). Dies unterstützt zentral verwalteteAnmeldeinformationen und schützt sensible Daten vor dem Risiko der Kompromittierung.

• Verfügbar für Offline-Szenarien. Konnektoren und Funktionen können bei fehlender Verbindung zumInternet sicher auf lokale Services und Software zugreifen.

• Kontrollierter Zugriff auf Secrets. Nur autorisierte Konnektoren und Funktionen in der Gruppe könnenauf Ihre Secrets zugreifen. AWS IoT Greengrass verwendet Verschlüsselung für private Schlüssel, umIhre Secrets zu schützen. Secrets werden während der Übertragung und im Ruhezustand verschlüsselt.Weitere Informationen finden Sie unter the section called “Secrets Verschlüsselung” (p. 275).

274

AWS IoT Greengrass EntwicklerhandbuchSecrets Verschlüsselung

• Kontrollierte Rotation. Nachdem Sie Ihre Secrets in Secrets Manager rotiert haben, stellen Sie dieGreengrass-Gruppe erneut bereit, um die lokalen Kopien Ihrer Secrets zu aktualisieren. WeitereInformationen finden Sie unter the section called “Erstellen und Verwalten von Secrets” (p. 279).

Important

AWS IoT Greengrass aktualisiert die Werte lokaler Secrets nicht automatisch, nachdem Cloud-Versionen rotiert wurden. Um lokale Werte zu aktualisieren, müssen Sie die Gruppe erneutbereitstellen.

Secrets VerschlüsselungAWS IoT Greengrass verschlüsselt Geheimnisse während der Übertragung und im Ruhezustand.

Important

Stellen Sie sicher, dass die benutzerdefinierten Lambda-Funktionen Geheimnisse sicherverarbeiten, und protokollieren Sie keine vertraulichen Daten, die im Geheimnisse gespeichertsind. Weitere Informationen finden Sie unter Verhindern von Risiken durch die Protokollierungoder das Debuggen Ihrer Lambda-Funktion im AWS Secrets Manager-Benutzerhandbuch. Obwohlsich diese Dokumentationen speziell auf Rotationsfunktionen bezieht, gilt die Empfehlung auch fürGreengrass Lambda-Funktionen.

Verschlüsselung während der Übertragung.

AWS IoT Greengrass verwendet die Transport Layer Security (TLS) zur Verschlüsselung dergesamten Kommunikation über das Internet und das lokale Netzwerk. Dies schützt Secrets währendder Übertragung, was der Fall ist, wenn Secrets vom Secrets Manager abgerufen und dem Kernbereitgestellt werden. Unterstützte TLS-Cipher-Suites finden Sie unter the section called “AWS IoTGreengrass Cipher Suites” (p. 431).

Verschlüsselung im Ruhezustand

AWS IoT Greengrass verwendet den in config.json (p. 23) angegebenen privaten Schlüsselzur Verschlüsselung der Secrets, die auf dem Core gespeichert sind. Aus diesem Grund ist diesichere Speicherung des privaten Schlüssels für den Schutz lokaler Secrets entscheidend. Im AWS Modell der übergreifenden Verantwortlichkeit liegt es in der Verantwortung des Kunden, die sichereSpeicherung des privaten Schlüssels auf dem Core-Gerät zu gewährleisten.

AWS IoT Greengrass unterstützt zwei Arten der Speicherung privater Schlüssel:• Die Verwendung von Hardware-Sicherheitsmodulen. Weitere Informationen finden Sie unter the

section called “Hardware-Sicherheit” (p. 435).Note

Aktuell unterstützt AWS IoT Greengrass bei der Nutzung von hardwarebasierten privatenSchlüsseln nur den Padding-Mechanismus PKCS#1 v1.5 für die Ver- und Entschlüsselungvon lokalen Geheimnissen. Wenn Sie die vom Anbieter bereitgestellten Anweisungen zummanuellen Erstellen hardwarebasierter privater Schlüssel befolgen, stellen Sie sicher,dass Sie PKCS#1 v1.5 auswählen. AWS IoT Greengrass unterstützt Optimal AsymmetricEncryption Padding (OAEP) nicht.

• Die Verwendung von Dateisystemberechtigungen (Standard).

Der private Schlüssel wird zur Sicherung des Datenschlüssels verwendet, mit dem lokale Secretsverschlüsselt werden. Der Datenschlüssel wird bei jedem Gruppeneinsatz rotiert.

AWS IoT Greengrass-Core ist die einzige Entität, die Zugriff auf den privaten Schlüssel hat.Greengrass-Konnektoren oder Lambda-Funktionen, die einer geheimen Ressource zugeordnet sind,erhalten den Wert des Secrets aus dem Kern.

275

https://docs.aws.amazon.com/secretsmanager/latest/userguide/best-practices.html#best-practice_lamda-debug-statements


https://aws.amazon.com/compliance/shared-responsibility-model/

https://aws.amazon.com/compliance/shared-responsibility-model/



VoraussetzungenDies sind die Anforderungen für den lokalen Secret-Support:

• Sie müssen AWS IoT Greengrass Core v1.7 or later verwenden.• Um die Werte der lokalen Geheimnisse zu erhalten, müssen die benutzerdefinierten Lambda-Funktionen

AWS IoT GreengrassCore-SDK v1.3.0 or later verwenden.• Der private Schlüssel, der für die Verschlüsselung lokaler Secrets verwendet wird, muss in der

Greengrass-Konfigurationsdatei angegeben sein. Standardmäßig verwendet AWS IoT Greengrassden privaten Kernschlüssel, der im Dateisystem gespeichert ist. Informationen zur Bereitstellung Ihreseigenen privaten Schlüssels finden Sie unter the section called “Angeben des privaten Schlüssels für dieVerschlüsselung von Secrets” (p. 276). Nur der RSA-Schlüsseltyp wird unterstützt.

Note

Aktuell unterstützt AWS IoT Greengrass bei der Nutzung von hardwarebasierten privatenSchlüsseln nur den Padding-Mechanismus PKCS#1 v1.5 für die Ver- und Entschlüsselungvon lokalen Geheimnissen. Wenn Sie die vom Anbieter bereitgestellten Anweisungen zummanuellen Erstellen hardwarebasierter privater Schlüssel befolgen, stellen Sie sicher, dass SiePKCS#1 v1.5 auswählen. AWS IoT Greengrass unterstützt Optimal Asymmetric EncryptionPadding (OAEP) nicht.

• AWS IoT Greengrass muss die Berechtigung erteilt werden, um Ihre geheimen Werte empfangen zukönnen. Dies ermöglicht es AWS IoT Greengrass, die Werte während der Bereitstellung der Gruppeabzurufen. Wenn Sie die standardmäßige Greengrass-Servicerolle verwenden, hat AWS IoT Greengrassbereits Zugriff auf Secrets mit Namen, die mit greengrass- beginnen. Informationen zum Anpassendes Zugriffs finden Sie unter the section called “AWS IoT Greengrass den Zugriff auf Secret-Werteerlauben” (p. 277).

Note

Wir empfehlen Ihnen, diese Namenskonvention zu verwenden, um die Secrets zu identifizieren,auf die AWS IoT Greengrass zugreifen darf, auch wenn Sie die Berechtigungen anpassen.Die Konsole verwendet verschiedene Berechtigungen, um Ihre Secrets zu lesen. Dadurchkönnen Sie in der Konsole Secrets auswählen, für die AWS IoT Greengrass keine Berechtigungzum Abrufen besitzt. Die Verwendung einer Namenskonvention kann dazu beitragen, einenBerechtigungskonflikt zu vermeiden, der zu einem Bereitstellungsfehler führt.

Angeben des privaten Schlüssels für dieVerschlüsselung von Secrets

In diesem Verfahren geben Sie den Pfad zu einem privaten Schlüssel an, der für die lokale geheimeVerschlüsselung verwendet wird. Dabei muss es sich um einen RSA-Schlüssel mit einer Mindestlängevon 2048 Bits handeln. Weitere Informationen über private Schlüssel, die auf AWS IoT Greengrass-Coreverwendet werden, finden Sie unter the section called “Sicherheitsprinzipale” (p. 428).

AWS IoT Greengrass unterstützt zwei Arten der Speicherung privater Schlüssel: hardwarebasiert oderdateisystembasiert (Standard). Weitere Informationen finden Sie unter the section called “SecretsVerschlüsselung” (p. 275).

Führen Sie diese Vorgehensweise nur dann aus, wenn Sie die Standardkonfiguration ändern möchten, dieden privaten Core-Schlüssel im Dateisystem verwendet. Diese Schritte gelten unter der Annahme, dass SieIhre Gruppe und Ihren Kern wie in Modul 2 (p. 81) des Tutorials Erste Schritte beschrieben erstellt haben.

1. Öffnen Sie die Datei config.json (p. 23), die sich im Verzeichnis /greengrass-root/configbefindet.

276


AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass den Zugriff auf Secret-Werte erlauben

Note

greengrass-root steht für den Pfad, unter dem die AWS IoT Greengrass Core-Software auf Ihrem Gerät installiert ist. Falls Sie die Software anhand des im Tutorial ErsteSchritte (p. 69) beschriebenen Verfahrens installiert haben, handelt es sich hierbei um dasVerzeichnis /greengrass.

2. Geben Sie im Objekt crypto.principals.SecretsManager für die EigenschaftprivateKeyPath den Pfad des privaten Schlüssels ein:

• Wenn Ihr privater Schlüssel im Dateisystem gespeichert ist, geben Sie den absoluten Pfad zumSchlüssel an. Zum Beispiel:

"SecretsManager" : { "privateKeyPath" : "file:///somepath/hash.private.key"}

• Wenn Ihr privater Schlüssel in einem Hardware-Sicherheitsmodul (HSM) gespeichert ist, geben Sieden Pfad mithilfe des URI-Schemas RFC 7512 PKCS#11 an. Zum Beispiel:

"SecretsManager" : { "privateKeyPath" : "pkcs11:object=private-key-label;type=private"}

Weitere Informationen finden Sie unter the section called “Hardware-Sicherheitskonfiguration” (p. 436).

Note


AWS IoT Greengrass den Zugriff auf Secret-Werteerlauben

In diesem Verfahren fügen Sie der Greengrass-Servicerolle eine Inline-Richtlinie hinzu, die es AWS IoTGreengrass ermöglicht, die Werte Ihrer Secrets zu erhalten.

Befolgen Sie dieses Verfahren nur, wenn Sie AWS IoT Greengrass benutzerdefinierteBerechtigungen für Ihre Secrets erteilen möchten oder wenn Ihre Greengrass-Servicerollenicht die mit AWSGreengrassResourceAccessRolePolicy verwaltete Richtlinie enthält.AWSGreengrassResourceAccessRolePolicy gewährt Zugriff auf Secrets mit Namen, die mitgreengrass- beginnen.

1. Führen Sie den folgenden CLI-Befehl aus, um den ARN der Greengrass-Servicerolle zu erhalten:

aws greengrass get-service-role-for-account --region Region

Der zurückgegebene ARN enthält den Rollennamen.

{

277




"AssociatedAt": "time-stamp", "RoleArn": "arn:aws:iam::account-id:role/service-role/role-name"}

Sie verwenden im folgenden Schritt den ARN oder den Namen.2. Fügen Sie eine Inline-Richtlinie hinzu, die die Aktion secretsmanager:GetSecretValue

erlaubt. Eine Anleitung finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

Sie können granularen Zugriff gewähren, indem Sie Secrets explizit auflisten oder ein Wildcard* Namensschema verwenden, oder Sie können bedingten Zugriff auf versionierte oder markierteSecrets gewähren. Die folgende Richtlinie erlaubt es beispielsweise AWS IoT Greengrass nur dieangegebenen Secrets zu lesen.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "secretsmanager:GetSecretValue" ], "Resource": [ "arn:aws:secretsmanager:region:account-id:secret:greengrass-SecretA-abc", "arn:aws:secretsmanager:region:account-id:secret:greengrass-SecretB-xyz" ] } ]}

Note

Wenn Sie einen vom Kunden verwalteten AWS KMS-Schlüssel zur Verschlüsselung vonSecrets verwenden, muss Ihre Greengrass-Servicerolle auch die Aktion kms:Decrypterlauben.

Weitere Informationen zu IAM-Richtlinien für das Secrets Manager finden Sie unter Authentifizierung undZugriffskontrolle für AWS Secrets Manager und Aktionen, Ressourcen und Kontext-Schlüssel, die Sie ineiner IAM-Richtlinie oder Secret-Richtlinie für AWS Secrets Manager verwenden können im AWS SecretsManager-Benutzerhandbuch.

Weitere Informationen finden Sie auch unter:• Was ist AWS Secrets Manager? im AWS Secrets Manager-Benutzerhandbuch• PKCS #1: RSA Encryption Version 1.5

Arbeiten mit Secret-RessourcenAWS IoT Greengrass verwendet Secret-Ressourcen zum Integrieren von Secrets aus AWS SecretsManager in einer Greengrass-Gruppe. Eine Secret-Ressource ist ein Verweis auf ein Secrets Manager-Secret. Weitere Informationen finden Sie unter Secrets für Core bereitstellen (p. 274).

278


https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html


AWS IoT Greengrass EntwicklerhandbuchErstellen und Verwalten von Secrets

Auf dem AWS IoT Greengrass-Core-Gerät können Connectors und Lambda-Funktionen die geheimeRessource für die Authentifizierung bei Services und Anwendungen verwenden, ohne Passwörter, Tokenoder andere Anmeldeinformationen fest kodieren zu müssen.

Erstellen und Verwalten von SecretsIn einer Greengrass-Gruppe verweist eine Secret-Ressourcen auf den ARN eines Secrets Manager-Secrets. Wenn die Secret-Ressource für den Core bereitgestellt wird, wird der Wert des Secretsverschlüsselt und zugeordneten Konnektoren und Lambda-Funktionen zur Verfügung gestellt. WeitereInformationen finden Sie unter the section called “Secrets Verschlüsselung” (p. 275).

Verwenden Sie Secrets Manager zum Erstellen und Verwalten von Cloud-Versionen Ihrer Secrets.Verwenden Sie AWS IoT Greengrass zum Erstellen, Verwalten und Bereitstellen Ihrer geheimenRessourcen.

Important

Wir empfehlen, dass Sie die bewährten Methoden der Rotation Ihrer Secrets in Secrets Managerbefolgen. Stellen Sie dann die Greengrass-Gruppe bereit, um die lokalen Kopien Ihrer Secretszu aktualisieren. Weitere Informationen finden Sie unter Rotieren von AWS Secrects Manager-Secrets im AWS Secrets Manager-Benutzerhandbuch.

So machen Sie ein Secret auf dem Greengrass-Core verfügbar

1. Erstellen Sie ein Secret in Secrets Manager. Das ist die Cloud-Version Ihres Secrets, die im SecretsManager zentral gespeichert und verwaltet wird. Zu den Verwaltungsaufgaben gehören das Rotieren vongeheimen Werten und das Anwenden von Ressourcenrichtlinien.

2. Erstellen Sie eine Secret-Ressource in AWS IoT Greengrass. Dies ist ein Gruppenressourcentyp,der über den ARN auf das Cloud-Secret verweist. Sie können ein Secret nur einmal pro Gruppereferenzieren.

3. Konfigurieren Sie Ihren Konnektor oder die Lambda-Funktion. Sie müssen die Ressource mit einemKonnektor oder einer Funktion verknüpfen, indem Sie entsprechende Parameter oder Eigenschaftenangeben. Dadurch kann von ihnen der Wert der lokal bereitgestellten geheimen Ressourceermittelt werden. Weitere Informationen finden Sie unter the section called “Verwenden von lokalenSecrets” (p. 282).

4. Bereitstellen der Greengrass-Gruppe Während der Bereitstellung ruft AWS IoT Greengrass den Wertdes Cloud-Secrets ab und erstellt (oder aktualisiert) das lokale Secret auf dem Kern.

Secrets Manager protokolliert jedes Mal ein Ereignis in AWS CloudTrail, wenn AWS IoT Greengrass einengeheimen Wert abruft. AWS IoT Greengrass protokolliert keine Ereignisse in Zusammenhang mit derBereitstellung oder Verwendung lokalen Secrets. Weitere Informationen über die Protokollierung im SecretsManager finden Sie unter Überwachen der Verwendung Ihrer AWS Secrets Manager-Secrets im AWSSecrets Manager-Benutzerhandbuch.

Einbinden von Staging-Bezeichnungen in geheime RessourcenSecrets Manager verwendet Staging-Bezeichnungen zum Identifizieren spezifischer Versionen einesgeheimen Werts. Staging-Beschriftungen können systemdefiniert oder benutzerdefiniert sein. SecretsManager ordnet die Beschriftung AWSCURRENT der neuesten Version des geheimen Wertes zu. Staging-Beschriftungen werden häufig verwendet, um die Rotation von Secrets zu verwalten. Weitere Informationenüber das Secrets Manager-Versioning finden Sie unter Wichtige Begriffe und Konzepte für AWS SecretsManager im AWS Secrets Manager-Benutzerhandbuch.

Secret-Ressourcen enthalten immer die Staging-Bezeichnung AWSCURRENT und können optionalandere Staging-Bezeichnungen enthalten, wenn sie von einer Lambda-Funktion oder von einem

279

https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html


Konnektor benötigt werden. Während der Gruppenbereitstellung ruft AWS IoT Greengrass die Werteder Staging-Beschriftungen ab, die in der Gruppe referenziert sind, und erstellt oder aktualisiert dann dieentsprechenden Werte auf dem Kern.

Erstellen und Verwalten von geheimen Ressourcen (Konsole)Erstellen von geheimen Ressourcen (Konsole)

In der AWS IoT Greengrass-Konsole erstellen und verwalten Sie geheime Ressourcen auf derRegisterkarte Secrets der Seite Resources (Ressourcen) der Gruppe. Für Tutorials, die eine geheimeRessource erstellen und zu einer Gruppe hinzufügen, siehe the section called “Erstellen einerSecret-Ressource (Konsole)” (p. 284) und the section called “Beginnen Sie mit Konnektoren(Konsole)” (p. 390).

Note

Alternativ können Sie mit der Konsole ein Geheimnis und eine geheime Ressource erstellen, wennSie einen Connector oder eine Lambda-Funktion konfigurieren. Sie können dies über die SeiteConfigure parameters (Parameter konfigurieren) des Connectors oder die Seite Ressourcen derLambda-Funktion durchführen.

Verwalten von geheimen Ressourcen (Konsole)

Zu den Verwaltungsaufgaben für die geheimen Ressourcen in Ihrer Greengrass-Gruppe gehören u. a. dasHinzufügen geheimer Ressourcen zur Gruppe, das Entfernen geheimer Ressourcen aus der Gruppe unddas Ändern des Satzes an Staging-Bezeichnungen (p. 279), die in einer geheimen Ressource enthaltensind.

Wenn Sie auf ein anderes Secret von Secrets Manager verweisen, müssen Sie auch alle Konnektorenbearbeiten, die das Secret verwenden:

1. Wählen Sie auf der Gruppenkonfigurationsseite die Option Connectors (Konnektoren) aus.2. Klicken Sie im Konnektor-Kontextmenü auf Edit (Bearbeiten).3. Die Seite Edit parameters (Parameter bearbeiten) Parameter wird eine Meldung angezeigt, um Sie

zu informieren, dass sich der geheime ARN geändert hat. Wählen Sie Save (Speichern), um dieÄnderung zu bestätigen.

Wenn Sie ein Geheimnis in Secrets Manager löschen, entfernen Sie die entsprechende geheimeRessource aus der Gruppe und von den Connectors und Lambda-Funktionen, die auf sie verweisen.Andernfalls gibt AWS IoT Greengrass bei der Gruppenbereitstellung als Fehler aus, dass das Geheimnisnicht gefunden wird. Aktualisieren Sie bei Bedarf außerdem Ihre Lambda-Funktion.

280


Erstellen und Verwalten von geheimen Ressourcen (CLI)Erstellen von geheimen Ressourcen (CLI)In der AWS IoT Greengrass-API ist ein Secret ist eine Art Gruppenressource. Das folgende Beispielerstellt eine Ressourcendefinition mit einer Startversion, die eine geheime Ressource namensMySecretResource enthält. Ein Tutorial, das eine geheime Ressource erstellt und zu einerGruppenversion hinzufügt, finden Sie unter the section called “Beginnen Sie mit Konnektoren(CLI)” (p. 401).

Die Secret-Ressource verweist auf den ARN des entsprechenden Secrets Manager-Secrets und enthältzwei Staging-Beschriftungen zusätzlich zu AWSCURRENT, die immer enthalten ist.

aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{ "Resources": [ { "Id": "my-resource-id", "Name": "MySecretResource", "ResourceDataContainer": { "SecretsManagerSecretResourceData": { "ARN": "arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-SomeSecret-KUj89s", "AdditionalStagingLabelsToDownload": [ "Label1", "Label2" ] } } } ]}'

Verwalten von geheimen Ressourcen (CLI)Zu den Verwaltungsaufgaben für die geheimen Ressourcen in Ihrer Greengrass-Gruppe gehören u. a. dasHinzufügen geheimer Ressourcen zur Gruppe, das Entfernen geheimer Ressourcen aus der Gruppe unddas Ändern des Satzes an Staging-Bezeichnungen (p. 279), die in einer geheimen Ressource enthaltensind.

In der AWS IoT Greengrass-API werden diese Änderungen mithilfe von Versionen implementiert.

Die AWS IoT Greengrass-API nutzt Versionen für die Gruppenverwaltung. Versionen sind unveränderlich.Wenn Sie also Gruppenkomponenten – z. B. die Geräte, Funktionen und Ressourcen der Gruppe –hinzufügen oder ändern möchten, müssen Sie Versionen von neuen oder aktualisierten Komponentenerstellen. Anschließend erstellen Sie eine Gruppenversion, die die Zielversion jeder Komponente enthält,und stellen sie bereit. Weitere Informationen zu Gruppen finden Sie unter the section called “AWS IoTGreengrass-Gruppen” (p. 6).

So ändern Sie beispielsweise die Staging-Beschriftungen für eine geheime Ressource:

1. Erstellen Sie eine Version einer Ressourcendefinition, die die aktualisierte geheime Ressource enthält.Das folgende Beispiel fügt der geheimen Ressource aus dem vorherigen Abschnitt eine dritte Staging-Beschriftung hinzu.

Note

Um der Version weitere Ressourcen hinzuzufügen, nehmen Sie diese in das Array Resourcesauf.

aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{

281

AWS IoT Greengrass EntwicklerhandbuchVerwenden von lokalen Secrets

"Resources": [ { "Id": "my-resource-id", "Name": "MySecretResource", "ResourceDataContainer": { "SecretsManagerSecretResourceData": { "ARN": "arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-SomeSecret-KUj89s", "AdditionalStagingLabelsToDownload": [ "Label1", "Label2", "Label3" ] } } } ]}'

2. Wenn die ID der geheimen Ressource geändert wird, aktualisieren Sie Konnektoren und Funktionen, diedie geheime Ressource verwenden. Aktualisieren Sie in den neuen Versionen den Parameter oder dieEigenschaft, die der Ressourcen-ID entspricht. Wenn der ARN des Secrets geändert wird, müssen Sieauch den entsprechenden Parameter für alle Konnektoren aktualisieren, die das Secret verwenden.

Note

Die Ressourcen-ID ist ein beliebiger Identifikator, der vom Kunden bereitgestellt wird.3. Erstellen Sie eine Gruppenversion, die die Zielversion jeder Komponente enthält, die Sie an den Kern

senden möchten.4. Bereitstellen der Gruppenversion.

Ein Tutorial, das zeigt, wie man geheime Ressourcen, Konnektoren und Funktionen erstellt und bereitstellt,finden Sie unter the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401).

Wenn Sie ein Geheimnis in Secrets Manager löschen, entfernen Sie die entsprechende geheimeRessource aus der Gruppe und von den Connectors und Lambda-Funktionen, die auf sie verweisen.Andernfalls gibt AWS IoT Greengrass bei der Gruppenbereitstellung als Fehler aus, dass das Geheimnisnicht gefunden wird. Aktualisieren Sie bei Bedarf außerdem Ihre Lambda-Funktion. Sie können ein lokalesSecret entfernen, indem Sie eine Version der Ressourcendefinition bereitstellen, die die entsprechendegeheime Ressource nicht enthält.

Verwenden von lokalen Secrets in Konnektoren undLambda-FunktionenGreengrass-Konnektoren und Lambda-Funktionen verwenden lokale Secrets für die Interaktion mitServices und Anwendungen. Der AWSCURRENT-Wert wird standardmäßig verwendet, es sind aber auchWerte für andere Staging-Bezeichnungen (p. 279) in der Secret-Ressource verfügbar.

Konnektoren und Funktionen müssen konfiguriert werden, bevor sie auf lokale Secrets zugreifen. Dadurchwird die geheime Ressource mit dem Konnektor oder der Funktion verknüpft.

Konnektoren

Wenn ein Konnektor Zugriff auf ein lokales Secret benötigt, stellt er Parameter zur Verfügung, die Siemit den Informationen konfigurieren, die für den Zugriff auf das Secret erforderlich sind.• Informationen, wie dazu in der AWS IoT Greengrass-Konsole vorzugehen ist, finden Sie unter the

section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390).

282

AWS IoT Greengrass EntwicklerhandbuchVerwenden von lokalen Secrets

• Informationen, wie dazu mit der AWS IoT Greengrass-CLI vorzugehen ist, finden Sie unter thesection called “Beginnen Sie mit Konnektoren (CLI)” (p. 401).

Weitere Informationen über die Anforderungen einzelner Konnektoren finden Sie unter the sectioncalled “Von AWS bereitgestellte Greengrass-Konnektoren” (p. 302).

Die Logik für den Zugriff und die Nutzung des Secrets ist in den Konnektor integriert.Lambda-Funktionen

Damit eine Greengrass Lambda-Funktion auf ein lokales Secret zugreifen kann, konfigurieren Sie dieEigenschaften der Funktion.• Informationen, wie dazu in der AWS IoT Greengrass-Konsole vorzugehen ist, finden Sie unter the

section called “Erstellen einer Secret-Ressource (Konsole)” (p. 284).• Dazu stellen Sie in der AWS IoT Greengrass-API die folgenden Informationen in der EigenschaftResourceAccessPolicies zur Verfügung.• ResourceId: Die ID der geheimen Ressource in der Greengrass-Gruppe. Dies ist die Ressource,

die auf den ARN des entsprechenden Secrets Manager-Secrets verweist.• Permission: Die Art des Zugriffs, den die Funktion auf die Ressource hat. Nur die Berechtigungro (schreibgeschützt) wird für geheime Ressourcen unterstützt.

Im folgenden Beispiel wird eine Lambda-Funktion erstellt, die auf die geheime Ressource MyApiKeyzugreifen kann.

aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{ "Functions": [ { "Id": "MyLambdaFunction", "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:myFunction:1", "FunctionConfiguration": { "Pinned": false, "MemorySize": 16384, "Timeout": 10, "Environment": { "ResourceAccessPolicies": [ { "ResourceId": "MyApiKey", "Permission": "ro" } ], "AccessSysfs": true } } } ]}'

Um während der Laufzeit auf lokale Secrets zuzugreifen, rufen Greengrass Lambda-Funktionen dieget_secret_value-Funktion über den secretsmanager-Client im AWS IoT GreengrassCore-SDK (v1.3.0 or later) auf.

Das folgende Beispiel zeigt, wie das AWS IoT GreengrassCore-SDK für Python verwendet wird,um auf ein Secret zuzugreifen. Es übergibt den Namen des Secrets an die get_secret_value-Funktion. SecretId kann der Name oder ARN des Secrets Manager-Secrets (und nicht der Secret-Ressource) sein.

283

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Secret-Ressource (Konsole)

import greengrasssdk # Creating a Greengrass Core SDK clientclient = greengrasssdk.client('secretsmanager') # This handler is called when the function is invoked# It uses the secretsmanager client to get the value of a secretdef function_handler(event, context): response = client.get_secret_value(SecretId='greengrass-MySecret-abc') raw_secret = response.get('SecretString')

Für Secrets vom Typ Text gibt die get_secret_value-Funktion eine Zeichenfolge zurück. FürSecrets des Binärtyps gibt sie eine base64-kodierte Zeichenfolge zurück.

Important

Stellen Sie sicher, dass die benutzerdefinierten Lambda-Funktionen Geheimnisse sicherverarbeiten, und protokollieren Sie keine vertraulichen Daten, die im Geheimnissegespeichert sind. Weitere Informationen finden Sie unter Verhindern von Risiken durchdie Protokollierung oder das Debuggen Ihrer Lambda-Funktion im AWS Secrets Manager-Benutzerhandbuch. Obwohl sich diese Dokumentationen speziell auf Rotationsfunktionenbezieht, gilt die Empfehlung auch für Greengrass Lambda-Funktionen.

Standardmäßig wird der aktuelle Wert des Secrets zurückgegeben. Dies ist die Version,der die AWSCURRENT-Staging-Bezeichnung zugeordnet ist. Um auf eine andere Versionzuzugreifen, übergeben Sie den Namen der zugehörigen Staging-Bezeichnung für das optionaleVersionStage-Argument. Zum Beispiel:

import greengrasssdk # Creating a greengrass core sdk clientclient = greengrasssdk.client('secretsmanager') # This handler is called when the function is invoked# It uses the secretsmanager client to get the value of a specific secret versiondef function_handler(event, context): response = client.get_secret_value(SecretId='greengrass-MySecret-abc', VersionStage='MyTargetLabel') raw_secret = response.get('SecretString')

Eine weitere Beispielfunktion, die get_secret_value aufruft, finden Sie unter Erstellen einesBereitstellungspakets für eine Lambda-Funktion (p. 288).

Erstellen einer Secret-Ressource (Konsole)Diese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

In diesem Tutorial wird gezeigt, wie man mit der AWS Management Console eine geheime Ressource zueiner Greengrass-Gruppe hinzufügt. Eine geheime Ressource ist ein Verweis auf ein Secret aus dem AWSSecrets Manager. Weitere Informationen finden Sie unter Secrets für Core bereitstellen (p. 274).

Auf dem AWS IoT Greengrass-Core-Gerät können Connectors und Lambda-Funktionen die geheimeRessource für die Authentifizierung bei Services und Anwendungen verwenden, ohne Passwörter, Tokenoder andere Anmeldeinformationen fest kodieren zu müssen.

In diesem Tutorial erstellen Sie zunächst ein Secret in der AWS Secrets Manager-Konsole. Anschließendkönnen Sie in der AWS IoT Greengrass-Konsole eine Secret-Ressource von der Seite Resources

284




(Ressourcen) der Gruppe einer Greengrass-Gruppe hinzufügen. Diese Secret-Ressource verweist auf dasSecrets Manager-Secret. Danach ordnen Sie die Secret-Ressource einer Lambda-Funktion zu, wodurchdie Funktion den Wert des lokalen Secrets erhält.

Note

Alternativ können Sie mit der Konsole ein Geheimnis und eine geheime Ressource erstellen, wennSie einen Connector oder eine Lambda-Funktion konfigurieren. Sie können dies über die SeiteConfigure parameters (Parameter konfigurieren) des Connectors oder die Seite Ressourcen derLambda-Funktion durchführen.Nur Konnektoren, die Parameter für Secrets enthalten, können auf Secrets zugreifen. EinTutorial, das zeigt, wie der Twilio-Benachrichtigungen-Konnektor ein lokal gespeichertesAuthentifizierungstoken verwendet, finden Sie unter the section called “Beginnen Sie mitKonnektoren (Konsole)” (p. 390).


1. Erstellen eines Secrets Manager-Secrets (p. 285)2. Hinzufügen einer geheimen Ressource zu einer Gruppe (p. 287)3. Erstellen eines Bereitstellungspakets für eine Lambda-Funktion (p. 288)4. Erstellen Sie eine Lambda-Funktion (p. 289)5. Hinzufügen der Funktion zur Gruppe (p. 291)6. Verknüpfen der Secret-Ressource mit der Funktion (p. 291)7. Hinzufügen von Abonnements zur Gruppe (p. 292)8. Bereitstellen der Gruppe (p. 293)

Für dieses Tutorial benötigen Sie ungefähr 20 Minuten.


• Eine Greengrass-Gruppe und ein Greengrass-Core (v1.7 or later). Weitere Informationen zumErstellen einer Greengrass-Gruppe und Greengrass Core finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69). Das Tutorial „Erste Schritte“ enthält auch die Schritte zur Installation der AWS IoTGreengrass Core-Software.

• AWS IoT Greengrass muss für die Unterstützung lokaler Secrets konfiguriert sein. Weitere Informationenfinden Sie unter Anforderungen für Secrets (p. 276).

Note

Dazu gehört die Gewährung des Zugriffs auf Ihre Secrets Manager-Secrets. Wenn Sie diestandardmäßige Greengrass-Servicerolle verwenden, hat Greengrass bereits Zugriff auf dieWerte von Secrets mit Namen, die mit greengrass- beginnen.

• Um die Werte der lokalen Geheimnisse zu erhalten, müssen die benutzerdefinierten Lambda-FunktionenAWS IoT GreengrassCore-SDK v1.3.0 or later verwenden.

Schritt 1: Erstellen eines Secrets Manager-SecretsIn diesem Schritt erstellen Sie mithilfe der AWS Secrets Manager-Konsole ein Secret.

1. Melden Sie sich bei der AWS Secrets Manager-Konsole an.

285

https://console.aws.amazon.com/secretsmanager/

AWS IoT Greengrass EntwicklerhandbuchErstellen eines Secrets Manager-Secrets

Note

Weitere Informationen zu diesem Prozess finden Sie unter Schritt 1: Erstellen und SpeichernIhres Secrets in AWS Secrets Manager im AWS Secrets Manager-Benutzerhandbuch.

2. Wählen Sie Store a new secret (Ein neues Secret speichern).3. Wählen Sie unter Select secret type (Secret-Typ auswählen) die Option Other type of secrets (Anderer

Secret-Typ) aus.4. Unter Specify the key/value pairs to be stored for this secret (Angabe der Schlüssel/Wert-Paare, die für

dieses Secret gespeichert werden sollen):

• Geben Sie für Key (Schlüssel) test ein.• Geben Sie für Value (Wert) abcdefghi ein.

5. Belassen Sie DefaultEncryptionKey für den Verschlüsselungscode ausgewählt und wählen Sie Next(Weiter).

Note

Wenn Sie den von AWS verwalteten Standardschlüssel verwenden, den Secrets Manager inIhrem Konto erstellt, wird Ihnen dies von AWS KMS nicht berechnet.

6. Geben Sie für Secret name (Secret-Name) greengrass-TestSecret ein und klicken Sie auf Next(Weiter).

Note

Standardmäßig erlaubt die Greengrass-Servicerolle AWS IoT Greengrass den Abruf vonSecrets mit Namen, die mit greengrass- beginnen. Weitere Informationen finden Sie unterAnforderungen für Secrets.

7. Dieses Tutorial erfordert keine Rotation. Wählen Sie also Disable automatic rotation (AutomatischeRotation deaktivieren) und danach Next (Weiter) aus.

286

https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html


AWS IoT Greengrass EntwicklerhandbuchHinzufügen einer geheimen Ressource zu einer Gruppe

8. Prüfen Sie auf der Seite Review (Prüfen) Ihre Einstellungen und wählen Sie Store (Speichern).

Als nächstes erstellen Sie in Ihrer Greengrass-Gruppe eine geheime Ressource, die auf das Secretverweist.

Schritt 2: Hinzufügen einer geheimen Ressource zueiner Greengrass-GruppeIn diesem Schritt konfigurieren Sie eine Gruppenressource, die auf das Secrets Manager-Secret verweist.

1. Wählen Sie in der AWS IoT-Konsole Greengrass und dann Groups.2. Wählen Sie die Gruppe, zu der Sie die geheime Ressource hinzufügen möchten.3. Klicken Sie auf der Gruppenkonfigurationsseite auf Resources (Ressourcen) und wählen Sie dann

Secret. Auf dieser Registerkarte werden die geheimen Ressourcen angezeigt, die zur Gruppe gehören.Auf dieser Registerkarte können Sie geheime Ressourcen hinzufügen, bearbeiten und entfernen.

Note

Alternativ können Sie mit der Konsole ein Geheimnis und eine geheime Ressource erstellen,wenn Sie einen Connector oder eine Lambda-Funktion konfigurieren. Sie können dies überdie Seite Configure parameters (Parameter konfigurieren) des Connectors oder die SeiteRessourcen der Lambda-Funktion durchführen.

4. Wählen Sie Add a secret resource (Auswählen einer geheimen Ressource).5. Wählen Sie auf der Seite Add a secret resource to your group (Hinzufügen einer geheimen Ressource

zu Ihrer Gruppe) Select (Auswählen), und wählen Sie dann greengrass-TestSecret.

287

AWS IoT Greengrass EntwicklerhandbuchErstellen eines Bereitstellungspakets

für eine Lambda-Funktion

6. Wählen Sie auf der Seite Select labels (Optional) (Bezeichnungen auswählen) aus und wählen Siedann Next (Weiter) aus. Das Staging-Label AWSCURRENT stellt die neueste Version des Secrets dar.Dieses Label ist immer in einer geheimen Ressource enthalten.

Note

Dieses Tutorial erfordert nur das Label AWSCURRENT. Sie können optional Bezeichnungenhinzufügen, die von Ihrer Lambda-Funktion oder vom Konnektor benötigt werden.

7. Geben Sie auf der Seite Name your secret resource (Name Ihrer geheimen Ressource eingeben)MyTestSecret ein und klicken Sie dann auf Save (Speichern).

Schritt 3: Erstellen eines Bereitstellungspakets für eineLambda-FunktionUm eine Lambda-Funktion zu erstellen, müssen Sie zunächst ein Lambda-Funktions-Bereitstellungspaketerstellen, das den Funktionscode und die Abhängigkeiten enthält. Greengrass Lambda-Funktionenerfordern das AWS IoT Greengrass-Core-SDK (p. 177) für Aufgaben wie die Kommunikation mit MQTT-Nachrichten in der Core-Umgebung oder den Zugriff auf lokale Geheimnisse. In diesem Tutorial wird einePython-Funktion erstellt. Folglich verwenden Sie die Python-Version des SDK im Bereitstellungspaket.

Note

Um die Werte der lokalen Geheimnisse zu erhalten, müssen die benutzerdefinierten Lambda-Funktionen AWS IoT GreengrassCore-SDK v1.3.0 or later verwenden.



3. Speichern Sie die folgende Pythoncode-Funktion in einer lokalen Datei namens secret_test.py.

import greengrasssdk # Create SDK clients.secrets_client = greengrasssdk.client('secretsmanager')message_client = greengrasssdk.client('iot-data')message = ''

# This handler is called when the function is invoked.# It uses the 'secretsmanager' client to get the value of the test secret using the secret name.

288

AWS IoT Greengrass EntwicklerhandbuchErstellen Sie eine Lambda-Funktion

# The test secret is a text type, so the SDK returns a string. # For binary secret values, the SDK returns a base64-encoded string.def function_handler(event, context): response = secrets_client.get_secret_value(SecretId='greengrass-TestSecret') secret_value = response.get('SecretString') if secret_value is None: message = 'Failed to retrieve secret.' else: message = 'Success! Retrieved secret.' message_client.publish(topic='secrets/output', payload=message) print('published: ' + message)

Die Funktion get_secret_value unterstützt den Namen oder den ARN des SecretsManager-Secrets für den SecretId-Wert. Dieses Beispiel verwendet den Namen des Secrets.Für dieses Beispiel-Secret gibt AWS IoT Greengrass das Schlüssel-Werte-Paar zurück:{"test":"abcdefghi"}.

Important

Stellen Sie sicher, dass die benutzerdefinierten Lambda-Funktionen Geheimnisse sicherverarbeiten, und protokollieren Sie keine vertraulichen Daten, die im Geheimnisse gespeichertsind. Weitere Informationen finden Sie unter Verhindern von Risiken durch die Protokollierungoder das Debuggen Ihrer Lambda-Funktion im AWS Secrets Manager-Benutzerhandbuch.Obwohl sich diese Dokumentationen speziell auf Rotationsfunktionen bezieht, gilt dieEmpfehlung auch für Greengrass Lambda-Funktionen.

4. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen secret_test_python.zip.Schließen Sie beim Erstellen einer ZIP-Datei nur den Code und die Abhängigkeiten ein, nicht dendazugehörigen Ordner.

• secret_test.py. App-Logik.• greengrasssdk. Erforderliche Bibliothek für alle Python-Greengrass Lambda-Funktionen.

Dies ist das Bereitstellungspaket für Ihre Lambda-Funktion.

Schritt 4: Erstellen von einer Lambda-FunktionIn diesem Schritt erstellen Sie mithilfe der AWS Lambda-Konsole eine Lambda-Funktion und konfigurierendiese zur Verwendung des Bereitstellungspakets. Anschließend veröffentlichen Sie eine Funktionsversionund erstellen einen Alias.

1. Zunächst erstellen Sie die Lambda-Funktion.

a. Wählen Sie in der AWS Management Console Services und öffnen Sie die AWS Lambda-Konsole.b. Wählen Sie Create function und Author from scratch aus.c. Verwenden Sie im Abschnitt Basic information (Basisinformationen) folgende Werte:

• Geben Sie für Function name (Funktionsname) SecretTest ein.• Wählen Sie für Runtime die Option Python 2.7 aus.• Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eine


d. Wählen Sie unten auf der Seite Create function aus.2. Registrieren Sie jetzt den Handler und laden Sie Ihr Bereitstellungspaket für die Lambda-Funktion

hoch.

289




a. Geben Sie auf der Registerkarte Configuration (Konfiguration) für die Funktion "SecretTest" unterFunction code (Funktionscode) folgende Werte an:


• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie unter Handler secret_test.function_handler ein.

b. Wählen Sie Upload aus.c. Wählen Sie das Bereitstellungspaket secret_test_python.zip aus.d. Wählen Sie Save aus.

Note


Tip

Sie sehen Ihren Code im Abschnitt Function code (Funktionscode), indem Sie im MenüCode entry type (Codeeingabetyp) die Option Edit code inline (Code inline bearbeiten)auswählen.

3. Veröffentlichen Sie jetzt die erste Version der Lambda-Funktion und erstellen Sie einen Alias für dieVersion.

Note


a. Wählen Sie im Menü Actions die Option Publish new version aus.b. Geben Sie unter Version description (Versionsbeschreibung) den Wert First version ein und

wählen Sie dann Publish (Veröffentlichen) aus.c. Wählen Sie auf der Konfigurationsseite für SecretTest: 1 im Menü Actions (Aktionen) die Option

Create alias (Alias erstellen) aus.d. Geben Sie auf der Seite Create a new alias folgende Werte an:

• Geben Sie unter Name GG_SecretTest ein.• Wählen Sie für Version die Option 1.

Note

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen.e. Wählen Sie Create aus.

Jetzt sind Sie bereit, die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzuzufügen und die geheimeRessource anzufügen.

290



AWS IoT Greengrass EntwicklerhandbuchHinzufügen der Funktion zur Gruppe

Schritt 5: Hinzufügen der Lambda-Funktion zurGreengrass-GruppeIn diesem Schritt fügen Sie die Lambda-Funktion zur Greengrass-Gruppe im AWS IoT-Konsole hinzu.



3. Wählen Sie auf der Seite Use existing Lambda (Vorhandene Lambda verwenden) den EintragSecretTest aus und klicken Sie auf Next (Weiter).

4. Wählen Sie auf der Seite Select a Lambda version (Lambda-Version auswählen) die OptionAlias:GG_SecretTest aus und klicken Sie auf Finish (Fertigstellen).

Verknüpfen Sie danach die Secret-Ressource mit der Funktion.

Schritt 6: Verknüpfen der Secret-Ressource mit derLambda-FunktionIn diesem Schritt verknüpfen Sie die Secret-Ressource mit der Lambda-Funktion in der Greengrass-Gruppe. Auf diese Weise wird die Ressource der Funktion zugeordnet, wodurch die Funktion den Wert deslokalen Secrets erhalten kann.

1. Wählen Sie auf der Seite Lambdas der Gruppe die Funktion SecretTest.2. Wählen Sie auf der Details-Seite der Funktion nacheinander Resources (Ressourcen), Secret und

dann Attach a secret resource (Eine Secret-Ressource anfügen) aus.

291


3. Wählen Sie auf der Seite Attach a secret resource to your LAM function (Anfügen einer geheimenRessource zu Ihrer Lambda-Funktion) die Option Choose secret resource (Geheime Ressourceauswählen).

4. Wählen Sie auf der Seite Select a secret resource from your group (Auswählen einer geheimenRessource von Ihrer Gruppe) MyTestSecret, und wählen Sie dann Save (Speichern).

Schritt 7: Hinzufügen von Abonnements zurGreengrass-GruppeIn diesem Schritt fügen Sie Abonnements hinzu, die den Nachrichtenaustausch zwischen AWS IoT undder Lambda-Funktion ermöglichen. Ein Abonnement ermöglicht es AWS IoT, die Funktion aufzurufen, undeines ermöglicht es der Funktion, Ausgabedaten an AWS IoT zu senden.


2. Erstellen Sie ein Abonnement, das es AWS IoT ermöglicht, Nachrichten an die Funktion zuveröffentlichen.

Konfigurieren Sie auf der Seite Select your source and target (Wählen Sie Ihre Quelle und Ziel) dieQuelle und das Ziel:


b. Wählen Sie für Ein Ziel auswählen die Option Lambdas und dann SecretTest aus.c. Wählen Sie Next.

292


3. Geben Sie auf der Seite Filter your data with a topic (Filtern Sie Ihre Daten nach einem Thema.) fürTopic filter (Themenfilter) secrets/input ein und wählen Sie dann Next (Weiter).

4. Wählen Sie Finish aus.5. Wiederholen Sie die Schritte 1 - 4, um ein Abonnement zu erstellen, das es der Funktion ermöglicht,

den Status an AWS IoT zu veröffentlichen.

a. Wählen Sie für Eine Quelle auswählen die Option Lambdas und dann SecretTest aus.b. Wählen Sie für Select a target (Ein Ziel auswählen) die Option Services und dann IoT Cloud aus.c. Geben Sie für Topic filter (Themenfilter) die Zeichenfolge secrets/output ein.

Schritt 8: Bereitstellen der Greengrass-GruppeStellen Sie die Gruppe auf dem Core-Gerät bereit. Während der Bereitstellung ruft AWS IoT Greengrassden Wert des Secrets von Secrets Manager ab und erstellt auf dem Core eine lokale verschlüsselte Kopie.





Note






293

AWS IoT Greengrass EntwicklerhandbuchTesten der Funktion


Note


Auf der Seite Deployments werden der Zeitstempel, die Versions-ID und der Status der Bereitstellungangegeben. Nach abgeschlossener Bereitstellung sollte der Status Successfully completed lauten.


Testen der Funktion1. Wählen Sie auf der AWS IoT-Konsole-Startseite die Option Test.

294

AWS IoT Greengrass EntwicklerhandbuchTesten der Funktion

2. Verwenden Sie für Subscriptions (Abonnements) die folgenden Werte und wählen Sie dann Subscribeto topic (Abonnement für Thema).

Eigenschaft Wert

Abonnementthema secrets/output

MQTT-Nutzlast-Anzeige Zeigt Nutzlasten als Zeichenfolgen an

3. Verwenden Sie für Publish (Veröffentlichen) die folgenden Werte, und wählen Sie dann Publish to topic(Zum Thema veröffentlichen), um die Funktion aufzurufen.

Eigenschaft Wert

Thema secrets/input

Nachricht Behalten der Standardnachricht. DasVeröffentlichen einer Nachricht ruft die Lambda-Funktion auf, aber die Funktion in diesemTutorial verarbeitet den Nachrichtentext nicht.

Im Erfolgsfall veröffentlicht die Funktion eine "Success"-Meldung.

295


Weitere Informationen finden Sie auch unter:• Secrets für Core bereitstellen (p. 274)

296


Integrieren von Services undProtokollen mit Greengrass-Konnektoren


Greengrass-Konnektoren sind vorkonfigurierte Module, die helfen, den Entwicklungslebenszyklus fürgängige Edge-Szenarien zu beschleunigen. Sie erleichtern die Interaktion mit der lokalen Infrastruktur,Geräteprotokollen, AWS und anderen Cloud-Services. Mit Konnektoren können Sie weniger Zeit mitdem Erlernen neuer Protokolle und APIs verbringen und mehr Zeit für die Logik verwenden, die für IhrUnternehmen wichtig ist.

Das folgende Diagramm zeigt, an welcher Stelle Konnektoren in die AWS IoT Greengrass-Umgebungpassen.

Viele Konnektoren verwenden MQTT-Nachrichten, um mit Geräten und Greengrass Lambda-Funktionen inder Gruppe oder mit AWS IoT und dem lokalen Schattendienst zu kommunizieren. Im folgenden Beispielempfängt der Twilio-Benachrichtigungen-Konnektor MQTT-Nachrichten von einer benutzerdefiniertenLambda-Funktion, verwendet eine lokale Referenz eines Secrets von AWS Secrets Manager und ruft dieTwilio-API auf.

297


Ein Tutorial zum Erstellen dieser Lösung finden Sie unter the section called “Beginnen Sie mit Konnektoren(Konsole)” (p. 390) und the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401).

Greengrass-Konnektoren können Ihnen helfen, die Gerätefunktionen schnell zu erweitern oder Einzweck-Geräte zu erstellen. Konnektoren können Folgendes erleichtern:

• Implementieren einer wiederverwendbaren Geschäftslogik.• Interagieren mit Cloud und lokalen Services, einschließlich AWS und Drittanbieter-Services.• Erfassen und Verarbeiten von Gerätedaten.• Aktivieren von Gerät-zu-Gerät-Aufrufen mithilfe von MQTT-Themenabonnements und

benutzerdefinierten Lambda-Funktionen.

AWS bietet eine Reihe von Greengrass-Konnektoren, die die Interaktion mit gängigen Services undDatenquellen vereinfachen. Diese vorgefertigten Module ermöglichen Szenarien für Protokollierungund Diagnose, Nachschubplanung, industrielle Datenverarbeitung sowie für Alarm und Meldung.Weitere Informationen finden Sie unter the section called “Von AWS bereitgestellte Greengrass-Konnektoren” (p. 302).

VoraussetzungenFür Konnektoren gelten folgende Anforderungen:

• Sie müssen die AWS IoT Greengrass-Core Software v1.7 or later verwenden.• Sie müssen die Anforderungen der einzelnen Konnektoren erfüllen, die Sie verwenden. Diese

Anforderungen können Gerätevoraussetzungen, erforderliche Berechtigungen und Einschränkungenbeinhalten. Weitere Informationen finden Sie unter the section called “Von AWS bereitgestellteGreengrass-Konnektoren” (p. 302).

• Eine Greengrass-Gruppe kann nur eine konfigurierte Instance eines bestimmten Konnektors enthalten,aber die Instance kann in mehreren Abonnements verwendet werden. Weitere Informationen finden Sieunter the section called “Konfigurationsparameter” (p. 300).

• Konnektoren werden nicht unterstützt, wenn die Greengrass-Gruppe zur Ausführung ohneContainerisierung konfiguriert ist. Weitere Informationen finden Sie unter the section called “Steuern derGreengrass Lambda-Funktionsausführung” (p. 179).

Verwenden von AWS IoT Greengrass-KonnektorenEin Konnektor ist ein Typ einer Gruppenkomponente. Wie bei anderen Gruppenkomponenten, z. B. Geräteund benutzerdefinierte Lambda-Funktionen, fügen Sie Konnektoren zu Gruppen hinzu, konfigurieren ihreEinstellungen und stellen sie für AWS IoT Greengrass-Core bereit. Konnektoren werden in der Core-Umgebung ausgeführt.

Einige Konnektoren können als einfache, eigenständige Anwendungen bereitgestellt werden.Beispielsweise liest der Device Defender-Konnektor Systemmetriken vom Core-Gerät und sendet sie zurAnalyse an AWS IoT Device Defender.

Andere Konnektoren können als Bausteine in größeren Lösungen verwendet werden. Die folgendeBeispiellösung verwendet den Modbus-RTU-Protokolladapter-Konnektor zur Verarbeitung von Meldungenvon Sensoren und den Twilio-Benachrichtigungen-Konnektor zur Auslösung von Twilio-Meldungen.

298

AWS IoT Greengrass EntwicklerhandbuchVerwenden von AWS IoT Greengrass-Konnektoren

Lösungen beinhalten oft benutzerdefinierte Lambda-Funktionen, die sich neben den Konnektoren befindenund die Daten verarbeiten, die der Konnektor sendet oder empfängt. In diesem Beispiel empfängt dieTempMonitor-Funktion Daten von Modbus-RTU-Protokolladapter, führt einige Geschäftslogik aus undsendet dann Daten an Twilio-Benachrichtigungen.

Um eine Lösung zu erstellen und bereitzustellen, folgen Sie diesem allgemeinen Prozess:

1. Bilden Sie den übergeordneten Datenfluss ab. Identifizieren Sie die Datenquellen, Datenkanäle,Services, Protokolle und Ressourcen, mit denen Sie arbeiten müssen. In der Beispiellösung beinhaltetdies Daten über das Modbus RTU-Protokoll, die physikalische serielle Modbus-Schnittstelle und Twilio.

2. Identifizieren Sie die Konnektoren, die in die Lösung aufgenommen werden sollen, und fügen Siesie zu Ihrer Gruppe hinzu. Das Beispiellösung verwendet Modbus-RTU-Protokolladapter und Twilio-Benachrichtigungen. Damit Sie die Konnektoren leichter finden, die auf Ihr Szenario zutreffen, und ummehr über deren individuelle Anforderungen zu erfahren, konsultieren Sie die the section called “VonAWS bereitgestellte Greengrass-Konnektoren” (p. 302).

3. Identifizieren Sie, ob benutzerdefinierte Lambda-Funktionen, Geräte oder Ressourcen benötigt werden,und erstellen Sie sie dann und fügen Sie sie der Gruppe hinzu. Dies kann Funktionen beinhalten, dieGeschäftslogik enthalten oder Daten in ein Format verarbeiten, das von einer anderen Entity in derLösung benötigt wird. Die Beispiellösung verwendet Funktionen, um Modbus RTU-Anforderungen zusenden und Twilio-Benachrichtigungen auszulösen. Sie enthält auch eine lokale Geräteressource für dieserielle Schnittstelle Modbus RTU und eine geheime Ressource für das Twilio-Authentifizierungstoken.

Note

Eine geheime Ressource meint Passwörter, Token und andere Secrets vom AWS SecretsManager. Secrets können von Konnektoren und Lambda-Funktionen für die Authentifizierungbei Services und Anwendungen verwendet werden. Standardmäßig kann AWS IoT Greengrassauf Secrets mit Namen zugreifen, die mit "greengrass-" beginnen. Weitere Informationen findenSie unter Secrets für Core bereitstellen (p. 274).

4. Erstellen Sie Abonnements, die es den Entitäten in der Lösung ermöglichen, MQTT-Nachrichtenauszutauschen. Wenn ein Konnektor in einem Abonnement verwendet wird, müssen der Konnektorund die Nachrichtenquelle oder das Ziel die vordefinierte Themensyntax verwenden, die von demKonnektor unterstützt wird. Weitere Informationen finden Sie unter the section called “Inputs undOutputs” (p. 301).

5. Bereitstellen der Gruppe auf Greengrass Core.

Informationen zum Erstellen und Bereitstellen eines Konnektors finden Sie in den folgenden Tutorials:

299

AWS IoT Greengrass EntwicklerhandbuchKonfigurationsparameter

• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)

KonfigurationsparameterViele Konnektoren stellen Parameter bereit, mit denen Sie Verhalten oder Ausgabe anpassen können.Diese Parameter werden während der Initialisierung, zur Laufzeit oder zu anderen Zeiten im Lebenszyklusdes Konnektors verwendet.

Die Parametertypen und -verwendung variieren je nach Konnektor. Beispielsweise hat der SNS-Konnektoreinen Parameter, der das Standard-SNS-Thema konfiguriert, und Device Defender hat einen Parameter,der die Datenabtastrate konfiguriert.

Eine Gruppenversion kann mehrere Konnektoren enthalten, aber nur eine Instance eines bestimmtenKonnektor auf einmal. Dies bedeutet, dass jeder Konnektor in der Gruppe nur über eine aktiveKonfiguration verfügen kann. Die Konnektor-Instance kann jedoch in mehreren Abonnements in der Gruppeverwendet werden. Beispiel: Sie können Abonnements erstellen, die es vielen Geräten ermöglichen, Datenan den Kinesis Firehose-Konnektor zu senden.

Parameter für den Zugriff auf GruppenressourcenGreengrass-Konnektoren verwenden Gruppenressourcen für den Zugriff auf das Dateisystem, Ports,Peripheriegeräte und andere lokale Ressourcen auf dem Core-Gerät. Wenn ein Konnektor den Zugriff aufeine Gruppenressource erfordert, stellt er zugehörige Konfigurationsparameter zur Verfügung.

Gruppenressourcen beinhalten:

• Lokale Ressourcen (p. 204). Verzeichnisse, Dateien, Ports, Pins und Peripheriegeräte, die auf demGreengrass Core-Gerät vorhanden sind.

• Ressourcen für maschinelles Lernen (p. 227). Machine Learning-Modelle, die in der Cloud geschult undfür den Core für lokale Inferenzen bereitgestellt werden.

• Geheime Ressourcen (p. 274). Lokale, verschlüsselte Kopien von Passwörtern, Schlüsseln, Token oderbeliebigem Text aus AWS Secrets Manager. Konnektoren können auf diese lokalen Geheimnisse sicherzugreifen und sie verwenden, um sich auf Services oder in der lokalen Infrastruktur zu authentifizieren.

Beispielsweise ermöglichen Parameter für Device Defender den Zugriff auf Systemmetriken im Host-Verzeichnis /proc und Parameter für Twilio-Benachrichtigungen den Zugriff auf einen lokal gespeichertenTwilio-Authentifizierungstoken.

Aktualisieren von Konnektor-ParameternDie Parameter werden konfiguriert, wenn der Konnektor zu einer Greengrass-Gruppe hinzugefügt wird. Siekönnen die Parameterwerte ändern, nachdem der Konnektor hinzugefügt wurde.

• In der Konsole: Öffnen Sie auf der Gruppenkonfigurationsseite Connectors (Konnektoren) und wählenSie im Kontextmenü des Konnektors Edit (Bearbeiten) aus.

Note

Wenn der Konnektor eine geheime Ressource verwendet, die später geändert wird, um auf einanderes Secret zu verweisen, müssen Sie die Parameter des Konnektors bearbeiten und dieÄnderung bestätigen.

• In der API: Erstellen Sie eine weitere Version des Konnektors, die die neue Konfiguration definiert.

300

AWS IoT Greengrass EntwicklerhandbuchInputs und Outputs

Die AWS IoT Greengrass-API nutzt Versionen für die Gruppenverwaltung. Versionen sindunveränderlich. Wenn Sie also Gruppenkomponenten – z. B. die Geräte, Funktionen und Ressourcender Gruppe – hinzufügen oder ändern möchten, müssen Sie Versionen von neuen oder aktualisiertenKomponenten erstellen. Anschließend erstellen Sie eine Gruppenversion, die die Zielversion jederKomponente enthält, und stellen sie bereit.

Nachdem Sie Änderungen an der Konnektor-Konfiguration der Gruppe vorgenommen haben, müssen Siedie Gruppe bereitstellen, damit die Änderungen zum Core propagiert werden.

Inputs und OutputsGreengrass-Konnektoren können mit anderen Entitäten kommunizieren, indem sie MQTT-Nachrichtensenden und empfangen. Diese Kommunikation wird durch Abonnements gesteuert, die dem Konnektorden Austausch von Daten mit Lambda-Funktionen und Geräten in der Gruppe oder mit AWS IoT unddem Service lokaler Schatten ermöglichen. Weitere Informationen finden Sie unter the section called“Konfigurieren von Abonnements” (p. 121).

Konnektoren können Mitteilungsabonnenten, Mitteilungsveröffentlicher oder beides sein. Jeder Konnektordefiniert die Themen, die er abonniert oder veröffentlicht. Diese vordefinierten Themen müssen in denAbonnements verwendet werden, wobei der Konnektor eine Nachrichtenquelle oder ein Nachrichtenziel ist.Tutorials mit den Schritten für die Konfiguration von Abonnements für einen Konnektor finden Sie unter thesection called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390) und the section called “Beginnen Siemit Konnektoren (CLI)” (p. 401).

Note

Viele Konnektoren haben auch eingebaute Kommunikationsmodi, um mit Cloud- oder lokalenServices zu interagieren. Diese variieren je nach Konnektor und können erfordern, dassSie Parameter konfigurieren oder der Gruppenrolle Berechtigungen hinzufügen. WeitereInformationen zu den Anforderungen für Konnektoren finden Sie unter the section called “VonAWS bereitgestellte Greengrass-Konnektoren” (p. 302).

Input-ThemenDie meisten Konnektoren empfangen Eingabedaten zu MQTT-Themen. Einige Konnektoren abonnierenmehrere Themen für Eingabedaten. Beispielsweise unterstützt der Serial Stream-Konnektor zwei Themen:

• serial/+/read/#

• serial/+/write/#

Für diesen Konnektor werden Lese- und Schreibanforderungen an das zugehörige Thema gesendet.Wenn Sie Abonnements erstellen, stellen Sie sicher, dass Sie das Thema verwenden, das zu IhrerImplementierung passt.

Die Zeichen + und # in den vorherigen Beispielen sind Platzhalter. Diese Platzhalter ermöglichen esAbonnenten, Nachrichten zu mehreren Themen zu empfangen, und Herausgebern, die Themen, zu denensie veröffentlichen, anzupassen.

• Der Platzhalter + kann an beliebiger Stelle in der Themenhierarchie erscheinen. Es kann durch einHierarchie-Element ersetzt werden.

Zum Beispiel können für das Thema sensor/+/input Nachrichten zu den Themen sensor/id-123/input veröffentlicht werden, nicht aber zu sensor/group-a/id-123/input.

301

AWS IoT Greengrass EntwicklerhandbuchProtokollierung

• Der # Platzhalter kann nur am Ende der Themenhierarchie erscheinen. Es kann durch null oder mehrHierarchieelemente ersetzt werden..

Zum Beispiel können für das Thema sensor/# Nachrichten zu sensor/, sensor/id-123 undsensor/group-a/id-123 veröffentlicht werden, nicht aber zu sensor.

Platzhalterzeichen sind nur gültig, wenn Sie Themen abonnieren. Nachrichten können nicht zu Themenveröffentlicht werden, die Platzhalter enthalten. Lesen Sie die Dokumentation für den Konnektor, um mehrüber die Anforderungen an das Input- oder Output-Thema zu erfahren. Weitere Informationen finden Sieunter the section called “Von AWS bereitgestellte Greengrass-Konnektoren” (p. 302).

ProtokollierungGreengrass-Konnektoren enthalten Lambda-Funktionen, die Ereignisse und Fehler in Greengrass-Protokolle schreiben. Abhängig von Ihren Gruppeneinstellungen werden Protokolle in CloudWatch Logs,das lokale Dateisystem oder beides geschrieben. Protokolle von Konnektoren enthalten den ARN derentsprechenden Funktion. Nachfolgend finden Sie ein Beispiel eines ARN von dem Kinesis Firehose-Konnektor.

arn:aws:lambda:aws-region:account-id:function:KinesisFirehoseClient:1

Die Standardprotokollierungskonfiguration schreibt Info-Level-Protokolle mit der folgendenVerzeichnisstruktur in das Dateisystem:

greengrass-root/ggc/var/log/user/Region/aws/function-name.log

Weitere Informationen zur Greengrass-Protokollierung finden Sie unter Überwachung (p. 444).

Von AWS bereitgestellte Greengrass-KonnektorenAWS bietet die folgenden Konnektoren, die gängige AWS IoT Greengrass-Szenarien unterstützen. WeitereInformationen zur Funktionsweise von Konnektoren finden Sie in der folgenden Dokumentation:

• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• Beginnen Sie mit Konnektoren (Konsole) (p. 390) oder Beginnen Sie mit Konnektoren (CLI) (p. 401)

Konnektor Beschreibung

CloudWatch-Metriken (p. 303) Veröffentlicht benutzerdefinierte Metriken inAmazon CloudWatch

Device Defender (p. 310) Sendet Systemmetriken an AWS IoT DeviceDefender.

Bildklassifikation (p. 313) Führt einen lokalen Inferenzdienst zurBildklassifizierung aus. Dieser Konnektor bietetVersionen für mehrere Plattformen.

IoT Analytics (p. 324) Sendet Daten von Geräten und Sensoren an AWSIoT Analytics.

302

AWS IoT Greengrass EntwicklerhandbuchCloudWatch-Metriken

Konnektor Beschreibung

Kinesis Firehose (p. 332) Sendet Daten einen Amazon Kinesis DataFirehose-Bereitstellungs-Stream

Modbus-RTU-Protokolladapter (p. 340) Sendet Anfragen an Modbus RTU-Geräte.

Raspberry Pi GPIO (p. 352) Steuert GPIO-Pins auf einem Raspberry Pi-Core-Gerät.

Serial Stream (p. 357) Liest und schreibt über eine serielle Schnittstelleeines Core-Geräts.

ServiceNow MetricBase-Integration (p. 365) Veröffentlicht Zeitreihenmetriken in der ServiceNowMetricBase.

SNS (p. 371) Sendet Nachrichten an ein Amazon SNS-Thema.

Splunk-Integration (p. 376) Veröffentlicht Daten in Splunk HEC.

Twilio-Benachrichtigungen (p. 382) Löst eine Twilio-Text- oder Sprachnachricht aus.

CloudWatch-MetrikenDer CloudWatch-Metriken Konnektor (p. 297) veröffentlicht benutzerdefinierte Metriken von Greengrass-Geräten für Amazon CloudWatch. Der Konnektor bietet eine zentralisierte Infrastruktur für dieVeröffentlichung von CloudWatch-Metriken, mit der Sie die Greengrass Core-Umgebung überwachenund analysieren und auf lokale Ereignisse reagieren können. Weitere Informationen finden Sie unter Verwendung von Amazon CloudWatch-Metriken im Amazon CloudWatch-Benutzerhandbuch.

Dieser Konnektor empfängt Metrikdaten wie MQTT-Nachrichten. Der Konnektor verarbeitet Metriken, diesich im gleichen Namespace befinden, und veröffentlicht sie in regelmäßigen Abständen in CloudWatch.

Dieser Connector hat die folgenden Versionen.

Version ARN

2 arn:aws:greengrass:Region::/connectors/CloudWatchMetrics/versions/2

1 arn:aws:greengrass:Region::/connectors/CloudWatchMetrics/versions/1

Informationen über Versionsänderungen finden Sie im Änderungsprotokoll (p. 309).

VoraussetzungenDieser Konnektor hat die folgenden Anforderungen:

• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktioncloudwatch:PutMetricData erlaubt, wie im folgenden Beispiel gezeigt.

{

303

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html




"Version": "2012-10-17", "Statement": [ { "Sid": "Stmt1528133056761", "Action": [ "cloudwatch:PutMetricData" ], "Effect": "Allow", "Resource": "*" } ]}

Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM Richtlinien im IAM-Benutzerhandbuch und Amazon CloudWatch-Berechtigungs-Referenz im IAM-Benutzerhandbuch.

Konnektor ParameterDieser Konnektor stellt die folgenden Parameter bereit:

PublishInterval

Die maximale Wartezeit in Sekunden, die bis zur Veröffentlichung von Batch-Metriken für einenbestimmten Namespace vergehen kann. Der maximale Wert beträgt 900. Um den Konnektor so zukonfigurieren, dass er Metriken veröffentlicht, sobald sie empfangen werden (ohne Batching), gebenSie 0 an.

Der Konnektor veröffentlicht an CloudWatch, nachdem er 20 Metriken im gleichen Namespaceerhalten hat oder nach dem angegebenen Intervall.

Note

Der Konnektor garantiert nicht die Reihenfolge der veröffentlichten Ereignisse.

Anzeigename in der Konsole: Publish interval (Veröffentlichungsintervall)

Erforderlich: true

Typ: string

Zulässige Werte: 0 - 900

Gültiges Muster: [0-9]|[1-9]\d|[1-9]\d\d|900PublishRegion

Die AWS-Region, in die Metriken an CloudWatch veröffentlicht werden sollen. Dieser Wertüberschreibt die standardmäßige Greengrass-Metrik-Region. Dies ist nur beim Veröffentlichen vonregionsübergreifenden Metriken erforderlich.

Anzeigename in der Konsole: Publish region (Veröffentlichungsregion)

Erforderlich: false

Typ: string

Gültiges Muster: ^$|([a-z]{2}-[a-z]+-\d{1})MemorySize

Der Speicher (in KB), der dem Konnektor zugewiesen werden soll.

Anzeigename in der Konsole: Memory size (Speichergröße)

304


https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/permissions-reference-cw.html


Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$MaxMetricsToRetain

Die maximale Anzahl von Metriken über alle Namespaces hinweg, die im Speicher gespeichert werdenkönnen, bevor sie durch neue Metriken ersetzt werden. Der minimale Wert beträgt 2000.

Diese Begrenzung gilt, wenn keine Verbindung zum Internet besteht und der Konnektor beginnt, dieMetriken zu puffern, um sie später zu veröffentlichen. Wenn der Puffer voll ist, werden die ältestenMetriken durch neue Metriken ersetzt. Metriken in einem bestimmten Namespace werden nur durchMetriken im selben Namespace ersetzt.

Note

Metriken werden nicht gespeichert, wenn der Host-Prozess für den Konnektor unterbrochenwird. Dies kann beispielsweise während der Gruppen-Bereitstellung oder beim Neustart desGeräts geschehen.

Anzeigename in der Konsole: Maximum metrics to retain (Maximale Anzahl der zu erhaltendenMetriken)

Erforderlich: true

Typ: string

Gültiges Muster: ^([2-9]\d{3}|[1-9]\d{4,})$

Beispiel: Erstellen eines Connectors (CLI)Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den CloudWatch-Metriken-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyCloudWatchMetricsConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/CloudWatchMetrics/versions/2", "Parameters": { "PublishInterval" : "600", "PublishRegion" : "us-west-2", "MemorySize" : "16", "MaxMetricsToRetain" : "2500" } } ]}'

Im AWS IoT Greengrass-Konsole können Sie einen Connector von der Seite Connectors (Konnektoren)der Gruppe hinzufügen. Weitere Informationen finden Sie unter the section called “Beginnen Sie mitKonnektoren (Konsole)” (p. 390).

EingabedatenDieser Konnektor akzeptiert Metriken zu einem MQTT-Thema und veröffentlicht die Metriken inCloudWatch. Eingabemeldungen müssen das JSON-Format aufweisen.

305


Themenfilter

cloudwatch/metric/put

Nachrichten-Eigenschaftenrequest

Informationen über die Metrik in dieser Meldung.

Das Anforderungsobjekt enthält die metrischen Daten, die an CloudWatch veröffentlichtwerden sollen. Die metrischen Werte müssen den Spezifikationen der PutMetricData-APIentsprechen. Es werden nur die Eigenschaften namespace, metricData.metricName undmetricData.value benötigt.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:namespace

Der benutzerdefinierte Namespace für die Metrikdaten in dieser Anforderung. CloudWatchverwendet Namespaces als Container für metrische Datenpunkte.

Note

Sie können keinen Namespace angeben, der mit der reservierten Zeichenkette"AWS/" beginnt.

Erforderlich: true

Typ: string

Gültiges Muster: [^:].*metricData

Die Daten für die Metrik.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:metricName

Name der Metrik.

Erforderlich: true

Typ: stringdimensions

Die Dimensionen, die der Metrik zugeordnet sind. Dimensionen liefern zusätzlicheInformationen über die Metrik und ihre Daten. Eine Metrik kann bis zu 10 Dimensionendefinieren.

Erforderlich: false

Typ: array der Dimension-Objekte, die die folgenden Eigenschaften beinhalten:name

Der Dimensionsname.

306

https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html


Erforderlich: false

Typ: stringvalue

Der Dimensionswert.

Erforderlich: false

Typ: stringtimestamp

Der Zeitpunkt, an dem die metrischen Daten empfangen wurden, ausgedrückt als dieAnzahl der Millisekunden seit Jan 1, 1970 00:00:00 UTC. Wenn dieser Wertweggelassen wird, verwendet der Konnektor den Zeitpunkt an dem er die Nachrichtempfangen hat.

Erforderlich: false

Typ: timestampvalue

Der Wert für die Metrik.

Note

CloudWatch lehnt alle Werte ab, die zu klein oder zu groß sind. Die Wertemüssen im Bereich von 8.515920e-109 bis 1.174271e+108 (Base 10) oder2e-360 bis 2e360 (Base 2) liegen. Spezielle Werte (z. B. NaN, +Infinity, -Infinity) werden nicht unterstützt.

Erforderlich: true

Typ: doubleunit

Die Einheit der Metrik.

Erforderlich: false

Typ: string

Zulässige Werte: Seconds, Microseconds, Milliseconds, Bytes,Kilobytes, Megabytes, Gigabytes, Terabytes, Bits, Kilobits,Megabits, Gigabits, Terabits, Percent, Count, Bytes/Second,Kilobytes/Second, Megabytes/Second, Gigabytes/Second, Terabytes/Second, Bits/Second, Kilobits/Second, Megabits/Second, Gigabits/Second, Terabits/Second, Count/Second, None

Beschränkungen

Alle Beschränkungen, die durch die CloudWatch PutMetricData-API auferlegt werden, geltenfür die Metriken bei Verwendung dieses Konnektors. Von besonderer Bedeutung sind die folgendenGrenzwerte:• 40 KB Limit auf API-Nutzlast• 20 Metriken pro API-Anforderung• 150 Transaktionen pro Sekunde (TPS) für die PutMetricData-API

307



Weitere Informationen finden Sie unter CloudWatch Limits im Amazon CloudWatch-Benutzerhandbuch.

Beispieleingabe

{ "request": { "namespace": "Greengrass", "metricData": { "metricName": "latency", "dimensions": [ { "name": "hostname", "value": "test_hostname" } ], "timestamp": 1539027324, "value": 123.0, "unit": "Seconds" } }}

AusgabedatenDieser Connector veröffentlicht Statusinformationen als Ausgabedaten.

Themenfilter

cloudwatch/metric/put/status

Beispielausgabe: Erfolg

Die Antwort beinhaltet den Namespace der metrischen Daten und das Feld RequestId aus derCloudWatch-Antwort.

{ "response": { "cloudwatch_rid":"70573243-d723-11e8-b095-75ff2EXAMPLE", "namespace": "Greengrass", "status":"success" }}

Beispielausgabe: Fehler

{ "response" : { "namespace": "Greengrass", "error": "InvalidInputException", "error_message":"cw metric is invalid", "status":"fail" }}

Note

Wenn der Connector einen wiederholbaren Fehler (etwa einen Verbindungsfehler) erkennt,wird die Veröffentlichung im nächsten Stapel erneut versucht.

308

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_limits.html


VerwendungsbeispielDie folgende Lambda-Beispielfunktion sendet eine Eingabenachricht an den Connector.

Note

Diese Python-Funktion verwendet den AWS IoT GreengrassCore-SDK (p. 177) für dieVeröffentlichung einer MQTT-Meldung. Sie können den folgenden pip-Befehl verwenden, um diePython-Version auf dem SDK auf Ihrem Kerngerät zu installieren.


import greengrasssdkimport timeimport json

iot_client = greengrasssdk.client('iot-data')send_topic = 'cloudwatch/metric/put'

def create_request_with_all_fields(): return { "request": { "namespace": "Greengrass_CW_Connector", "metricData": { "metricName": "Count1", "dimensions": [ { "name": "test", "value": "test" } ], "value": 1, "unit": "Seconds", "timestamp": time.time() } } }

def publish_basic_message(): messageToPublish = create_request_with_all_fields() print "Message To Publish: ", messageToPublish iot_client.publish(topic=send_topic, payload=json.dumps(messageToPublish))

publish_basic_message()


LizenzenDer CloudWatch-Metriken-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:

• AWS SDK für Python (Boto3) / Apache 2.0

Dieser Connector wird im Rahmen der Lizenzvereinbarung für die Greengrass Core-Software bereitgestellt.

ChangelogIn der folgenden Tabelle sind die Änderungen in jeder Version des Connectors beschrieben.

309


https://github.com/boto/boto3


AWS IoT Greengrass EntwicklerhandbuchDevice Defender

Version Änderungen

2 Beheben, um übermäßige Protokollierung zureduzieren.

1 Erstversion.

Eine Greengrass-Gruppe kann jeweils nur eine Version des Connectors enthalten.

Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Verwenden von Amazon CloudWatch-Metriken im Amazon CloudWatch-Benutzerhandbuch• PutMetricData im Amazon CloudWatch API Reference

Device DefenderDer Device Defender-Konnektor (p. 297) benachrichtigt Administratoren über Änderungen im Statuseines Greengrass Core-Geräts. Dies kann helfen, ungewöhnliches Verhalten zu erkennen, das auf eingefährdetes Gerät hinweisen könnte.

Dieser Konnektor liest Systemmetriken aus dem Verzeichnis /proc auf dem Core-Gerät und veröffentlichtdie Metriken dann in AWS IoT Device Defender. Details zur Metrik-Berichterstattung finden Sie unterGeräte-Metrik Dokumentspezifikation im AWS IoT-Entwicklerhandbuch.

ARN: arn:aws:greengrass:Region::/connectors/DeviceDefender/versions/1


• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• AWS IoT Device Defender ist konfiguriert, um die Detect-Funktion zu verwenden, damit Verstöße verfolgt

werden. Weitere Informationen finden Sie unter Detect im AWS IoT-Entwicklerhandbuch.• Ein lokale Volumeressource (p. 204) in der Greengrass-Gruppe, der auf das Verzeichnis /proc zeigt.

Die Ressource muss die folgenden Eigenschaften verwenden:• Quellpfad: /proc• Zielpfad: /host_proc (oder einen Wert, der dem gültigen Muster (p. 311) entspricht)• AutoAddGroupOwner: true

• Die psutil-Bibliothek, die auf dem AWS IoT Greengrass-Core installiert ist. Mit dem folgenden Befehlkönnen Sie sie installieren:

pip install psutil

• Die cbor-Bibliothek, die auf dem AWS IoT Greengrass-Core installiert ist. Mit dem folgenden Befehlkönnen Sie sie installieren:

pip install cbor

310



https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html#DetectMetricsMessagesSpec


https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html

https://pypi.org/project/psutil/

http://cbor.io/



SampleIntervalSeconds

Die Anzahl der Sekunden zwischen jedem Zyklus der Erfassung und Berichterstattung von Metriken.Die Mindestwert beträgt 300 Sekunden (5 Minuten).

Anzeigename in der Konsole: Metrics reporting interval (Metriken Berichterstellungsintervall)

Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]*(?:3[0-9][0-9]|[4-9][0-9]{2}|[1-9][0-9]{3,})$ProcDestinationPath-ResourceId

Die ID der Volume-Ressource /proc.

Note

Dieser Konnektor hat nur Lesezugriff auf die Ressource.

Anzeigename in der Konsole: Resource for /proc directory (Resource für/proc Verzeichnis)

Erforderlich: true

Typ: string

Gültiges Muster: [a-zA-Z0-9_-]+ProcDestinationPath

Der Ziel-Pfad der Volume-Ressource /proc.

Anzeigename in der Konsole: Destination path of /proc resource (Zielpfad von/proc Ressource)

Erforderlich: true

Typ: string

Gültiges Muster: \/[a-zA-Z0-9_-]+

Beispiel: Erstellen eines Connectors (CLI)

Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den DeviceDefender-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyDeviceDefenderConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/DeviceDefender/versions/1", "Parameters": { "SampleIntervalSeconds": "600", "ProcDestinationPath": "/host_proc", "ProcDestinationPath-ResourceId": "my-proc-resource" }

311


} ]}'

Note

Die Lambda-Funktion in diesem Connector hat einen langfristigen (p. 189) Lebenszyklus.


EingabedatenDieser Connector akzeptiert keine MQTT-Nachrichten als Eingabedaten.

AusgabedatenDieser Konnektor veröffentlicht Metriken in AWS IoT Device Defender als Ausgabedaten.

Themenfilter

$aws/things/+/defender/metrics/json

Note

Dies ist die Themensyntax, die AWS IoT Device Defender erwartet. Der Konnektor ersetztden +-Platzhalter durch den Gerätenamen (z. B. $aws/things/thing-name/defender/metrics/json).

Beispielausgabe

Details zur Metrik-Berichterstattung finden Sie unter Geräte-Metrik Dokumentspezifikation im AWS IoT-Entwicklerhandbuch.

{ "header": { "report_id": 1529963534, "version": "1.0" }, "metrics": { "listening_tcp_ports": { "ports": [ { "interface": "eth0", "port": 24800 }, { "interface": "eth0", "port": 22 }, { "interface": "eth0", "port": 53 } ], "total": 3 }, "listening_udp_ports": { "ports": [ { "interface": "eth0",

312

https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-detect.html#DetectMetricsMessagesSpec

AWS IoT Greengrass EntwicklerhandbuchBildklassifikation

"port": 5353 }, { "interface": "eth0", "port": 67 } ], "total": 2 }, "network_stats": { "bytes_in": 1157864729406, "bytes_out": 1170821865, "packets_in": 693092175031, "packets_out": 738917180 }, "tcp_connections": { "established_connections":{ "connections": [ { "local_interface": "eth0", "local_port": 80, "remote_addr": "192.168.0.1:8000" }, { "local_interface": "eth0", "local_port": 80, "remote_addr": "192.168.0.1:8000" } ], "total": 2 } } }}

LizenzenDieser Connector wird im Rahmen der Lizenzvereinbarung für die Greengrass Core-Software bereitgestellt.

Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Device Defender im AWS IoT-Entwicklerhandbuch

BildklassifikationDie Bildklassifikation-Konnektoren (p. 297) stellen einen Machine Learning (ML)-Inferenzservice zurVerfügung, der auf dem AWS IoT Greengrass-Core ausgeführt wird. Dieser lokaler Interferenzserviceführt die Bildklassifizierung mit einem Modell durch, das mit dem Bildklassifizierungsalgorithmus AmazonSageMaker trainiert wurde.

Benutzerdefinierte Lambda-Funktionen verwenden die AWS IoT Greengrass Machine Learning SDK, umInferenzanforderungen an den lokalen Inferenzdienst zu senden. Der Dienst führt die Inferenz lokal aus undgibt die Wahrscheinlichkeit zurück, dass das Eingabebild zu bestimmten Kategorien gehört.

AWS IoT Greengrass stellt Bildklassifikation-Konnektoren für mehrere Plattformen bereit:

313


https://docs.aws.amazon.com/iot/latest/developerguide/device-defender.html


Konnektor Beschreibung und ARN

Bildklassifikation Aarch64 JTX2 Bildklassifikation Inferenzdienst für NVIDIA JetsonTX2. Unterstützt die GPU-Beschleunigung.

ARN: arn:aws:greengrass:Region::/connectors/ImageClassificationAarch64JTX2/versions/1

Bildklassifikation x86_64 Bildklassifikation Inferenzdienst für x86_64Plattformen.

ARN: arn:aws:greengrass:Region::/connectors/ImageClassificationx86-64/versions/1

Bildklassifikation ARMv7 Bildklassifikation Inferenzdienst für ARMv7-Plattformen.

ARN: arn:aws:greengrass:Region::/connectors/ImageClassificationARMv7/versions/1

VoraussetzungenFür diese Konnektoren gelten die folgenden Anforderungen:

• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Abhängigkeiten für das auf dem Core-Gerät installierte Apache MXNet-Framework. Weitere

Informationen finden Sie unter the section called “Installieren von MXNet-Abhängigkeiten” (p. 319).• Eine ML-Ressource (p. 228) in der Greengrass-Gruppe, die auf eine Amazon SageMaker-Modellquelle

verweist. Dieses Modell muss mit dem Bildklassifikationsalgorithmus Amazon SageMaker trainiertwerden. Weitere Informationen finden Sie unter Algorithmus zur Bildklassifizierung im AmazonSageMaker-Entwicklerhandbuch.

• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktionsagemaker:DescribeTrainingJob auf dem Ziel-Trainingsjob erlaubt, wie im folgenden Beispielgezeigt.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "sagemaker:DescribeTrainingJob" ], "Resource": "arn:aws:sagemaker:region:account-id:training-job:training-job-name" } ]}

Sie können Ressourcen granularen oder bedingten Zugriff gewähren 8etwa mit einembenennungsschema mit Platzhaltern *). Wenn Sie den Ziel-Schulungsauftrag zukünftig ändern, stellen

314


https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html


Sie sicher, dass Sie die Gruppenrolle aktualisieren. Weitere Informationen finden Sie unter Hinzufügenund Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

Konnektor ParameterDiese Konnektoren stellen die folgenden Parameter bereit.

MLModelDestinationPath

Der absolute lokale Pfad der ML-Ressource innerhalb der Lambda-Umgebung. Dies ist der Zielpfad,der für die ML-Ressource angegeben ist.

Note

Wenn Sie die ML-Ressource in der Konsole angelegt haben, ist dies der lokale Pfad.

Anzeigename in der Konsole: Model destination path (Modell-Zielpfad)

Erforderlich: true

Typ: string

Gültiges Muster: .+MLModelResourceId

Die ID der ML-Ressource, die auf das Quellmodell verweist.

Anzeigename in der Konsole: SageMaker job ARN resource (SageMaker Job ARN Ressource)

Erforderlich: true

Typ: string

Gültiges Muster: [a-zA-Z0-9:_-]+MLModelSageMakerJobArn

Der ARN des Amazon SageMaker Trainingsjobs, der die Modellquelle Amazon SageMaker darstellt.Das Modell muss mit dem Bildklassifikationsalgorithmus Amazon SageMaker trainiert werden.

Anzeigename in der Konsole: SageMaker job ARN

Erforderlich: true

Typ: string

Gültiges Muster: ^arn:aws:sagemaker:[a-zA-Z0-9-]+:[0-9]+:training-job/[a-zA-Z0-9][a-zA-Z0-9-]+$

LocalInferenceServiceName

Der Name für den lokalen Inferenzdienst. Benutzerdefinierte Lambda-Funktionen rufen den Serviceauf, indem sie den Namen an die Funktion invoke_inference_service der Funktion des AWSIoT Greengrass Machine Learning SDK übergeben. Ein Beispiel finden Sie unter the section called“Verwendungsbeispiel” (p. 317).

Anzeigename in der Konsole: Local inference service name (Lokaler Inferenz-Service-Name)

Erforderlich: true

Typ: string

Gültiges Muster: [a-zA-Z0-9][a-zA-Z0-9-]{1,62}

315




LocalInferenceServiceTimeoutSeconds

Die Zeitspanne (in Sekunden), nach der die Inferenzanforderung beendet wird. Der minimale Wertbeträgt 1.

Anzeigename in der Konsole: Timeout (Sekunden)

Erforderlich: true

Typ: string

Gültiges Muster: [1-9][0-9]*LocalInferenceServiceMemoryLimitKB

Die Speichergröße (in KB), auf die der Service Zugriff hat. Der minimale Wert beträgt 1.

Anzeigename in der Konsole: Memory limit (KB) (Speicherlimit)

Erforderlich: true

Typ: string

Gültiges Muster: [1-9][0-9]*GPUAcceleration

Der CPU- oder GPU-(beschleunigte) Berechnungskontext. Diese Eigenschaft gilt nur für denBildklassifikation-Aarch64-JTX2-Konnektor.

Anzeigename in der Konsole: GPU acceleration (GPU-Beschleunigung)

Erforderlich: true

Typ: string

Zulässige Werte: CPU oder GPU

Beispiel: Erstellen eines Connectors (CLI)Die folgenden CLI-Befehle erstellen eine ConnectorDefinition mit einer Initialversion, die einenBildklassifikation-Konnektor enthält.

Example: CPU Instance (Beispiel: CPU-Instance)

Dieses Beispiel erzeugt eine Instance des Bildklassifikation-ARMv7l-Konnektors.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyImageClassificationConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/ImageClassificationARMv7/versions/1", "Parameters": { "MLModelDestinationPath": "/path-to-model", "MLModelResourceId": "my-ml-resource", "MLModelSageMakerJobArn": "arn:aws:sagemaker:us-west-2:123456789012:training-job:MyImageClassifier", "LocalInferenceServiceName": "imageClassification", "LocalInferenceServiceTimeoutSeconds": "10", "LocalInferenceServiceMemoryLimitKB": "500000" } }

316


]}'

Example: GPU Instance (Beispiel: GPU-Instance)

Dieses Beispiel erzeugt eine Instance des Bildklassifikation-Aarch64-JTX2-Konnektors, die die GPU-Beschleunigung auf einer NVIDIA Jetson TX2-Karte unterstützt.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyImageClassificationConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/ImageClassificationAarch64JTX2/versions/1", "Parameters": { "MLModelDestinationPath": "/path-to-model", "MLModelResourceId": "my-ml-resource", "MLModelSageMakerJobArn": "arn:aws:sagemaker:us-west-2:123456789012:training-job:MyImageClassifier", "LocalInferenceServiceName": "imageClassification", "LocalInferenceServiceTimeoutSeconds": "10", "LocalInferenceServiceMemoryLimitKB": "500000", "GPUAcceleration": "GPU" } } ]}'

Note

Die Lambda-Funktion in diesen Connectors hat einen langfristigen (p. 189) Lebenszyklus.


EingabedatenDiese Connectors akzeptieren keine MQTT-Nachrichten als Eingabedaten.

AusgabedatenDiese Connectors veröffentlichen keine MQTT-Nachrichten als Ausgabedaten.

VerwendungsbeispielDie folgende Lambda-Beispielfunktion verwendet das AWS IoT Greengrass Machine LearningSDK (p. 177) zur Interaktion mit einem Bildklassifikation-Konnektor.

Note

Sie können das SDK über die Seite AWS IoT Greengrass Machine Learning SDK (p. 22)downloads herunterladen.

Das Beispiel initialisiert einen SDK-Client und ruft synchron die Funktion invoke_inference_servicedes SDK auf, um den lokalen Inferenzdienst aufzurufen. Es wird der Algorithmustyp, der Servicename, derBildtyp und der Bildinhalt übergeben. Anschließend analysiert das Beispiel die Service-Antwort, um dieWahrscheinlichkeitsergebnisse (Vorhersagen) zu erhalten.

317


import loggingfrom threading import Timer

import numpy as np

import greengrass_machine_learning_sdk as ml

# We assume the inference input image is provided as a local file# to this inference client Lambda function.with open('/test_img/test.jpg', 'rb') as f: content = f.read()

client = ml.client('inference')

def infer(): logging.info('invoking Greengrass ML Inference service')

try: resp = client.invoke_inference_service( AlgoType='image-classification', ServiceName='imageClassification', ContentType='image/jpeg', Body=content ) except ml.GreengrassInferenceException as e: logging.info('inference exception {}("{}")'.format(e.__class__.__name__, e)) return except ml.GreengrassDependencyException as e: logging.info('dependency exception {}("{}")'.format(e.__class__.__name__, e)) return

logging.info('resp: {}'.format(resp)) predictions = resp['Body'].read() logging.info('predictions: {}'.format(predictions)) # The connector output is in the format: [0.3,0.1,0.04,...] # Remove the '[' and ']' at the beginning and end. predictions = predictions[1:-1] count = len(predictions.split(',')) predictions_arr = np.fromstring(predictions, count=count, sep=',')

# Perform business logic that relies on the predictions_arr, which is an array # of probabilities. # Schedule the infer() function to run again in one second. Timer(1, infer).start() return

infer()


Die Funktion invoke_inference_service in der AWS IoT Greengrass Machine Learning SDKakzeptiert die folgenden Argumente.

Argument Beschreibung

AlgoType Der Name des Algorithmentyps, der für die Inferenzverwendet werden soll. Derzeit wird nur image-classification unterstützt.

Erforderlich: true

318


Argument BeschreibungTyp: string

Zulässige Werte: image-classification

ServiceName Der Name des lokalen Inferenzdienstes.Verwenden Sie den Namen, den Sie für denParameter LocalInferenceServiceName beider Konfiguration des Konnektors angegebenhaben.

Erforderlich: true

Typ: string

ContentType Der Mime-Typ des Eingangsbildes.

Erforderlich: true

Typ: string

Zulässige Werte: image/jpeg, image/png

Body Der Inhalt der Eingabebilddatei.

Erforderlich: true

Typ: binary

Installieren von MXNet-Abhängigkeiten auf dem AWS IoTGreengrass CoreUm einen Bildklassifikation-Konnektor verwenden zu können, müssen Sie die Abhängigkeiten für dasApache MXNet Framework auf dem Core-Gerät installieren. Die Konnektoren verwenden das Frameworkfür die Bereitstellung des ML-Modells.

Note

Diese Konnektoren sind mit einer vorkompilierten MXNet-Bibliothek gebündelt, sodass Sie dasMXNet-Framework nicht auf dem Core-Gerät installieren müssen.

AWS IoT Greengrass bietet Skripts zum Installieren der Abhängigkeiten für die folgenden gängigenPlattformen und Geräte (oder zur Verwendung als Referenz für die Installation). Wenn Sie eine anderePlattform oder ein anderes Gerät verwenden, lesen Sie die MXNet-Dokumentation für Ihre Konfiguration.

Stellen Sie vor der Installation der MXNet-Abhängigkeiten sicher, dass die erforderlichenSystembibliotheken (p. 322) (mit den angegebenen Mindestversionen) auf dem Gerät vorhanden sind.

NVIDIA Jetson TX2

1. Installieren Sie CUDA Toolkit 9.0 und cuDNN 7.0. Befolgen Sie die Anweisungen unter the sectioncalled “Einrichten anderer Geräte” (p. 80) im Tutorial "Erste Schritte".

2. Aktivieren Sie Universum-Repositorys, damit der Konnektor offene, von der Community verwalteteSoftware installieren kann. Weitere Informationen finden Sie unter Repositories/Ubuntu in derUbuntu-Dokumentation.

a. Öffnen Sie die /etc/apt/sources.list Datei.

319

https://mxnet.apache.org/

https://help.ubuntu.com/community/Repositories/Ubuntu


b. Achten Sie darauf, dass die folgenden Zeilen nicht kommentiert sind.

deb http://ports.ubuntu.com/ubuntu-ports/ xenial universedeb-src http://ports.ubuntu.com/ubuntu-ports/ xenial universedeb http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universedeb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-updates universe

3. Speichern Sie eine Kopie des folgenden Installationsskripts in einer Datei namensnvidiajtx2.sh auf dem Core-Gerät.

#!/bin/bashset -e

echo "Installing MXNet dependencies on the system..."echo 'Assuming that universe repos are enabled and checking dependencies...'apt-get -y updateapt-get -y dist-upgradeapt-get install -y liblapack3 libopenblas-dev liblapack-dev libatlas-base-dev python-dev

echo 'Install latest pip...'wget https://bootstrap.pypa.io/get-pip.pypython get-pip.pyrm get-pip.py

pip install numpy==1.15.0 scipy

echo 'Dependency installation/upgrade complete.'

4. Führen Sie im Verzeichnis, in dem Sie die Datei gespeichert haben, den folgenden Befehl aus:

sudo nvidiajtx2.sh

x86_64 (Ubuntu or Amazon Linux)

1. Speichern Sie eine Kopie des folgenden Installationsskripts in einer Datei namens x86_64.sh aufdem Core-Gerät.

#!/bin/bashset -e

echo "Installing MXNet dependencies on the system..."

release=$(awk -F= '/^NAME/{print $2}' /etc/os-release)

if [ "$release" == '"Ubuntu"' ]; then # Ubuntu. Supports EC2 and DeepLens. DeepLens has all the dependencies installed, so # this is mostly to prepare dependencies on Ubuntu EC2 instance. apt-get -y update apt-get -y dist-upgrade

apt-get install -y libgfortran3 libsm6 libxext6 libxrender1 python-dev python-pipelif [ "$release" == '"Amazon Linux"' ]; then # Amazon Linux. Expect python to be installed already yum -y update yum -y upgrade

yum install -y compat-gcc-48-libgfortran libSM libXrender libXext python-pipelse echo "OS Release not supported: $release"

320


exit 1fi

pip install numpy==1.15.0 scipy opencv-python



sudo x86_64.sh

ARMv7 (Raspberry Pi)

1. Speichern Sie eine Kopie des folgenden Installationsskripts in einer Datei namens armv7l.sh aufdem Core-Gerät.

#!/bin/bashset -e

echo "Installing MXNet dependencies on the system..."

apt-get updateapt-get -y upgrade

apt-get install -y liblapack3 libopenblas-dev liblapack-dev python-dev

# python-opencv depends on python-numpy. The latest version in the APT repository is python-numpy-1.8.2# This script installs python-numpy first so that python-opencv can be installed, and then install the latest# numpy-1.15.x with pipapt-get install -y python-numpy python-opencvdpkg --remove --force-depends python-numpy

echo 'Install latest pip...'wget https://bootstrap.pypa.io/get-pip.pypython get-pip.pyrm get-pip.py

pip install --upgrade numpy==1.15.0 picamera scipy



sudo bash armv7l.sh

Note

Auf einem Raspberry Pi ist die Installation von scipy mithilfe von pip einespeicherintensive Operation, die dazu führen kann, dass auf dem Gerät nicht mehrgenügend Speicherplatz vorhanden ist und es nicht mehr reagiert. Um dieses Problem zuumgehen, können Sie die Auslagerungsgröße vorübergehend erhöhen:Erhöhen Sie in /etc/dphys-swapfile den Wert der CONF_SWAPSIZE-Variable undführen Sie dann den folgenden Befehl aus, um dphys-swapfile neu zu starten.

/etc/init.d/dphys-swapfile restart

321


Protokollierung und FehlersucheAbhängig von Ihren Gruppeneinstellungen werden Ereignis- und Fehlerprotokolle in CloudWatch Logs,das lokale Dateisystem oder beides geschrieben. Protokolle von diesem Konnektor verwenden das PräfixLocalInferenceServiceName. Wenn sich der Konnektor nicht wie erwartet verhält, überprüfen Sie dieProtokolle des Konnektors. Diese enthalten in der Regel nützliche Debugging-Informationen, wie z. B. einefehlende ML-Bibliothek-Abhängigkeit oder die Ursache eines Fehlers beim Starten des Konnektors.

Wenn die AWS IoT Greengrass-Gruppe zum Schreiben lokaler Protokolle konfiguriert ist, schreibt derConnector Protokolldateien in greengrass-root/ggc/var/log/user/Region/aws/. WeitereInformationen zur Greengrass-Protokollierung finden Sie unter Überwachung (p. 444).

Verwenden Sie die folgenden Informationen für die Problembehandlung bei den Bildklassifikation-Konnektoren.

Erforderliche Systembibliotheken

Die folgenden Registerkarten listen die für jeden Bildklassifikation-Konnektor erforderlichenSystembibliotheken auf.

Bildklassifikation Aarch64 JTX2

Bibliothek Mindestversion

ld-linux-aarch64.so.1 GLIBC_2.17

libc.so.6 GLIBC_2.17

libcublas.so.9.0 n.v.

libcudart.so.9.0 n.v.

libcudnn.so.7 n.v.

libcufft.so.9.0 n.v.

libcurand.so.9.0 n.v.

libcusolver.so.9.0 n.v.

libgcc_s.so.1 GCC_4.2.0

libgomp.so.1 GOMP_4.0, OMP_1.0

libm.so.6 GLIBC_2.23

libpthread.so.0 GLIBC_2.17

librt.so.1 GLIBC_2.17

libstdc++.so.6 GLIBCXX_3.4.21, CXXABI_1.3.8

Bildklassifikation x86_64


ld-linux-x86-64.so.2 GCC_4.0.0

322



libc.so.6 GLIBC_2.4

libgfortran.so.3 GFORTRAN_1.0

libm.so.6 GLIBC_2.23

libpthread.so.0 GLIBC_2.2.5

librt.so.1 GLIBC_2.2.5

libstdc++.so.6 CXXABI_1.3.8, GLIBCXX_3.4.21

Bildklassifikation ARMv7


ld-linux-armhf.so.3 GLIBC_2.4

libc.so.6 GLIBC_2.7

libgcc_s.so.1 GCC_4.0.0

libgfortran.so.3 GFORTRAN_1.0

libm.so.6 GLIBC_2.4

libpthread.so.0 GLIBC_2.4

librt.so.1 GLIBC_2.4

libstdc++.so.6 CXXABI_1.3.8, CXXABI_ARM_1.3.3,GLIBCXX_3.4.20

Problembereiche

Symptom Lösung

Auf einem Raspberry Pi wird die folgendeFehlermeldung protokolliert, und Sie verwendennicht die Kamera: Failed to initializelibdc1394

Führen Sie den folgenden Befehl aus, um denTreiber zu deaktivieren:

sudo ln /dev/null /dev/raw1394

Diese Operation ist flüchtig, und dersymbolische Link wird nach dem Neustartverschwinden. Schlagen Sie im Handbuch IhrerBetriebssystemverteilung nach, wie der Link beimNeustart automatisch erstellt wird.

LizenzenDie Bildklassifikation-Konnektoren enthalten die folgende Drittanbieter-Software/Lizenz:


323


AWS IoT Greengrass EntwicklerhandbuchIoT Analytics

• mxnet / Apache 2.0


Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Durchführen von Machine Learning-Inferenzen (p. 227)• Bildklassifikationsalgorithmus im Amazon SageMaker-Entwicklerhandbuch

IoT AnalyticsDer IoT Analytics-Konnektor sendet lokale Gerätedaten an AWS IoT Analytics. Sie können diesenKonnektor als zentralen Hub für die Erfassung von Sensordaten auf dem Greengrass Core-Gerät undvon angeschlossenen Greengrass-Geräten (p. 8) verwenden. Der Konnektor sendet die Daten an AWSIoT Analytics-Kanäle im aktuellen AWS-Konto und in der aktuellen Region. Sie kann Daten an einenStandardzielkanal und an dynamisch angegebene Kanäle senden.

Note

AWS IoT Analytics ist ein vollständig verwalteter Service, mit dem Sie IoT-Daten erfassen,speichern, verarbeiten und abfragen können. In AWS IoT Analytics können die Daten weiteranalysiert und verarbeitet werden. Auf diese Weise können beispielsweise ML-Modelle zurÜberwachung des Computerstatus oder zum Test neuer Modellierungsstrategien geschult werden.Weitere Informationen finden Sie unter Was ist AWS IoT Analytics? im AWS IoT Analytics-Benutzerhandbuch.

Der Konnektor akzeptiert formatierte und unformatierte Daten zu Eingabe-MQTT-Themen (p. 328). Eswerden zwei vordefinierte Themen mit angegebenem Zielkanal unterstützt. Sie kann auch Nachrichtenzu den von Kunden definierten Themen empfangen, die in Abonnements konfiguriert (p. 301) sind. Aufdiese Weise können Nachrichten von Geräten weitergeleitet werden, die feste Themen veröffentlichen oderunstrukturierte bzw. Stack-abhängige Daten von Geräten mit eingeschränkten Ressourcen verarbeiten.

Dieser Konnektor verwendet die BatchPutMessage-API, um Daten (als JSON- oder base64-codierteZeichenfolge) an den Zielkanal zu senden. Der Konnektor kann Rohdaten in ein Format verarbeiten,das den API-Anforderungen entspricht. Der Konnektor puffert Eingabenachrichten in Warteschlangenpro Kanal und verarbeitet die Stapel asynchron. Sie bietet Parameter, mit denen Sie das Verhalten vonWarteschlangen und Stapeln steuern und die Speicherbelegung beschränken können. Beispielsweisekönnen Sie die maximale Warteschlangengröße, den Stapelintervall, die Größe des Arbeitsspeichers unddie Anzahl der aktiven Kanäle konfigurieren.

ARN: arn:aws:greengrass:Region::/connectors/IoTAnalytics/versions/1


• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Dieser Konnektor kann nur in unterstützten AWS-Regionen verwendet werden. Weitere Informationen

finden Sie unter the section called “Beschränkungen” (p. 331).

324

https://pypi.org/project/mxnet/


https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html

https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html

https://docs.aws.amazon.com/iotanalytics/latest/userguide/api.html#cli-iotanalytics-batchputmessage



• Alle verwandten AWS IoT Analytics-Entitäten (Kanäle, Pipeline, Datastores, Datasets) undWorkflows werden erstellt und konfiguriert. Weitere Informationen finden Sie unter AWS CLI oderKonsolenprozeduren im AWS IoT Analytics-Benutzerhandbuch.

Note

AWS IoT Analytics-Zielkanäle müssen dasselbe Konto verwenden und in derselben AWS-Region wie dieser Konnektor vorhanden sein.

• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktioniotanalytics:BatchPutMessage für Zielkanäle erlaubt, wie im folgenden Beispiel gezeigt. DieKanäle müssen sich im aktuellen AWS-Konto und der Region befinden.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "Stmt1528133056761", "Action": [ "iotanalytics:BatchPutMessage" ], "Effect": "Allow", "Resource": [ "arn:aws:iotanalytics:Region:account-id:channel/channel_1_name", "arn:aws:iotanalytics:Region:account-id:channel/channel_2_name" ] } ]}

Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

ParameterMemorySize

Die Speichergröße (in KB), die diesem Konnektor zugewiesen werden soll.


Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$PublishRegion

Die AWS-Region, in der Ihre AWS IoT Analytics-Kanäle erstellt werden. Verwenden Sie dieselbeRegion wie dem Konnektor.

Note

Diese muss ebenfalls der Region für die Kanäle entsprechen, die in derGruppenrolle (p. 324) angegeben sind.

Anzeigename in der Konsole: Publish region (Veröffentlichungsregion)

Erforderlich: false

Typ: string

325

https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html

https://docs.aws.amazon.com/iotanalytics/latest/userguide/quickstart.html



Gültiges Muster: ^$|([a-z]{2}-[a-z]+-\\d{1})PublishInterval

Das Intervall (in Sekunden) für die Veröffentlichung eines empfangener Datenstapels an AWS IoTAnalytics.


Erforderlich: false

Typ: string

Standardwert: 1

Gültiges Muster: $|^[0-9]+$IotAnalyticsMaxActiveChannels

Die maximale Anzahl der AWS IoT Analytics-Kanäle, die von dem Konnektor aktiv überwacht werden.Diese muss größer als 0 und mindestens gleich der Anzahl der Kanäle sein, die voraussichtlich vondem Konnektor zu einem bestimmten Zeitpunkt veröffentlicht werden.

Sie können mit diesem Parameter den Speicherverbrauch beschränken, indem Sie die Gesamtzahlder Warteschlangen, die von dem Konnektor zu einem bestimmten Zeitpunkt verwaltet werden können,einschränken. Eine Warteschlange wird gelöscht, wenn alle Nachrichten darin gesendet wurden.

Anzeigename in der Konsole: Maximum number of active channels (Maximalzahl aktiver Kanäle)

Erforderlich: false

Typ: string

Standardwert: 50

Gültiges Muster: ^$|^[1-9][0-9]*$IotAnalyticsQueueDropBehavior

Das Verhalten für das Löschen von Nachrichten aus einer Kanalwarteschlange, wenn dieWarteschlange voll ist.

Anzeigename in der Konsole: Queue drop behavior (Löschverhalten der Warteschlange)

Erforderlich: false

Typ: string

Zulässige Werte: DROP_NEWEST oder DROP_OLDEST

Standardwert: DROP_NEWEST

Gültiges Muster: ^DROP_NEWEST|DROP_OLDEST$IotAnalyticsQueueSizePerChannel

Die maximale Anzahl der vor dem Senden oder Verwerfen der Nachrichten (pro Kanal) im Speichergehaltenen Nachrichten. Dieser Wert muss größer als 0 sein.

Anzeigename in der Konsole: Maximum queue size per channel (Maximale Größe der Warteschlangepro Kanal)

326


Erforderlich: false

Typ: string

Standardwert: 2048

Gültiges Muster: ^$|^[1-9][0-9]*$IotAnalyticsBatchSizePerChannel

Die maximale Anzahl der in einer Stapelanfrage an einen AWS IoT Analytics-Kanal gesendetenNachrichten. Dieser Wert muss größer als 0 sein.

Anzeigename in der Konsole: Maximum number of messages to batch per channel (Die maximaleAnzahl der pro Kanal zu stapelnden Nachrichten)

Erforderlich: false

Typ: string

Standardwert: 5

Gültiges Muster: ^$|^[1-9][0-9]*$IotAnalyticsDefaultChannelName

Der Name des AWS IoT Analytics-Kanals, der von diesem Konnektor für Nachrichten verwendet wird,die an ein vom Kunden definiertes Eingabethema gesendet werden.

Anzeigename in der Konsole: Default channel name (Standardkanalname)

Erforderlich: false

Typ: string

Gültiges Muster: ^[a-zA-Z0-9_]$


Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den IoTAnalytics-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyIoTAnalyticsApplication", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/IoTAnalytics/versions/1", "Parameters": { "MemorySize": "65535", "PublishRegion": "us-west-1", "PublishInterval": "2", "IotAnalyticsMaxActiveChannels": "25", "IotAnalyticsQueueDropBehavior": "DROP_OLDEST", "IotAnalyticsQueueSizePerChannel": "1028", "IotAnalyticsBatchSizePerChannel": "5", "IotAnalyticsDefaultChannelName": "my_channel" } } ]

327


}'

Note



EingabedatenDieser Konnektor akzeptiert Daten auf vordefinierten und vom Kunden definierten MQTT-Themen.Herausgeber können Greengrass-Geräte, Lambda-Funktionen oder andere Konnektoren sein.

Vordefinierte Themen

Der Konnektor unterstützt die folgenden beiden strukturierten MQTT-Themen, mit denen Herausgeberden Kanalnamen inline angeben können.• Eine formatierte Nachricht (p. 328) zum iotanalytics/channels/+/messages/put-Thema.

Die IoT-Daten in diesen Eingabenachrichten müssen als JSON- oder base64-kodierte Zeichenfolgeformatiert sein.

• Eine unformatierte Nachricht auf dem iotanalytics/channels/+/messages/binary/put-Thema. Die zu diesem Thema erhalten Eingabenachrichten werden als binäre Daten behandeltkönnen einen beliebigen Datentyp enthalten.

Wenn Sie vordefinierte Themen veröffentlichen möchten, ersetzen Sie den +-Platzhalter durch denKanalnamen. Beispiel:

iotanalytics/channels/my_channel/messages/put

Kundendefinierte Themen

Der Konnektor unterstützt die #-Themasyntax, wodurch er Eingabenachrichten zu einem beliebigenMQTT-Thema annehmen kann, das Sie in einem Abonnement konfigurieren. Wir empfehlen, einenThemenpfad anzugeben, anstatt lediglich den Platzhalter # in Ihren Abonnements zu verwenden.Diese Nachrichten werden an den Standardkanal gesendet, den Sie für den Konnektor angeben.

Eingabenachrichten zu den von Kunden definierten Themen werden als Binärdaten behandelt. Siekönnen eine beliebiges Nachrichtformat verwenden und beliebige Datentypen enthalten. Mit den vomKunden definierten Themen können Sie Nachrichten von Geräten weiterleiten, die an feste Themenveröffentlicht werden. Sie können damit auch Eingabedaten von Geräten akzeptieren, deren Datennicht in eine formatierte Nachricht verarbeitet und an den Konnektor gesendet werden können.

Weitere Informationen zu Abonnements und MQTT-Themen finden Sie unter the section called “Inputsund Outputs” (p. 301).

Die Gruppenrolle muss die iotanalytics:BatchPutMessage-Aktion auf allen Zielkanälen erlauben.Weitere Informationen finden Sie unter the section called “Voraussetzungen” (p. 324).

Themenfilter: iotanalytics/channels/+/messages/put

Mit diesem Thema können Sie formatierte Nachrichten an den Konnektor senden und dynamischeinen Zielkanal angeben. Dieses Thema ermöglicht Ihnen auch die Angabe einer ID, die in derAntwortausgabe zurückgegeben wird. Der Konnektor bestätigt, dass IDs für jede an AWS IoT Analytics

328


gesendete Nachricht in der ausgehenden BatchPutMessage-Anfrage eindeutig sind. Eine Nachrichtmit einer doppelten ID wird gelöscht.

Die Eingabedaten zu diesem Thema müssen das folgende Format aufweisen.Nachrichten-Eigenschaften

request

Die an den angegebenen Kanal zu sendenden Daten.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:message

Die Geräte- oder Sensordaten als JSON- oder base64-kodierte Zeichenfolge.

Erforderlich: true

Typ: stringid

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung einer Ausgabeantwort zuzuordnen. Wenn angegeben, wird dieEigenschaft id im Antwortobjekt auf diesen Wert gesetzt. Wenn Sie diese Eigenschaftauslassen, wird von dem Konnektor eine ID generiert.

Erforderlich: false

Typ: string

Gültiges Muster: .*Beispieleingabe

{ "request": { "message" : "{\"temp\":23.33}" }, "id" : "req123"}

Themenfilter: iotanalytics/channels/+/messages/binary/put

Mit diesem Thema können Sie unformatierte Nachrichten an den Konnektor senden und dynamischeinen Zielkanal angeben.

Die Konnektor-Daten analysieren die zu diesem Thema empfangenen Eingabenachrichten nicht. Siewerden als Binärdaten behandelt. Bevor die Nachrichten an AWS IoT Analytics gesendet werden,verschlüsselt und formatiert der Konnektor diese Nachrichten entsprechend den BatchPutMessage-API-Anforderungen:• Der Konnektor führt eine base64-Verschlüsselung der Rohdaten durch und schließt diese

verschlüsselte Nutzlast in einer ausgehenden BatchPutMessage-Anforderung ein.• Der Konnektor generiert eine ID für jede Eingabenachricht und weist sie zu.

Note

In der Konnektor-Antwortausgabe ist keine ID-Korrelation für diese Eingabenachrichtenbeinhaltet.

329


Nachrichten-Eigenschaften

Keine.Themenfilter: #

Verwenden Sie dieses Thema, um ein beliebiges Nachrichtenformat an den Standardkanal zu senden.Dies ist besonders nützlich, wenn Ihre Geräte an feste Themen veröffentlichen oder wenn Sie Datenvon Geräten, die die Daten nicht in das vom Konnektor unterstützte Nachrichtenformat (p. 328)verarbeiten können, an den Standardkanal senden möchten.

Sie definieren die Themensyntax in dem von Ihnen erstellten Abonnement, um diesen Konnektor mitder Datenquelle zu verbinden. Wir empfehlen, einen Themenpfad anzugeben, anstatt lediglich denPlatzhalter # in Ihren Abonnements zu verwenden.

Die Konnektor-Daten analysieren die an dieses Eingabethema veröffentlichten Nachrichten nicht. AlleEingabenachrichten werden als Binärdaten behandelt. Bevor die Nachrichten an AWS IoT Analyticsgesendet werden, verschlüsselt und formatiert der Konnektor diese Nachrichten entsprechend denBatchPutMessage-API-Anforderungen:• Der Konnektor führt eine base64-Verschlüsselung der Rohdaten durch und schließt diese

verschlüsselte Nutzlast in einer ausgehenden BatchPutMessage-Anforderung ein.• Der Konnektor generiert eine ID für jede Eingabenachricht und weist sie zu.

Note

In der Konnektor-Antwortausgabe ist keine ID-Korrelation für diese Eingabenachrichtenbeinhaltet.


Keine.

AusgabedatenDieser Connector veröffentlicht Statusinformationen als Ausgabedaten. Diese Informationen enthält diezurückgegebene Antwort von AWS IoT Analytics für jede Eingabenachricht, die von AWS IoT Analyticsempfangen und von dort gesendet wird.

Themenfilter

iotanalytics/messages/put/status


{ "response" : { "status" : "success" }, "id" : "req123"}


{ "response" : { "status" : "fail", "error" : "ResourceNotFoundException", "error_message" : "A resource with the specified name could not be found." }, "id" : "req123"

330


}

Note

Wenn der Connector einen wiederholbaren Fehler (etwa einen Verbindungsfehler) erkennt,wird die Veröffentlichung im nächsten Stapel erneut versucht. Exponentielles Backoff wirdvon der AWS SDK behandelt. Anfragen mit wiederholbaren Fehlern werden zur weiterenVeröffentlichung entsprechend dem IotAnalyticsQueueDropBehavior-Parameter wiederder Kanalwarteschlange hinzugefügt.

BeschränkungenDieser Konnektor unterliegt den folgenden Einschränkungen.

• Alle durch das AWS SDK für Python (boto3) für die AWS IoT Analytics batch_put_message-Aktionauferlegten Einschränkungen.

• Alle von der AWS IoT Analytics BatchPutMessage-API auferlegten Einschränkungen. WeitereInformationen finden Sie unter AWS IoT Analytics-Einschränkungen in der allgemeinen AWS-Referenz.• 100.000 Nachrichten pro Sekunde pro Kanal.• 100 Nachrichten pro Stapel.• 128 KB pro Nachricht.

Diese API verwendet Kanalnamen (keine Kanal-ARNs), daher wird das Senden von Daten anregionsübergreifende oder kontoübergreifende Kanäle nicht unterstützt.

• Alle vom AWS IoT Greengrass-Core verhängten Einschränkungen. Weitere Informationen finden Sieunter AWS IoT Greengrass-Core-Einschränkungen in der allgemeinen AWS-Referenz.

Die folgenden Einschränkungen sind möglicherweise in besonderem Maße zutreffend:• Die maximale Größe der von einem Gerät gesendeten Nachrichten ist 128 KB.• Die maximale Größe der Nachrichtenwarteschlange im Greengrass Core-Router ist 2,5 MB.• Die maximale Länge einer Thema-Zeichenfolge beträgt 256 Byte UTF-8-Zeichen.

• Dieser Konnektor kann nur in AWS-Regionen verwendet werden, die von AWS IoT Greengrass und AWSIoT Analytics unterstützt werden. Derzeit schließt dies die folgenden Regionen ein:• USA Ost (Ohio) - us-east-2• USA Ost (Nord-Virginia) - us-east-1• USA West (Oregon) - us-west-2• Asien-Pazifik (Tokio) - ap-northeast-1• EU (Frankfurt) - eu-central-1• EU (Irland) - eu-west-1

LizenzenDer IoT Analytics-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:



Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)

331

http://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/iotanalytics.html#IoTAnalytics.Client.batch_put_message

https://docs.aws.amazon.com/iotanalytics/latest/userguide/api.html#cli-iotanalytics-batchputmessage

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_iot_analytics

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#gg_core_limits


https://docs.aws.amazon.com/general/latest/gr/rande.html#iotanalytics_region

https://docs.aws.amazon.com/general/latest/gr/rande.html#iotanalytics_region



AWS IoT Greengrass EntwicklerhandbuchKinesis Firehose

• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Was ist AWS IoT Analytics? im AWS IoT Analytics-Benutzerhandbuch

Kinesis FirehoseDer Kinesis Firehose Konnektor (p. 297) veröffentlicht Daten über einen Amazon Kinesis Data Firehose-Bereitstellungs-Stream an Ziele wie Amazon S3, Amazon Redshift oder Amazon Elasticsearch Service.

Dieser Konnektor ist ein Datenproduzent für einen Kinesis-Bereitstellungs-Stream. Er empfängtEingabedaten zu einem MQTT-Thema und sendet die Daten an einen angegebenen Bereitstellungs-Stream. Der Bereitstellungs-Stream sendet dann den Datensatz an das konfigurierte Ziel (z. B. einen S3-Bucket).


Version ARN

2 arn:aws:greengrass:Region::/connectors/KinesisFirehose/versions/2

1 arn:aws:greengrass:Region::/connectors/KinesisFirehose/versions/1


VoraussetzungenDieser Connector hat die folgenden Anforderungen:

Version 2

• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Ein konfigurierter Kinesis-Bereitstellungs-Stream. Weitere Informationen finden Sie unter Erstellen

eines Amazon Kinesis Data Firehose-Bereitstellungs-Streams im Amazon Kinesis-FirehoseEntwicklerhandbuch.

• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktionenfirehose:PutRecord und firehose:PutRecordBatch auf dem Zielbereitstellungsstromerlaubt, wie im folgenden Beispiel gezeigt:

{ "Version":"2012-10-17", "Statement":[ { "Sid":"Stmt1528133056761", "Action":[ "firehose:PutRecord", "firehose:PutRecordBatch" ], "Effect":"Allow", "Resource":[ "arn:aws:firehose:Region:account-id:deliverystream/stream-name" ]

332

https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html


https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html



} ] }

Mit diesem Konnektor können Sie den standardmäßigen Bereitstellungs-Stream in der Nutzlast derInput-Message dynamisch überschreiben. Wenn Ihre Implementierung diese Funktion verwendet,sollte die IAM-Richtlinie alle Zielströme als Ressourcen enthalten. Sie können Ressourcengranularen oder bedingten Zugriff gewähren 8etwa mit einem benennungsschema mit Platzhaltern*). Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

Version 1

• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Ein konfigurierter Kinesis-Bereitstellungs-Stream. Weitere Informationen finden Sie unter Erstellen

eines Amazon Kinesis Data Firehose-Bereitstellungs-Streams im Amazon Kinesis-FirehoseEntwicklerhandbuch.

• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktionfirehose:PutRecord auf dem Ziel-Bereitstellungs-Stream erlaubt, wie im folgenden Beispielgezeigt:

{ "Version":"2012-10-17", "Statement":[ { "Sid":"Stmt1528133056761", "Action":[ "firehose:PutRecord" ], "Effect":"Allow", "Resource":[ "arn:aws:firehose:Region:account-id:deliverystream/stream-name" ] } ] }

Mit diesem Konnektor können Sie den standardmäßigen Bereitstellungs-Stream in der Nutzlast derInput-Message dynamisch überschreiben. Wenn Ihre Implementierung diese Funktion verwendet,sollte die IAM-Richtlinie alle Zielströme als Ressourcen enthalten. Sie können Ressourcengranularen oder bedingten Zugriff gewähren 8etwa mit einem benennungsschema mit Platzhaltern*). Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.

Konnektor ParameterDieser Connector stellt die folgenden Parameter bereit:

Version 2

DefaultDeliveryStreamArn

Der ARN des standardmäßigen Kinesis Data Firehose Bereitstellungs-Streams, an den Datengesendet werden sollen. Der Ziel-Stream kann durch die Eigenschaft delivery_stream_arn inder Nutzlast der Eingangsnachricht überschrieben werden.

333







Note

Die Gruppenrolle muss die entsprechenden Aktionen für alle Zielbereitstellungsströmeermöglichen. Weitere Informationen finden Sie unter the section called“Voraussetzungen” (p. 332).

Anzeigename in der Konsole: Default delivery stream ARN (Standard Bereitstellungs-StreamARN)

Erforderlich: true

Typ: string

Gültiges Muster: arn:aws:firehose:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):deliverystream/([a-zA-Z0-9_\-.]+)$

DeliveryStreamQueueSize

Die maximale Anzahl der im Speicher behaltenen Datensätze, bevor neue Datensätze für dengleichen Bereitstellungsstrom abgelehnt werden. Der minimale Wert beträgt 2000.

Anzeigename in der Konsole: Die maximale Anzahl der zu puffernden Datensätze (pro Stream)

Erforderlich: true

Typ: string

Gültiges Muster: ^([2-9]\\d{3}|[1-9]\\d{4,})$MemorySize

Die Speichergröße (in KB), die diesem Konnektor zugewiesen werden soll.


Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$PublishInterval

Das Intervall (in Sekunden) für die Veröffentlichung von Datensätzen an Kinesis Data Firehose.Setzen Sie diesen Wert auf 0, um die Stapelverarbeitung zu deaktivieren.


Erforderlich: true

Typ: string


Gültiges Muster: [0-9]|[1-9]\\d|[1-9]\\d\\d|900

Version 1

DefaultDeliveryStreamArn

Der ARN des standardmäßigen Kinesis Data Firehose Bereitstellungs-Streams, an den Datengesendet werden sollen. Der Ziel-Stream kann durch die Eigenschaft delivery_stream_arn inder Nutzlast der Eingangsnachricht überschrieben werden.

334


Note

Die Gruppenrolle muss die entsprechenden Aktionen für alle Zielbereitstellungsströmeermöglichen. Weitere Informationen finden Sie unter the section called“Voraussetzungen” (p. 332).

Anzeigename in der Konsole: Default delivery stream ARN (Standard Bereitstellungs-StreamARN)

Erforderlich: true

Typ: string


Example


Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den Connectorenthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyKinesisFirehoseConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/KinesisFirehose/versions/2", "Parameters": { "DefaultDeliveryStreamArn": "arn:aws:firehose:region:account-id:deliverystream/stream-name", "DeliveryStreamQueueSize": "5000", "MemorySize": "65535", "PublishInterval": "10" } } ]}'


EingabedatenDieser Konnektor akzeptiert Stream-Inhalte zu MQTT-Themen und sendet die Inhalte dann an den Ziel-Bereitstellungs-Stream. Er akzeptiert zwei Arten von Eingabedaten:

• JSON-Daten zum kinesisfirehose/message-Thema.• Binäre Daten zum kinesisfirehose/message/binary/#-Thema.

Version 2

Themenfilter: kinesisfirehose/message

Verwenden Sie dieses Thema, um eine Nachricht zu senden, die JSON-Daten enthält.

335



Die zu sendenden Daten an den Lieferstrom und den Ziel-Lieferstrom, falls sie sich vomStandard-Stream unterscheiden.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:data

Die Daten, die an den Lieferstrom gesendet werden sollen.

Erforderlich: true

Typ: bytesdelivery_stream_arn

Der ARN des Kinesis Ziel-Lieferstroms. Fügen Sie diese Eigenschaft hinzu, um denstandardmäßigen Lieferstrom zu überschreiben.

Erforderlich: false

Typ: string


id

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung einer Ausgabeantwort zuzuordnen. Wenn angegeben, wird dieEigenschaft id im Antwortobjekt auf diesen Wert gesetzt. Wenn Sie diese Funktionnicht verwenden, können Sie diese Eigenschaft weglassen oder eine leere Zeichenketteangeben.

Erforderlich: false

Typ: string


{ "request": { "delivery_stream_arn": "arn:aws:firehose:region:account-id:deliverystream/stream2-name", "data": "Data to send to the delivery stream." }, "id": "request123"}

Themenfilter: kinesisfirehose/message/binary/#

Verwenden Sie dieses Thema, um eine Nachricht zu senden, die binäre Daten enthält. DerKonnektor analysiert keine binären Daten. Die Daten werden unverändert gestreamt.

Um die Eingabeaufforderung einer Ausgabeaufgabe zuzuordnen, ersetzen Sie den Platzhalter #im Meldungsthema durch eine beliebige Anforderungs-ID. Wenn Sie beispielsweise eine Nachricht

336


an kinesisfirehose/message/binary/request123 veröffentlichen, wird die Eigenschaft idim Antwortobjekt auf request123 gesetzt.

Wenn Sie eine Anfrage nicht auf eine Antwort abbilden möchten, können Sie Ihre Nachrichtenunter kinesisfirehose/message/binary/ veröffentlichen. Achten Sie darauf, dass Sie dennachlaufenden Schrägstrich verwenden.

Version 1

Themenfilter: kinesisfirehose/message

Verwenden Sie dieses Thema, um eine Nachricht zu senden, die JSON-Daten enthält.Nachrichten-Eigenschaften

request

Die zu sendenden Daten an den Lieferstrom und den Ziel-Lieferstrom, falls sie sich vomStandard-Stream unterscheiden.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:data

Die Daten, die an den Lieferstrom gesendet werden sollen.

Erforderlich: true

Typ: bytesdelivery_stream_arn

Der ARN des Kinesis Ziel-Lieferstroms. Fügen Sie diese Eigenschaft hinzu, um denstandardmäßigen Lieferstrom zu überschreiben.

Erforderlich: false

Typ: string


id

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung einer Ausgabeantwort zuzuordnen. Wenn angegeben, wird dieEigenschaft id im Antwortobjekt auf diesen Wert gesetzt. Wenn Sie diese Funktionnicht verwenden, können Sie diese Eigenschaft weglassen oder eine leere Zeichenketteangeben.

Erforderlich: false

Typ: string


{ "request": { "delivery_stream_arn": "arn:aws:firehose:region:account-id:deliverystream/stream2-name", "data": "Data to send to the delivery stream." },

337


"id": "request123"}

Themenfilter: kinesisfirehose/message/binary/#

Verwenden Sie dieses Thema, um eine Nachricht zu senden, die binäre Daten enthält. DerKonnektor analysiert keine binären Daten. Die Daten werden unverändert gestreamt.

Um die Eingabeaufforderung einer Ausgabeaufgabe zuzuordnen, ersetzen Sie den Platzhalter #im Meldungsthema durch eine beliebige Anforderungs-ID. Wenn Sie beispielsweise eine Nachrichtan kinesisfirehose/message/binary/request123 veröffentlichen, wird die Eigenschaft idim Antwortobjekt auf request123 gesetzt.

Wenn Sie eine Anfrage nicht auf eine Antwort abbilden möchten, können Sie Ihre Nachrichtenunter kinesisfirehose/message/binary/ veröffentlichen. Achten Sie darauf, dass Sie dennachlaufenden Schrägstrich verwenden.


Version 2

Themenfilter

kinesisfirehose/message/status

Beispielausgabe

Die Antwort enthält den Status jedes im Stapel gesendeten Datensatzes.

{ "response": [ { "ErrorCode": "error", "ErrorMessage": "test error", "id": "request123", "status": "fail" }, { "firehose_record_id": "xyz2", "id": "request456", "status": "success" }, { "firehose_record_id": "xyz3", "id": "request890", "status": "success" } ]}

Note

Wenn der Connector einen wiederholbaren Fehler (etwa einen Verbindungsfehler)erkennt, wird die Veröffentlichung im nächsten Stapel erneut versucht. ExponentiellesBackoff wird von der AWS SDK behandelt. Anfragen, die mit wiederholbaren Fehlernfehlschlagen, werden zur weiteren Veröffentlichung wieder am Ende der Warteschlangehinzugefügt.

338


Version 1

Themenfilter

kinesisfirehose/message/status


{ "response": { "firehose_record_id": "1lxfuuuFomkpJYzt/34ZU/r8JYPf8Wyf7AXqlXm", "status": "success" }, "id": "request123"}


{ "response" : { "error": "ResourceNotFoundException", "error_message": "An error occurred (ResourceNotFoundException) when calling the PutRecord operation: Firehose test1 not found under account 123456789012.", "status": "fail" }, "id": "request123"}

VerwendungsbeispielDie folgende Lambda-Beispielfunktion sendet eine Eingabenachricht an den Connector. Diese Nachrichtenthält JSON-Daten.

Note




iot_client = greengrasssdk.client('iot-data')send_topic = 'kinesisfirehose/message'

def create_request_with_all_fields(): return { "request": { "data": "Message from Firehose Connector Test" }, "id" : "req_123" }

def publish_basic_message(): messageToPublish = create_request_with_all_fields() print "Message To Publish: ", messageToPublish

339


AWS IoT Greengrass EntwicklerhandbuchModbus-RTU-Protokolladapter

iot_client.publish(topic=send_topic, payload=json.dumps(messageToPublish))



LizenzenDer Kinesis Firehose-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:




Version Änderungen

2 Unterstützung für das Senden vonStapeldatensätzen zu Kinesis Data Firehose zueinem angegebenen Intervall hinzugefügt.

• Außerdem ist diefirehose:PutRecordBatch-Aktion in derGruppenrolle erforderlich.

• Neue MemorySize-,DeliveryStreamQueueSize- undPublishInterval-Parameter.

• Die Ausgabenachricht enthält ein Arrayvon Statusantworten für die veröffentlichtenDatensätze.

1 Erstversion.


Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Was ist der Amazon Kinesis Data Firehose? im Amazon Kinesis Developer Guide

Modbus-RTU-ProtokolladapterDer Modbus-RTU-Protokolladapter Konnektor (p. 297) fragt Informationen von Modbus RTU-Geräten ab,die sich im AWS IoT Greengrass-Gruppe befinden.

340



https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html


Dieser Konnektor empfängt Parameter für eine Modbus RTU-Anforderung von einer benutzerdefiniertenLambda-Funktion. Er sendet die entsprechende Anforderung und veröffentlicht dann die Antwort desZielgeräts als MQTT-Nachricht.


Version ARN

2 arn:aws:greengrass:Region::/connectors/ModbusRTUProtocolAdapter/versions/2

1 arn:aws:greengrass:Region::/connectors/ModbusRTUProtocolAdapter/versions/1



• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Eine physikalische Verbindung zwischen dem AWS IoT Greengrass-Core und den Modbus-Geräten. Der

Kern muss physisch über eine serielle Schnittstelle (z. B. eine USB-Schnittstelle) mit dem Modbus RTU-Netzwerk verbunden sein.

• Ein lokale Geräteressource (p. 204) in der Greengrass-Gruppe, der auf die physische serielle Modbus-Schnittstelle zeigt.

• Eine benutzerdefinierte Lambda-Funktion, die Modbus RTU-Anforderungsparameter an diesenKonnektor sendet. Die Anforderungsparameter müssen den erwarteten Mustern entsprechen und dieIDs und Adressen der Zielgeräte im Modbus RTU-Netzwerk beinhalten. Weitere Informationen finden Sieunter the section called “Eingabedaten” (p. 342).

Konnektor ParameterDieser Konnektor unterstützt die folgenden Parameter:

ModbusSerialPort-ResourceId

Die ID der lokalen Geräteressource, die die physische serielle Modbus-Schnittstelle darstellt.Note

Dieser Konnektor hat Zugriff zum Lesen und Schreiben auf die Ressource.

Anzeigename in der Konsole: Modbus serial port resource (Ressource für die serielle Modbus-Schnittstelle)

Erforderlich: true

Typ: string

Gültiges Muster: .+ModbusSerialPort

Der absolute Pfad zur physikalischen seriellen Modbus-Schnittstelle auf dem Gerät. Dies ist derQuellpfad, der für die lokale Modbus-Geräteressource angegeben ist.

341



Anzeigename in der Konsole: Source path of Modbus serial port resource (Quellpfad der Ressourceder seriellen Modbus-Schnittstelle)

Erforderlich: true

Typ: string

Gültiges Muster: .+

Beispiel: Erstellen eines Connectors (CLI)Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den Modbus-RTU-Protokolladapter-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyModbusRTUProtocolAdapterConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/ModbusRTUProtocolAdapter/versions/2", "Parameters": { "ModbusSerialDevice-ResourceId": "MyLocalModbusSerialPort", "ModbusSerialDevice": "/path-to-port" } } ]}'

Note



Note

Nach der Bereitstellung des Modbus-RTU-Protokolladapter-Konnektors können Sie AWS IoTThings Graph verwenden, um Interaktionen zwischen Geräten in Ihrer Gruppe zu orchestrieren.Weitere Informationen finden Sie unter Modbus im AWS IoT Things Graph-Benutzerhandbuch.

EingabedatenDieser Konnektor akzeptiert Modbus RTU-Anforderungsparameter von einer benutzerdefinierten Lambda-Funktion zu einem MQTT-Thema. Eingabemeldungen müssen das JSON-Format aufweisen.

Themenfilter

modbus/adapter/request


Die Anforderungsnachricht variiert je nach Art der Modbus RTU-Anfrage, die sie darstellt. Diefolgenden Eigenschaften werden für alle Anforderungen benötigt:• Im request-Objekt:

• operation Der auszuführende Vorgang, angegeben durch Name oder Funktionscode. Umbeispielsweise Spulen zu lesen, können Sie ReadCoilsRequest oder 0x01 angeben. DieserWert muss eine Unicode-Zeichenfolge sein.

342

https://docs.aws.amazon.com/thingsgraph/latest/ug/iot-tg-protocols-modbus.html


• device Das Zielgerät der Anfrage. Dieser Wert muss zwischen 0 - 247 liegen.• Die id-Eigenschaft. Eine ID für die Anforderung. Dieser Wert wird für die Datendeduplizierung

verwendet und wie bei der id-Eigenschaft aller Antworten, einschließlich Fehlerantworten,zurückgegeben. Dieser Wert muss eine Unicode-Zeichenfolge sein.

Die weiteren Parameter, die in die Anforderung aufgenommen werden sollen, hängen vonder Operation ab. Alle Anforderungsparameter sind erforderlich, mit Ausnahme der CRC, dieseparat behandelt wird. Beispiele finden Sie unter the section called “Beispiel: Anforderungen undAntworten” (p. 345).

Beispieleingabe: Verwendung des Operationsnamens

{ "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest"}

Beispieleingabe: Verwenden des Funktionscodes

{ "request": { "operation": 0x01, "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest"}

Weitere Beispiele finden Sie unter the section called “Beispiel: Anforderungen undAntworten” (p. 345).

AusgabedatenDieser Konnektor veröffentlicht Antworten auf eingehende Modbus RTU-Anfragen.

Themenfilter

modbus/adapter/response


Das Format der Antwortnachricht variiert je nach Anforderung und Antwortstatus. Beispiele finden Sieunter the section called “Beispiel: Anforderungen und Antworten” (p. 345).

Note

Eine Antwort für einen Schreibvorgang ist lediglich ein Echo der Anforderung. Obwohl keineaussagekräftigen Informationen für Schreibantworten zurückgegeben werden, ist es eine guteVorgehensweise, den Status der Antwort zu überprüfen.

Jede Antwort beinhaltet die folgenden Eigenschaften:• Im response-Objekt:

343


• status Der Status der Anfrage. Der Status kann einer der folgenden Werte sein:• Success Die Anfrage war gültig, wurde an das Modbus RTU-Netzwerk gesendet und eine

Antwort wurde zurückgegeben.• Exception Die Anfrage war gültig, wurde an das Modbus-RTU-Netzwerk gesendet und eine

Ausnahmeantwort wurde zurückgegeben. Weitere Informationen finden Sie unter the sectioncalled “Antwortstatus: Ausnahme” (p. 349).

• No Response Die Anforderung war ungültig, und der Konnektor hat den Fehler abgefangen,bevor die Anforderung über das Modbus RTU-Netzwerk gesendet wurde. Weitere Informationenfinden Sie unter the section called “Antwortstatus: Keine Antwort” (p. 350).

• device Das Gerät, an das die Anforderung gesendet wurde.• operation Der Anfragetyp, der gesendet wurde.• payload Der Antwortinhalt, der zurückgegeben wurde. Wenn der status No Response ist,

enthält dieses Objekt nur eine error-Eigenschaft mit der Fehlerbeschreibung (z. B. "error":"[Input/Output] No Response received from the remote unit").

• Die id-Eigenschaft. Die ID der Anforderung, die für die Datendeduplizierung verwendet wird.Beispielausgabe: Erfolg

{ "response" : { "status" : "success", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 1, "bits": [1] } }, "id" : "TestRequest"}


{ "response" : { "status" : "fail", "error_message": "Internal Error", "error": "Exception", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 129, "exception_code": 2 } }, "id" : "TestRequest"}

Weitere Beispiele finden Sie unter the section called “Beispiel: Anforderungen undAntworten” (p. 345).

Modbus RTU Anfragen und AntwortenDieser Konnektor akzeptiert Modbus RTU-Anfrageparameter als Eingabedaten (p. 342) und veröffentlichtAntworten als Ausgabedaten (p. 343).

Die folgenden allgemeinen Operationen werden unterstützt.

344


Operation Funktionscode

ReadCoilsRequest 01

ReadDiscreteInputsRequest 02

ReadHoldingRegistersRequest 03

ReadInputRegistersRequest 04

WriteSingleCoilRequest 05

WriteSingleRegisterRequest 06

WriteMultipleCoilsRequest 15

WriteMultipleRegistersRequest 16

MaskWriteRegisterRequest 22

ReadWriteMultipleRegistersRequest 23

Beispiel: Anforderungen und Antworten

Im Folgenden finden Sie Beispiele für Anfragen und Antworten für unterstützte Operationen.

Spulen lesen

Anfragebeispiel:

{ "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 1, "bits": [1] } }, "id" : "TestRequest"}

Digitaleingänge lesen

Anfragebeispiel:

{

345


"request": { "operation": "ReadDiscreteInputsRequest", "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "ReadDiscreteInputsRequest", "payload": { "function_code": 2, "bits": [1] } }, "id" : "TestRequest"}

Lesen von Holdingregistern

Anfragebeispiel:

{ "request": { "operation": "ReadHoldingRegistersRequest", "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "ReadHoldingRegistersRequest", "payload": { "function_code": 3, "registers": [20,30] } }, "id" : "TestRequest"}

Lesen von Eingangsregistern

Anfragebeispiel:

{ "request": { "operation": "ReadInputRegistersRequest",

346


"device": 1, "address": 0x01, "value": 1 }, "id": "TestRequest"}

Schreiben Einzelspule

Anfragebeispiel:

{ "request": { "operation": "WriteSingleCoilRequest", "device": 1, "address": 0x01, "value": 1 }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "WriteSingleCoilRequest", "payload": { "function_code": 5, "address": 1, "value": true } }, "id" : "TestRequest"

Schreiben eines Einzelregisters

Anfragebeispiel:

{ "request": { "operation": "WriteSingleRegisterRequest", "device": 1, "address": 0x01, "value": 1 }, "id": "TestRequest"}

Schreiben mehrerer Spulen

Anfragebeispiel:

{ "request": { "operation": "WriteMultipleCoilsRequest", "device": 1, "address": 0x01, "values": [1,0,0,1]

347


}, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "WriteMultipleCoilsRequest", "payload": { "function_code": 15, "address": 1, "count": 4 } }, "id" : "TestRequest"}

Schreiben mehrerer Register

Anfragebeispiel:

{ "request": { "operation": "WriteMultipleRegistersRequest", "device": 1, "address": 0x01, "values": [20,30,10] }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "WriteMultipleRegistersRequest", "payload": { "function_code": 23, "address": 1, "count": 3 } }, "id" : "TestRequest"}

Masken-Schreibregister

Anfragebeispiel:

{ "request": { "operation": "MaskWriteRegisterRequest", "device": 1, "address": 0x01, "and_mask": 0xaf, "or_mask": 0x01

348


}, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "MaskWriteRegisterRequest", "payload": { "function_code": 22, "and_mask": 0, "or_mask": 8 } }, "id" : "TestRequest"}

Lesen mehrerer Register

Anfragebeispiel:

{ "request": { "operation": "ReadWriteMultipleRegistersRequest", "device": 1, "read_address": 0x01, "read_count": 2, "write_address": 0x03, "write_registers": [20,30,40] }, "id": "TestRequest"}

Antwortbeispiel:

{ "response": { "status": "success", "device": 1, "operation": "ReadWriteMultipleRegistersRequest", "payload": { "function_code": 23, "registers": [10,20,10,20] } }, "id" : "TestRequest"}

Note

Die in dieser Antwort zurückgegebenen Register sind die Register, aus denen gelesen wird.

Antwortstatus: Ausnahme

Ausnahmen können auftreten, wenn das Anfrageformat gültig ist, die Anfrage aber nicht erfolgreichabgeschlossen wurde. In diesem Fall enthält die Antwort die folgenden Informationen:

349


• Der status wird auf Exception gesetzt.• Der function_code entspricht dem Funktionscode der Anforderung + 128.• Der exception_code enthält den Ausnahmecode. Weitere Informationen finden Sie unter Modbus-

Ausnahmecodes.

Beispiel:

{ "response" : { "status" : "fail", "error_message": "Internal Error", "error": "Exception", "device": 1, "operation": "ReadCoilsRequest", "payload": { "function_code": 129, "exception_code": 2 } }, "id" : "TestRequest"}

Antwortstatus: Keine Antwort

Dieser Konnektor führt Validierungsprüfungen für die Modbus-Anforderung durch. So wird beispielsweisenach ungültigen Formaten und fehlenden Feldern gesucht. Wenn die Validierung fehlschlägt, sendet derKonnektor die Anforderung nicht. Stattdessen gibt er eine Antwort zurück, die die folgenden Informationenenthält:

• Der status wird auf No Response gesetzt.• Der error enthält die Fehlerursache.• Die error_message enthält die Fehlermeldung.

Beispiele:

{ "response" : { "status" : "fail", "error_message": "Invalid address field. Expected <type 'int'>, got <type 'str'>", "error": "No Response", "device": 1, "operation": "ReadCoilsRequest", "payload": { "error": "Invalid address field. Expected Expected <type 'int'>, got <type 'str'>" } }, "id" : "TestRequest"}

Wenn die Anforderung auf ein nicht vorhandenes Gerät abzielt oder wenn das Modbus RTU-Netzwerknicht funktioniert, erhalten Sie möglicherweise eine ModbusIOException, die das No Response-Formatverwendet.

{ "response" : { "status" : "fail", "error_message": "[Input/Output] No Response received from the remote unit",

350


"error": "No Response", "device": 1, "operation": "ReadCoilsRequest", "payload": { "error": "[Input/Output] No Response received from the remote unit" } }, "id" : "TestRequest"}


Note



import greengrasssdkimport json

TOPIC_REQUEST = 'modbus/adapter/request'

# Creating a greengrass core sdk clientiot_client = greengrasssdk.client('iot-data')

def create_read_coils_request(): request = { "request": { "operation": "ReadCoilsRequest", "device": 1, "address": 0x01, "count": 1 }, "id": "TestRequest" } return request

def publish_basic_request(): iot_client.publish(payload=json.dumps(create_read_coils_request()), topic=TOPIC_REQUEST)

publish_basic_request()


LizenzenDer Modbus-RTU-Protokolladapter-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:

• pymodbus/BSD• pyserial/BSD


351


https://github.com/riptideio/pymodbus/blob/master/README.rst

https://github.com/pyserial/pyserial


AWS IoT Greengrass EntwicklerhandbuchRaspberry Pi GPIO


Version Änderungen

2 Der Konnektor-ARN wurde zur Unterstützung derAWS-Region aktualisiert.

Verbesserte Fehlerprotokollierung.

1 Erstversion.


Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)

Raspberry Pi GPIODer Raspberry Pi GPIO-Konnektor (p. 297) steuert universell einsetzbare Input/Output (GPIO)-Pins aufeinem Raspberry Pi-Core-Gerät.

Dieser Konnektor fragt Eingangspins in einem bestimmten Intervall ab und veröffentlichtZustandsänderungen an MQTT-Themen. Es akzeptiert auch Lese- und Schreibanforderungen als MQTT-Nachrichten von benutzerdefinierten Lambda-Funktionen. Schreibanforderungen werden verwendet, umden Pin auf Hoch- oder Niederspannung zu setzen.

Der Konnektor stellt Parameter zur Verfügung, mit denen Sie Eingangs- und Ausgangspins definieren.Dieses Verhalten wird vor der Bereitstellung der Gruppe konfiguriert. Es kann während der Laufzeit nichtgeändert werden.

• Eingangspins können zum Empfangen von Daten von Peripheriegeräten verwendet werden.• Ausgangspins können zur Steuerung von Peripheriegeräten oder zum Senden von Daten an

Peripheriegeräte verwendet werden.

Sie können diesen Konnektor für viele Szenarien verwenden, wie z. B.:

• Steuerung der grünen, gelben und roten LED-Leuchten für eine Ampel.• Steuern eines Lüfters (mit einem elektrischen Relais verbunden) basierend auf Daten eines

Feuchtigkeitssensors.• Alarmierung der Mitarbeiter in einem Einzelhandelsgeschäft auf Knopfdruck.• Verwendung eines intelligenten Lichtschalters zur Steuerung anderer IoT-Geräte.

Note

Dieser Konnektor ist nicht geeignet für Anwendungen, die Echtzeitanforderungen habenEreignisse mit kurzer Dauer können verpasst werden.

352



Version ARN

1 arn:aws:greengrass:Region::/connectors/RaspberryPiGPIO/versions/1


• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Raspberry Pi 3 Modell B+ oder Modell B Sie müssen die PIN-Reihenfolge Ihres Raspberry Pi kennen.

Weitere Informationen finden Sie unter the section called “GPIO-Pin-Sequenz” (p. 353).• Ein lokale Geräteressource (p. 204) in der Greengrass-Gruppe, der auf /dev/gpiomem des

Raspberry Pi zeigt. Wenn Sie die Ressource in der Konsole erstellen, müssen Sie die OptionAutomatically add OS group permissions of the Linux group that owns the resource (AutomatischBetriebssystemgruppenberechtigungen der Linux-Gruppe hinzufügen, zu der die Ressource gehört)auswählen. Setzen Sie in der API die Eigenschaft GroupOwnerSetting.AutoAddGroupOwner auftrue.

• Das Modul RPi.GPIO, das auf dem Raspberry Pi installiert ist. In Raspbian ist dieses Modulstandardmäßig installiert. Mit dem folgenden Befehl können Sie es neu installieren:

sudo pip install RPi.GPIO

GPIO-Pin-SequenzDer Raspberry Pi GPIO-Connector verweist auf GPIO-Pins gemäß dem Nummerierungsschema deszugrundeliegenden SoC (System on Chip), nicht gemäß dem physischen Layout der GPIO-Pins. Diephysische Anordnung der Pins kann in verschiedenen Raspberry Pi-Versionen unterschiedlich sein.Weitere Informationen finden Sie unter GPIO in der Raspberry Pi-Dokumentation.

Der Konnektor kann nicht prüfen, ob die von Ihnen konfigurierten Ein- und Ausgangspins korrekt auf diezugrunde liegende Hardware Ihres Raspberry Pi passen. Wenn die Pin-Konfiguration ungültig ist, gibt derKonnektor einen Laufzeitfehler zurück, wenn er versucht, auf dem Gerät zu starten. Um dieses Problem zubeheben, konfigurieren Sie den Konnektor neu und stellen Sie ihn dann erneut bereit.

Note

Stellen Sie sicher, dass die Peripheriegeräte für GPIO-Pins richtig verdrahtet sind, um Schäden anden Komponenten zu vermeiden.


InputGpios

Eine kommagetrennte Liste von GPIO-Pin-Nummern, die als Eingänge konfiguriert werden können.Optional können Sie U anfügen, um den Pull-up-Widerstand eines Pins einzustellen, oder D, um denPull-down-Widerstand einzustellen. Beispiel: "5,6U,7D".

Anzeigename in der Konsole: Input GPIO Pins

353




https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/

https://www.raspberrypi.org/documentation/usage/gpio/


Erforderlich: false. Sie müssen Eingangspins, Ausgangspins oder beides angeben.

Typ: string

Gültiges Muster: ^$|^[0-9]+[UD]?(,[0-9]+[UD]?)*$InputPollPeriod

Das Intervall (in Millisekunden) zwischen jedem Polling-Vorgang, das die Eingangs-GPIO-Pins aufZustandsänderungen überprüft. Der minimale Wert beträgt 1.

Dieser Wert hängt von Ihrem Szenario und der Art der abgerufenen Geräte ab. Ein Wert von 50 solltebeispielsweise schnell genug sein, um einen Tastendruck zu erkennen.

Anzeigename in der Konsole: Input GPIO polling period (Input GPIO Abrufzeitraum)

Erforderlich: false

Typ: integer

Gültiges Muster: ^$|^[1-9][0-9]*$OutputGpios

Eine kommagetrennte Liste von GPIO-Pin-Nummern, die als Ausgänge konfiguriert werden können.Optional kann H angefügt werden, um einen hohen Zustand (1) zu setzen, oder L, um einen niedrigenZustand (0) einzustellen. Beispiel: "8H,9,27L".

Anzeigename in der Konsole: Output GPIO Pins

Erforderlich: false. Sie müssen Eingangspins, Ausgangspins oder beides angeben.

Typ: string

Gültiges Muster: ^$|^[0-9]+[HL]?(,[0-9]+[HL]?)*$GpioMem-ResourceId

Die ID der lokalen Geräteressource, die /dev/gpiomem repräsentiert.Note


Anzeigename in der Konsole: Resource for /dev/gpiomem device ( Ressource für /dev/gpiomem Gerät)

Erforderlich: true

Typ: string


Beispiel: Erstellen eines Connectors (CLI)Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den Raspberry PiGPIO-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyRaspberryPiGPIOConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/RaspberryPiGPIO/versions/1", "Parameters": {

354


"GpioMem-ResourceId": "my-gpio-resource", "InputGpios": "5,6U,7D", "InputPollPeriod": 50, "OutputGpios": "8H,9,27L" } } ]}'

Note



EingabedatenDieser Konnektor akzeptiert Lese- oder Schreibanforderungen für GPIO-Pins zu zwei MQTT-Themen.Eingabemeldungen müssen das JSON-Format aufweisen.

• Leseanforderungen zum Thema gpio/+/+/read.• Schreibanforderungen zum Thema gpio/+/+/write.

Um zu diesen Themen zu veröffentlichen, ersetzen Sie jeweils die Platzhalter + durch den Namen derCore-Objekte und die Nummer des Zielpins. Beispiel:

gpio/core-thing-name/gpio-number/read

Note

Derzeit müssen Sie beim Erstellen eines Abonnements, das den Raspberry Pi GPIO-Konnektorverwendet, einen Wert für mindestens einen der+-Platzhalter im Thema angeben.

Themenfilter: gpio/+/+/read

Verwenden Sie dieses Thema, um den Konnektor anzuweisen, den Zustand des GPIO-Pins zu lesen,der im Thema angegeben ist.

Der Konnektor veröffentlicht die Antwort zum entsprechenden Ausgabethema (z. B. gpio/core-thing-name/gpio-number/state).Nachrichten-Eigenschaften

Keine. Nachrichten, die an dieses Thema gesendet werden, werden ignoriert.Themenfilter: gpio/+/+/write

Verwenden Sie dieses Thema, um Schreibanfragen an einen GPIO-Pin zu senden. Dadurch wirdder Konnektor angewiesen, den GPIO-Pin, der im Thema angegeben ist, auf eine Nieder- oderHochspannung einzustellen.• 0 setzt den Pin auf Niederspannung.• 1 setzt den Pin auf Hochspannung.

Der Konnektor veröffentlicht die Antwort zum entsprechenden /state-Thema (z. B. gpio/core-thing-name/gpio-number/state).Nachrichten-Eigenschaften

Der Wert 0 oder 1 als ganze Zahl oder Zeichenkette.

355


Beispieleingabe

0

AusgabedatenDieser Konnektor veröffentlicht Daten zu zwei Themen:

• Hohe oder niedrige Zustandsänderungen im Thema gpio/+/+/state.• Fehler im Thema gpio/+/error.

Themenfilter: gpio/+/+/state

Verwenden Sie dieses Thema, um auf Zustandsänderungen an den Eingangspins und Antworten aufLeseanforderungen zu warten. Der Konnektor gibt die Zeichenkette "0" zurück, wenn sich der Pin ineinem niedrigen Zustand befindet, oder "1", wenn er sich in einem hohen Zustand befindet.

Bei der Veröffentlichung zu diesem Thema ersetzt der Konnektor die Platzhalter + durch den Namendes Core-Objekts bzw. den Zielpin. Beispiel:

gpio/core-thing-name/gpio-number/state

Note

Derzeit müssen Sie beim Erstellen eines Abonnements, das den Raspberry Pi GPIO-Konnektor verwendet, einen Wert für mindestens einen der+-Platzhalter im Thema angeben.

Beispielausgabe

0

Themenfilter: gpio/+/errors

Verwenden Sie dieses Thema, um nach Fehlern zu suchen. Der Konnektor veröffentlicht zu diesemThema aufgrund einer ungültigen Anforderung, (z. B., wenn eine Zustandsänderung an einemEingangspin angefordert wird).

Bei der Veröffentlichung zu diesem Thema ersetzt der Konnektor den Platzhalter + durch den Namendes Core-Objekts.Beispielausgabe

{ "topic": "gpio/my-core-thing/22/write", "error": "Invalid GPIO operation", "long_description": "GPIO 22 is configured as an INPUT GPIO. Write operations are not permitted." }

VerwendungsbeispielDie folgende Lambda-Beispielfunktion sendet eine Eingabenachricht an den Connector. Dieses Beispielsendet Leseanforderungen für einen Satz von Input-GPIO-Pins. Es zeigt, wie Sie Themen mit dem Namendes Core-Objekts und der PIN-Nummer erstellen.

356

AWS IoT Greengrass EntwicklerhandbuchSerial Stream

Note




iot_client = greengrasssdk.client('iot-data')INPUT_GPIOS = [6, 17, 22]

thingName = os.environ['AWS_IOT_THING_NAME']

def get_read_topic(gpio_num): return '/'.join(['gpio', thingName, str(gpio_num), 'read'])

def get_write_topic(gpio_num): return '/'.join(['gpio', thingName, str(gpio_num), 'write'])

def send_message_to_connector(topic, message=''): iot_client.publish(topic=topic, payload=str(message))

def set_gpio_state(gpio, state): send_message_to_connector(get_write_topic(gpio), str(state))

def read_gpio_state(gpio): send_message_to_connector(get_read_topic(gpio))

def publish_basic_message(): for i in INPUT_GPIOS: read_gpio_state(i)




Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• GPIO in der Raspberry Pi-Dokumentation

Serial StreamDer Serial Stream Konnektor (p. 297) liest und schreibt auf eine serielle Schnittstelle eines AWS IoTGreengrass Core-Geräts.

Dieser Konnektor unterstützt zwei Betriebsarten:

357



https://www.raspberrypi.org/documentation/usage/gpio/


• Read-On-Demand. Empfängt Lese- und Schreibanforderungen zu MQTT-Themen und veröffentlicht dieAntwort des Lesevorgangs oder den Status des Schreibvorgangs.

• Polling-Read. Liest in regelmäßigen Abständen von der seriellen Schnittstelle. Dieser Modus unterstütztauch Read-On-Demand-Anfragen.

Note

Leseanforderungen sind auf eine maximale Leselänge von 63994 Bytes begrenzt.Schreibanforderungen sind auf eine maximale Datenlänge von 128000 Bytes beschränkt.


Version ARN

2 arn:aws:greengrass:Region::/connectors/SerialStream/versions/2

1 arn:aws:greengrass:Region::/connectors/SerialStream/versions/1



• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Ein lokale Geräteressource (p. 204) in der Greengrass-Gruppe, der auf die serielle Zielschnittstelle zeigt.

Note

Bevor Sie diesen Konnektor bereitstellen, empfehlen wir, die serielle Schnittstelle einzurichtenund zu überprüfen, ob sie lesbar und beschreibbar ist.


BaudRate

Die Baudrate der seriellen Verbindung.

Anzeigename in der Konsole: Baud rate (Baudrate)

Erforderlich: true

Typ: string

Zulässige Werte: 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800,38400, 56000, 57600, 115200, 230400

Gültiges Muster: ^110$|^300$|^600$|^1200$|^2400$|^4800$|^9600$|^14400$|^19200$|^28800$|^38400$|^56000$|^57600$|^115200$|^230400$

358



Timeout

Der Timeout (in Sekunden) für einen Lesevorgang.

Anzeigename in der Konsole: Timeout

Erforderlich: true

Typ: string


Gültiges Muster: ^([1-9]|[1-5][0-9])$SerialPort

Der absolute Pfad zur physikalischen seriellen Schnittstelle auf dem Gerät. Dies ist der Quellpfad, derfür die lokale Geräteressource angegeben ist.

Anzeigename in der Konsole: Serial port (Serielle Schnittstelle)

Erforderlich: true

Typ: string

Gültiges Muster: [/a-zA-Z0-9_-]+SerialPort-ResourceId

Die ID der lokalen Geräteressource, die die physische serielle Schnittstelle darstellt.Note


Anzeigename in der Konsole: Serial port resource (Ressource für die serielle Schnittstelle)

Erforderlich: true

Typ: string

Gültiges Muster: [a-zA-Z0-9_-]+PollingRead

Stellt den Lesemodus ein: Polling-Read oder Read-On-Demand.• Für den Polling-Read-Modus geben Sie true an. In diesem Modus werden nur die EigenschaftenPollingInterval, PollingReadType und PollingReadLength benötigt.

• Für den Read-On-Demand-Modus geben Sie false an. In diesem Modus werden die Werte für Typund Länge in der Leseanforderung angegeben.

Anzeigename in der Konsole: Read mode (Read-Modus)

Erforderlich: true

Typ: string

Zulässige Werte: true, false

Gültiges Muster: ^([Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$PollingReadLength

Die Länge der zu lesenden Daten (in Bytes) bei jedem Polling-Lesevorgang. Dies gilt nur beiVerwendung des Polling-Read-Modus.

359


Anzeigename in der Konsole: Polling read length (Polling Leselänge)

Erforderlich: false. Diese Eigenschaft ist erforderlich, wenn PollingRead true ist.

Typ: string

Gültiges Muster: ^(|[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-2][0-9]{3}|63[0-8][0-9]{2}|639[0-8][0-9]|6399[0-4])$

PollingReadInterval

Das Intervall (in Sekunden), in dem das Lesen des Pollings stattfindet. Dies gilt nur bei Verwendungdes Polling-Read-Modus.

Anzeigename in der Konsole: Polling read interval (Polling Leseintervall)


Typ: string


Gültiges Muster: ^(|[1-9]|[1-9][0-9]|[1-9][0-9][0-9])$PollingReadType

Der Typ der Daten, die der Polling-Thread liest. Dies gilt nur bei Verwendung des Polling-Read-Modus.

Anzeigename in der Konsole: Polling read type (Polling Read-Typ)


Typ: string

Zulässige Werte: ascii, hex

Gültiges Muster: ^(|[Aa][Ss][Cc][Ii][Ii]|[Hh][Ee][Xx])$RtsCts

Gibt an, ob die RTS/CTS-Flusssteuerung aktiviert werden soll. Der Standardwert ist false. WeitereInformationen finden Sie unter RTS, CTS und RTR.

Anzeigename in der Konsole: RTS/CTS flow control (RTS/CTS-Flusssteuerung)

Erforderlich: false

Typ: string


Gültiges Muster: ^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$XonXoff

Gibt an, ob die Software-Flusssteuerung aktiviert werden soll. Der Standardwert ist false. WeitereInformationen finden Sie unter Software-Flusssteuerung.

Anzeigename in der Konsole: Software flow control (Software-Flusssteuerung)

Erforderlich: false

Typ: string

360

https://en.wikipedia.org/wiki/RS-232#RTS,_CTS,_and_RTR

https://en.wikipedia.org/wiki/Software_flow_control



Gültiges Muster: ^(|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])$Parity

Die Parität der seriellen Schnittstelle. Der Standardwert ist N. Weitere Informationen finden Sie unterParität.

Anzeigename in der Konsole: Serial port parity (Parität der seriellen Schnittstelle)

Erforderlich: false

Typ: string

Zulässige Werte: N, E, O, S, M

Gültiges Muster: ^(|[NEOSMneosm])$


Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den SerialStream-Konnektor enthält. Konfiguriert den Konnektor für den Polling-Read-Modus.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MySerialStreamConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/SerialStream/versions/2", "Parameters": { "BaudRate" : "9600", "Timeout" : "25", "SerialPort" : "/dev/serial1", "SerialPort-ResourceId" : "my-serial-port-resource", "PollingRead" : "true", "PollingReadLength" : "30", "PollingReadInterval" : "30", "PollingReadType" : "hex" } } ]}'


EingabedatenDieser Konnektor akzeptiert Lese- oder Schreibanforderungen für serielle Schnittstellen zu zwei MQTT-Themen. Eingabemeldungen müssen das JSON-Format aufweisen.

• Leseanforderungen zum Thema serial/+/read/#.• Schreibanforderungen zum Thema serial/+/write/#.

Um zu diesen Themen zu veröffentlichen, ersetzen Sie den Platzhalter + durch den Namen des Core-Objekts und den Platzhalter # durch den Pfad zur seriellen Schnittstelle. Beispiel:

361

https://en.wikipedia.org/wiki/Serial_port#Parity


serial/core-thing-name/read/dev/serial-port

Themenfilter: serial/+/read/#

Verwenden Sie dieses Thema, um On-Demand-Leseanforderungen an einen seriellen Pin zu senden.Leseanforderungen sind auf eine maximale Leselänge von 63994 Bytes begrenzt.Nachrichten-Eigenschaften

readLength

Die Länge der Daten, die von der seriellen Schnittstelle gelesen werden sollen.

Erforderlich: true

Typ: string

Gültiges Muster: ^[1-9][0-9]*$type

Der Typ der zu lesenden Daten.

Erforderlich: true

Typ: string


Gültiges Muster: (?i)^(ascii|hex)$id

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung einer Ausgabeantwort zuzuordnen.

Erforderlich: false

Typ: string

Gültiges Muster: .+Beispieleingabe

{ "readLength": "30", "type": "ascii", "id": "abc123"}

Themenfilter: serial/+/write/#

Verwenden Sie dieses Thema, um Schreibanforderungen an einen seriellen Pin zu senden.Schreibanforderungen sind auf eine maximale Datenlänge von 128000 Bytes beschränkt.Nachrichten-Eigenschaften

data

Die Zeichenfolge, die auf die serielle Schnittstelle geschrieben werden soll.

Erforderlich: true

Typ: string

362


Gültiges Muster: ^[1-9][0-9]*$type

Der Typ der zu lesenden Daten.

Erforderlich: true

Typ: string


Gültiges Muster: ^(ascii|hex|ASCII|HEX)$id


Erforderlich: false

Typ: string

Gültiges Muster: .+Beispiel-Eingabe: ASCII-Anforderung

{ "data": "random serial data", "type": "ascii", "id": "abc123"}

Beispiel-Eingabe: Hex-Anforderung

{ "data": "base64 encoded data", "type": "hex", "id": "abc123"}

AusgabedatenDer Konnektor veröffentlicht Ausgabedaten zu zwei Themen:

• Statusinformationen aus dem Konnektor zum Thema serial/+/status/#.• Antworten auf Leseanforderungen zum Thema serial/+/read_response/#.

Bei der Veröffentlichung zu diesem Thema ersetzt der Konnektor den Platzhalter + durch den Namen desCore-Objekts und den Platzhalter # durch den Pfad zur seriellen Schnittstelle. Beispiel:

serial/core-thing-name/status/dev/serial-port

Themenfilter: serial/+/status/#

Verwenden Sie dieses Thema, um den Status von Lese- und Schreibanforderungen anzuhören. Wenneine id-Eigenschaft in die Anfrage aufgenommen wird, wird sie in der Antwort zurückgegeben.

363



{ "response": { "status": "success" }, "id": "abc123"}


Eine Fehlerreaktion beinhaltet eine error_message-Eigenschaft, die den Fehler oder dasTimeout beschreibt, das beim Ausführen des Lese- oder Schreibvorgangs aufgetreten ist.

{ "response": { "status": "fail", "error_message": "Could not write to port" }, "id": "abc123"}

Themenfilter: serial/+/read_response/#

Verwenden Sie dieses Thema, um Antwortdaten von einem Lesevorgang zu empfangen. DieAntwortdaten sind Base64-kodiert, wenn der Typ hex ist.Beispielausgabe

{ "data": "output of serial read operation" "id": "abc123"}


Note




TOPIC_REQUEST = 'serial/CORE_THING_NAME/write/dev/serial1'

# Creating a greengrass core sdk clientiot_client = greengrasssdk.client('iot-data')

def create_serial_stream_request(): request = { "data": "TEST", "type": "ascii", "id": "abc123"

364


AWS IoT Greengrass EntwicklerhandbuchServiceNow MetricBase-Integration

} return request

def publish_basic_request(): iot_client.publish(payload=json.dumps(create_serial_stream_request()), topic=TOPIC_REQUEST)

publish_basic_request()


LizenzenDer Serial Stream-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:

• pyserial/BSD



Version Änderungen

2 Der Konnektor-ARN wurde zur Unterstützung derAWS-Region aktualisiert.

1 Erstversion.



ServiceNow MetricBase-IntegrationDer ServiceNow MetricBase-Integration Konnektor (p. 297) veröffentlicht Zeitreihenmetriken vonGreengrass-Geräten in ServiceNow MetricBase. Auf diese Weise können Sie Zeitreihendaten aus derGreengrass Core-Umgebung speichern, analysieren und visualisieren und auf lokale Ereignisse reagieren.

Dieser Konnektor empfängt Zeitreihendaten zu einem MQTT-Thema und veröffentlicht die Daten inregelmäßigen Abständen an die ServiceNow-API.

Sie können diesen Konnektor zur Unterstützung vieler Szenarien verwenden, darunter z. B.:

• Erstellen von Schwellenwert-basierten Warnmeldungen und Alarmen basierend auf Zeitreihendaten, dievon Greengrass-Geräten gesammelt wurden.

• Verwenden von Zeitservicedaten von Greengrass-Geräten mit benutzerdefinierten Anwendungen, die aufder ServiceNow-Plattform basieren.

365

https://github.com/pyserial/pyserial



ARN: arn:aws:greengrass:Region::/connectors/ServiceNowMetricBaseIntegration/versions/1


• AWS IoT Greengrass Core-Software v1.7 or later. AWS IoT Greengrass muss zur Unterstützung lokalerSecrets konfiguriert sein, wie unter Voraussetzungen für Secrets (p. 276) beschrieben.

Note


• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Ein ServiceNow-Konto mit aktiviertem Abonnement für MetricBase. Darüber hinaus muss im Konto eine

Metrik und eine metrische Tabelle angelegt werden. Weitere Informationen finden Sie unter MetricBasein der ServiceNow-Dokumentation.

• Ein Texttyp Secret in AWS Secrets Manager, das den Benutzernamen und das Passwort für IhreServiceNow-Instance (für die Basisauthentifizierung) speichert. Das Secret muss "Benutzer-" und"Passwort-"Schlüssel mit entsprechenden Werten enthalten. Weitere Informationen finden Sie unterErstellen eines grundlegenden Secrets im AWS Secrets Manager-Benutzerhandbuch.

• Eine geheime Ressource in der Greengrass-Gruppe, die auf das Secrets Manager-Secret verweist.Weitere Informationen finden Sie unter Secrets für Core bereitstellen (p. 274).


PublishInterval

Die maximale Wartezeit in Sekunden zwischen den Veröffentlichungsereignissen für ServiceNow. Dermaximale Wert beträgt 900.

Der Connector veröffentlicht an ServiceNow, wenn die PublishBatchSize erreicht ist oder dasPublishInterval abläuft.

Anzeigename in der Konsole: Publish interval in seconds (Veröffentlichungsintervall in Sekunden)

Erforderlich: true

Typ: string


Gültiges Muster: [1-9]|[1-9]\d|[1-9]\d\d|900PublishBatchSize

Die maximale Anzahl von Metrikenwerten, die vor der Veröffentlichung für ServiceNow gesammeltwerden können.

Der Connector veröffentlicht an ServiceNow, wenn die PublishBatchSize erreicht ist oder dasPublishInterval abläuft.

Anzeigename in der Konsole: Publish batch size (Stapel-Größe für die Veröffentlichung)

366


https://docs.servicenow.com/bundle/london-servicenow-platform/page/administer/metricbase/concept/metricbase.html

https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html


Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$InstanceName

Der Name der Instance, mit der die Verbindung zu ServiceNow hergestellt wird.

Anzeigename in der Konsole: Name of ServiceNow instance (Name der ServiceNow-Instance)

Erforderlich: true

Typ: string

Gültiges Muster: .+DefaultTableName

Der Name der Tabelle, die den GlideRecord enthält, der der Zeitreihe der MetricBase-Datenbankzugeordnet ist. Die Eigenschaft table in der Nutzlast der Input-Message kann verwendet werden, umdiesen Wert zu überschreiben.

Anzeigename in der Konsole: Der Name der Tabelle, die die Metrik enthält

Erforderlich: true

Typ: string

Gültiges Muster: .+MaxMetricsToRetain

Die maximale Anzahl der Metriken, die im Speicher gespeichert werden können, bevor sie durch neueMetriken ersetzt werden.

Diese Begrenzung gilt, wenn keine Verbindung zum Internet besteht und der Konnektor beginnt, dieMetriken zu puffern, um sie später zu veröffentlichen. Wenn der Puffer voll ist, werden die ältestenMetriken durch neue Metriken ersetzt.

Note

Metriken werden nicht gespeichert, wenn der Host-Prozess für den Konnektor unterbrochenwird. Dies kann beispielsweise während der Gruppen-Bereitstellung oder beim Neustart desGeräts geschehen.

Dieser Wert sollte größer als die Batch-Größe und groß genug sein, um Nachrichten basierend auf derEingangsrate der MQTT-Nachrichten zu halten.

Anzeigename in der Konsole: Maximum metrics to retain in memory (Maximale Anzahl der im Speicherzu erhaltenden Metriken)

Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$AuthSecretArn

Das Secret in AWS Secrets Manager, das den ServiceNow-Benutzernamen und das Passwortspeichert. Dies muss ein Texttyp Secret sein. Das Secret muss "Benutzer-" und "Passwort-"Schlüsselmit entsprechenden Werten enthalten.

367


Anzeigename in der Konsole: ARN of auth secret (ARN des auth Secrets)

Erforderlich: true

Typ: string

Gültiges Muster: arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+

AuthSecretArn-ResourceId

Die geheime Ressource in der Gruppe, die auf das Secrets Manager-Secret der ServiceNow-Anmeldeinformationen verweist.

Anzeigename in der Konsole: Auth token resource (Auth token-Ressource)

Erforderlich: true

Typ: string



Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den ServiceNowMetricBase-Integration-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyServiceNowMetricBaseIntegrationConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/ServiceNowMetricBaseIntegration/versions/1", "Parameters": { "PublishInterval" : "10", "PublishBatchSize" : "50", "InstanceName" : "myinstance", "DefaultTableName" : "u_greengrass_app", "MaxMetricsToRetain" : "20000", "AuthSecretArn" : "arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash", "AuthSecretArn-ResourceId" : "MySecretResource" } } ]}'

Note



EingabedatenDieser Konnektor akzeptiert Zeitreihenmetriken zu einem MQTT-Thema und veröffentlicht die Metriken inServiceNow. Eingabemeldungen müssen das JSON-Format aufweisen.

368


Themenfilter

servicenow/metricbase/metric


Informationen über die Tabelle, den Datensatz und die Metrik. Diese Anforderung repräsentiertdas Objekt seriesRef in einer Zeitreihen-POST-Anforderung. Weitere Informationen finden Sieunter Clotho Zeitreihen-API - POST.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:subject

Die sys_id des spezifischen Datensatzes in der Tabelle.

Erforderlich: true

Typ: stringmetric_name

Der Metrik-Feldname.

Erforderlich: true

Typ: stringtable

Der Name der Tabelle, in der der Datensatz gespeichert werden soll. Geben Sie diesen Wertan, um den Parameter DefaultTableName zu überschreiben.

Erforderlich: false

Typ: stringvalue

Der Wert des einzelnen Datenpunktes.

Erforderlich: true

Typ: floattimestamp

Der Zeitstempel des einzelnen Datenpunktes. Der Standardwert ist die aktuelle Zeit.

Erforderlich: false

Typ: stringBeispieleingabe

{ "request": { "subject":"ef43c6d40a0a0b5700c77f9bf387afe3", "metric_name":"u_count", "table": "u_greengrass_app" "value": 1.0,

369

https://docs.servicenow.com/bundle/london-application-development/page/integrate/inbound-rest/concept/Clotho-Time-Series-API.html#clotho-POST-put


"timestamp": "2018-10-14T10:30:00" }}


Themenfilter

servicenow/metricbase/metric/status


{ "response": { "metric_name": "Errors", "table_name": "GliderProd", "processed_on": "2018-10-14T10:35:00", "response_id": "khjKSkj132qwr23fcba", "status": "success", "values": [ { "timestamp": "2016-10-14T10:30:00", "value": 1.0 }, { "timestamp": "2016-10-14T10:31:00", "value": 1.1 } ] }}


{ "response": { "error": "InvalidInputException", "error_message": "metric value is invalid", "status": "fail" }}

Note

Wenn der Connector einen wiederholbaren Fehler (etwa einen Verbindungsfehler) erkennt,wird die Veröffentlichung im nächsten Stapel erneut versucht.


Note


370


AWS IoT Greengrass EntwicklerhandbuchSNS



iot_client = greengrasssdk.client('iot-data')SEND_TOPIC = 'servicenow/metricbase/metric'

def create_request_with_all_fields(): return { "request": { "subject": '2efdf6badbd523803acfae441b961961', "metric_name": 'u_count', "value": 1234, "timestamp": '2018-10-20T20:22:20', "table": 'u_greengrass_metricbase_test' } }

def publish_basic_message(): messageToPublish = create_request_with_all_fields() print "Message To Publish: ", messageToPublish iot_client.publish(topic=SEND_TOPIC, payload=json.dumps(messageToPublish))



LizenzenDer ServiceNow MetricBase-Integration-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:

• pysnow/MIT



SNSDer SNS Konnektor (p. 297) veröffentlicht Nachrichten in einem Amazon SNS-Thema. Auf dieseWeise können Webserver, E-Mail-Adressen und andere Nachrichtenabonnenten auf Ereignisse in derGreengrass-Gruppe reagieren.

Dieser Konnektor empfängt SNS-Nachrichteninformationen zu einem MQTT-Thema und sendet dieNachricht dann an ein bestimmtes SNS-Thema. Sie können optional benutzerdefinierte Lambda-Funktionen verwenden, um Filter- oder Formatierungslogik für Nachrichten zu implementieren, bevor sie andiesen Konnektor veröffentlicht werden.

ARN: arn:aws:greengrass:Region::/connectors/SNS/versions/1

371

https://github.com/rbw/pysnow




• AWS IoT Greengrass Core-Software v1.7 or later.• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Ein konfiguriertes SNS-Thema. Weitere Informationen finden Sie unter Erstellen eines Themas im

Entwicklerhandbuch für Amazon Simple Notification Service.• Eine IAM-Richtlinie, die der Greengrass-Gruppenrolle hinzugefügt wurde, die die Aktion sns:Publish

für das SNS-Thema erlaubt, wie im folgenden Beispiel gezeigt:

{ "Version":"2012-10-17", "Statement":[ { "Sid":"Stmt1528133056761", "Action":[ "sns:Publish" ], "Effect":"Allow", "Resource":[ "arn:aws:sns:region:account-id:topic-name" ] } ] }

Mit diesem Konnektor können Sie das standardmäßige Thema in der Nutzlast der Input-Messagedynamisch überschreiben. Wenn Ihre Implementierung diese Funktion verwendet, muss die IAM-Richtlinie die Berechtigung sns:Publish für alle Zielthemen zulassen. Sie können Ressourcengranularen oder bedingten Zugriff gewähren 8etwa mit einem benennungsschema mit Platzhaltern*). Weitere Informationen finden Sie unter Hinzufügen und Entfernen von IAM-Richtlinien im IAM-Benutzerhandbuch.


DefaultSNSArn

Der ARN des Standard-SNS-Themas, in dem Nachrichten veröffentlicht werden sollen. DasZiel-Thema kann durch die Eigenschaft sns_topic_arn in der Nutzlast der Eingangsnachrichtüberschrieben werden.

Note

Die Gruppenrolle muss die Berechtigung sns:Publish für alle Ziel-Themen erlauben.Weitere Informationen finden Sie unter the section called “Voraussetzungen” (p. 372).

Anzeigename in der Konsole: Default SNS topic ARN (Standard SNS-Thema-ARN)

Erforderlich: true

Typ: string

Gültiges Muster: arn:aws:sns:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):([a-zA-Z0-9-_]+)$

372


https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html




Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den SNS-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MySNSConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/SNS/versions/1", "Parameters": { "DefaultSNSArn": "arn:aws:sns:region:account-id:topic-name" } } ]}'


EingabedatenDieser Konnektor akzeptiert SNS-Nachrichteninformationen zu einem MQTT-Thema und veröffentlichtdie Nachricht dann unverändert im Ziel-SNS-Thema. Eingabemeldungen müssen das JSON-Formataufweisen.

Themenfilter

sns/message


Informationen über die zu sendende Nachricht an das SNS-Thema.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:message

Der Inhalt der Nachricht liegt als Zeichenfolge oder im JSON-Format vor. Beispiele finden Sieunter Beispieleingabe (p. 374).

Zum Senden von JSON muss die Eigenschaft message_structure auf json gesetzt sein,und die Nachricht muss eine zeichenfolgenkodiertes JSON-Objekt mit einem default-Schlüssel sein.

Erforderlich: true

Typ: string

Gültiges Muster: .*subject

Der Betreff der Nachricht.

Erforderlich: false

373


Typ: ASCII-Text bis zu 100 Zeichen. Dieser muss mit einem Buchstaben, einer Zahl odereinem Satzzeichen beginnen. Er darf keine Zeilenumbrüche oder Steuerzeichen enthalten.

Gültiges Muster: .*sns_topic_arn

Der ARN des SNS-Themas, in dem Nachrichten veröffentlicht werden sollen. Wennangegeben, veröffentlicht der Konnektor zu diesem Thema anstelle des Standardthemas.

Note

Die Gruppenrolle muss die Berechtigung sns:Publish für jedes Ziel-Thema erlauben. Weitere Informationen finden Sie unter the section called“Voraussetzungen” (p. 372).

Erforderlich: false

Typ: string

Gültiges Muster: arn:aws:sns:([a-z]{2}-[a-z]+-\d{1}):(\d{12}):([a-zA-Z0-9-_]+)$

message_structure

Der Struktur der Nachricht.

Erforderlich: false. Dies muss angegeben werden, damit eine JSON-Nachricht gesendetwerden kann.

Typ: string

Zulässige Werte: jsonid

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung einer Ausgabeantwort zuzuordnen. Wenn angegeben, wird die Eigenschaftid im Antwortobjekt auf diesen Wert gesetzt. Wenn Sie diese Funktion nicht verwenden, könnenSie diese Eigenschaft weglassen oder eine leere Zeichenkette angeben.

Erforderlich: false

Typ: string

Gültiges Muster: .*Beschränkungen

Die Nachrichtengröße ist durch eine maximale SNS-Nachrichtengröße von 256 KB begrenzt.Beispieleingabe: Zeichenfolgen-Nachricht

Dieses Beispiel sendet eine Zeichenfolgen-Nachricht. Es legt die optionale sns_topic_arn-Eigenschaft fest, durch die das Standard-Ziel-Thema außer Kraft gesetzt wird.

{ "request": { "subject": "Message subject", "message": "Message data", "sns_topic_arn": "arn:aws:sns:region:account-id:topic2-name" }, "id": "request123"}

374


Beispieleingabe: JSON-Nachricht

Dieses Beispiel sendet eine Nachricht als zeichenfolgenkodiertes JSON-Objekt mit dem default-Schlüssel.

{ "request": { "subject": "Message subject", "message": "{ \"default\": \"Message data\" }", "message_structure": "json" }, "id": "request123"}


Themenfilter

sns/message/status


{ "response": { "sns_message_id": "f80a81bc-f44c-56f2-a0f0-d5af6a727c8a", "status": "success" }, "id": "request123"}


{ "response" : { "error": "InvalidInputException", "error_message": "SNS Topic Arn is invalid", "status": "fail" }, "id": "request123"}


Note



import greengrasssdkimport time

375


AWS IoT Greengrass EntwicklerhandbuchSplunk-Integration

import json

iot_client = greengrasssdk.client('iot-data')send_topic = 'sns/message'

def create_request_with_all_fields(): return { "request": { "message": "Message from SNS Connector Test" }, "id" : "req_123" }




LizenzenDer SNS-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:



Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Die Veröffentlichen-Aktion in der Boto 3-Dokumentation• Was ist der Amazon Simple Notification Service? im Entwicklerhandbuch für Amazon Simple Notification

Service

Splunk-IntegrationDer Splunk-Integration Konnektor (p. 297) veröffentlicht Daten von Greengrass-Geräten für Splunk.Dies ermöglicht es Ihnen, Splunk zur Überwachung und Analyse der Greengrass Core-Umgebung zuverwenden und auf lokale Ereignisse zu reagieren. Der Konnektor ist in den HTTP Event Collector (HEC)integriert. Weitere Informationen finden Sie unter Einführung in den Splunk HTTP Event Collector in derSplunk-Dokumentation.

Dieser Konnektor empfängt Protokoll- und Ereignisdaten zu einem MQTT-Thema und veröffentlicht dieDaten an die Splunk-API.

Sie können diesen Konnektor zur Unterstützung von industriellen Szenarien verwenden, darunter z. B.:

• Die Betreiber können periodische Daten von Stellgliedern und Sensoren (z. B. Temperatur-, Druck- undWasserwerte) verwenden, um Alarme auszulösen, wenn Werte bestimmte Schwellenwerte überschrittenwerden.

376



https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish

https://docs.aws.amazon.com/sns/latest/dg/welcome.html

https://dev.splunk.com/view/event-collector/SP-CAAAE6M


• Developer können Daten verwenden, die von Industriemaschinen gesammelt wurden, um ML-Modelle zuentwerfen, die die Anlagen auf mögliche Probleme überwachen.

ARN: arn:aws:greengrass:Region::/connectors/SplunkIntegration/versions/1



Note


• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.• Die Funktionalität des HTTP Event Collectors muss im Splunk aktiviert sein. Weitere Informationen

finden Sie unter Einrichten und Verwenden des HTTP Event Collectors im Splunk Web in der Splunk-Dokumentation.

• Ein Texttyp Secret in AWS Secrets Manager, der Ihr Splunk HTTP Event Collector Token speichert.Weitere Informationen finden Sie unter Über Event Collector-Token in der Splunk-Dokumentation undErstellen eines grundlegenden Secrets im AWS Secrets Manager-Benutzerhandbuch.

Note

Um ein Secret in der Secrets Manager-Konsole zu erstellen, geben Sie Ihr Token auf derRegisterkarte Plaintext (Klartext) ein. Verwenden Sie dabei keine Anführungszeichen oderandere Formatierungen. Geben Sie in der API das Token als Wert für die EigenschaftSecretString ein.



SplunkEndpoint

Der Endpunkt Ihrer Splunk-Instance. Dieser Wert muss das Protokoll, den Hostnamen und den Portenthalten.

Anzeigename in der Konsole: Splunk endpoint (Splunk-Endpunkt)

Erforderlich: true

Typ: string

Gültiges Muster: ^(http:\/\/|https:\/\/)?[a-z0-9]+([-.]{1}[a-z0-9]+)*.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$

MemorySize

Die Speichergröße (in KB), die dem Konnektor zugewiesen werden soll.


377


https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector

https://docs.splunk.com/Documentation/Splunk/7.2.0/Data/UsetheHTTPEventCollector#About_Event_Collector_tokens



Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$SplunkQueueSize

Die maximale Anzahl von Elementen, die im Speicher gespeichert werden können, bevor die Elementeübertragen oder verworfen werden. Wenn dieses Limit erreicht wird, werden die ältesten Elementein der Warteschlange durch neuere Elemente ersetzt. Diese Begrenzung kommt typischerweise zumtragen, wenn keine Verbindung zum Internet besteht.

Anzeigename in der Konsole: Maximum items to retain (Maximale Anzahl der zu erhaltendenElemente)

Erforderlich: true

Typ: string

Gültiges Muster: ^[0-9]+$SplunkFlushIntervalSeconds

Das Intervall (in Sekunden) für die Veröffentlichung empfangener Daten an Splunk HEC. Der maximaleWert beträgt 900. Um den Konnektor so zu konfigurieren, dass er Elemente veröffentlicht, sobald sieempfangen werden (ohne Batching), geben Sie 0 an.

Anzeigename in der Konsole: Splunk publish interval (Splunk Veröffentlichungsintervall)

Erforderlich: true

Typ: string

Gültiges Muster: [0-9]|[1-9]\d|[1-9]\d\d|900SplunkTokenSecretArn

Das Secret im AWS Secrets Manager, das den Splunk-Token speichert. Dies muss ein Texttyp Secretsein.

Anzeigename in der Konsole: ARN of Splunk auth token secret (ARN des Splunk auth Token-Secrets)

Erforderlich: true

Typ: string

Gültiges Muster: arn:aws:secretsmanager:[a-z]{2}-[a-z]+-\d{1}:\d{12}?:secret:[a-zA-Z0-9-_]+-[a-zA-Z0-9-_]+

SplunkTokenSecretArn-ResourceId

Die geheime Ressource in der Greengrass-Gruppe, die auf das Splunk-Secret verweist.

Anzeigename in der Konsole: Splunk auth token resource (Splunk auth token-Ressource)

Erforderlich: true

Typ: string


378


SplunkCustomCALocation

Der Dateipfad der benutzerdefinierten Zertifizierungsstelle (CA) für Splunk (z. B. /etc/ssl/certs/splunk.crt).

Anzeigename in der Konsole: Splunk custom certificate authority location (Ort der Splunk CustomCertificate Authority)

Erforderlich: false

Typ: string

Gültiges Muster: ^$|/.*

Beispiel: Erstellen eines Connectors (CLI)Der folgende CLI-Befehl erstellt eine ConnectorDefinition mit einer Initialversion, die den Splunk-Integration-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MySplunkIntegrationConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/SplunkIntegration/versions/1", "Parameters": { "SplunkEndpoint": "https://myinstance.cloud.splunk.com:8088", "MemorySize": 200000, "SplunkQueueSize": 10000, "SplunkFlushIntervalSeconds": 5, "SplunkTokenSecretArn":"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash", "SplunkTokenSecretArn-ResourceId": "MySplunkResource" } } ]}'

Note



EingabedatenDieser Konnektor akzeptiert Protokoll- und Ereignisdaten zu einem MQTT-Thema und veröffentlicht dieempfangenen Daten an die Splunk-API. Eingabemeldungen müssen das JSON-Format aufweisen.

Themenfilter

splunk/logs/put


Die Ereignisdaten, die an die Splunk-API gesendet werden sollen. Ereignisse müssen denSpezifikationen der Services/Collector-API entsprechen.

379

https://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTinput#services.2Fcollector


Erforderlich: true

Typ: object. Nur die event-Eigenschaft ist erforderlich.id

Eine willkürliche ID für die Anforderung. Diese Eigenschaft wird verwendet, um eineEingangsanforderung auf einen Ausgangsstatus abzubilden.

Erforderlich: false

Typ: stringBeschränkungen

Alle Beschränkungen, die durch die Splunk-API auferlegt werden, gelten für diesen Konnektor. WeitereInformationen finden Sie unter Services/Collector.

Beispieleingabe

{ "request": { "event": "some event", "fields": { "severity": "INFO", "category": [ "value1", "value2" ] } }, "id": "request123"}

AusgabedatenDieser Konnektor veröffentlicht Ausgabedaten zu zwei Themen:

• Statusinformationen zum Thema splunk/logs/put/status.• Fehler im Thema splunk/logs/put/error.

Themenfilter: splunk/logs/put/status

Verwenden Sie dieses Thema, um den Status der Anforderungen anzuhören. Jedes Mal, wenn derKonnektor einen Stapel empfangener Daten an die Splunk-API sendet, veröffentlicht er eine Liste derIDs der erfolgreichen und der fehlgeschlagenen Anfragen.Beispielausgabe

{ "response": { "succeeded": [ "request123", ... ], "failed": [ "request789", ... ] }

380

https://docs.splunk.com/Documentation/Splunk/latest/RESTREF/RESTinput#services.2Fcollector


}

Themenfilter: splunk/logs/put/error

Verwenden Sie dieses Thema, um nach Fehlern vom Konnektor zu suchen. Die Eigenschafterror_message, die den Fehler oder das Timeout beschreibt, die beim Verarbeiten der Anforderungaufgetreten sind.Beispielausgabe

{ "response": { "error": "UnauthorizedException", "error_message": "invalid splunk token", "status": "fail" }}

Note

Wenn der Connector einen wiederholbaren Fehler (etwa einen Verbindungsfehler)erkennt, wird die Veröffentlichung im nächsten Stapel erneut versucht.


Note




iot_client = greengrasssdk.client('iot-data')send_topic = 'splunk/logs/put'

def create_request_with_all_fields(): return { "request": { "event": "Access log test message." }, "id" : "req_123" }



def function_handler(event, context):

381


AWS IoT Greengrass EntwicklerhandbuchTwilio-Benachrichtigungen

return



Twilio-BenachrichtigungenDer Twilio-Benachrichtigungen Konnektor (p. 297) führt automatisierte Telefonate oder sendetTextnachrichten über Twilio. Mit diesem Konnektor können Sie Benachrichtigungen als Reaktion aufEreignisse in der Greengrass-Gruppe senden. Bei Telefonaten kann der Konnektor eine Sprachnachrichtan den Empfänger weiterleiten.

Dieser Konnektor empfängt Twilio-Nachrichteninformationen zu einem MQTT-Thema und löst dann eineTwilio-Benachrichtigung aus.

Note

Ein Tutorial, das die Verwendung des Twilio-Benachrichtigungen-Konnektors zeigt, finden Sieunter the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390) oder the sectioncalled “Beginnen Sie mit Konnektoren (CLI)” (p. 401).


Version ARN

2 arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2

1 arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/1




Note


• Python, Version 2.7, installiert auf dem Kerngerät und der Umgebungsvariablen PATH hinzugefügt.

382




• Eine Twilio-Konto-SID, ein Authent-Token und eine Twilio-aktivierte Telefonnummer. Nachdem Sie einTwilio-Projekt erstellt haben, stehen diese Werte im Projekt-Dashboard zur Verfügung.

Note

Sie können ein Twilio-Testkonto verwenden. Wenn Sie ein Testkonto verwenden, müssenSie Telefonnummern von Nicht-Twilio-Empfängern einer Liste verifizierter Telefonnummernhinzufügen. Weitere Informationen finden Sie unter Wie Sie mit Ihrem kostenlosen Twilio-Testkonto arbeiten können.

• Ein Texttyp, der in AWS Secrets Manager geheim ist und das Twilio-Authent-Token speichert. WeitereInformationen finden Sie unter Erstellen eines grundlegenden Secrets im AWS Secrets Manager-Benutzerhandbuch.

Note

Um ein Secret in der Secrets Manager-Konsole zu erstellen, geben Sie Ihr Token auf derRegisterkarte Plaintext (Klartext) ein. Verwenden Sie dabei keine Anführungszeichen oderandere Formatierungen. Geben Sie in der API das Token als Wert für die EigenschaftSecretString ein.


Konnektor ParameterDieser Konnektor stellt die folgenden Parameter bereit.

TWILIO_ACCOUNT_SID

Die SID des Twilio-Kontos, mit der die Twilio-API aufgerufen wird.

Anzeigename in der Konsole: Twilio account SID (Twilio-Konto-SID)

Erforderlich: true

Typ: string

Gültiges Muster: .+TwilioAuthTokenSecretArn

Der ARN des Secrets Manager-Secrets, das das Twilio-Authent-Token speichert.

Note

Dies wird verwendet, um auf den Wert des lokalen Secrets auf dem Core zuzugreifen.

Anzeigename in der Konsole: ARN of Twilio auth token secret (ARN des Twilio auth Token-Secrets)

Erforderlich: true

Typ: string

Gültiges Muster: arn:aws:secretsmanager:[a-z0-9\-]+:[0-9]{12}:secret:([a-zA-Z0-9\\]+/)*[a-zA-Z0-9/_+=,.@\-]+-[a-zA-Z0-9]+

TwilioAuthTokenSecretArn-ResourceId

Die ID der geheimen Ressource in der Greengrass-Gruppe, die auf das Secret für das Twilio-Authent-Token verweist.

Anzeigename in der Konsole: Twilio auth token resource (Twilio auth token-Ressource)

383

https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account




Erforderlich: true

Typ: string

Gültiges Muster: .+DefaultFromPhoneNumber

Die standardmäßige Twilio-aktivierte Telefonnummer, die Twilio zum Senden von Nachrichtenverwendet. Twilio verwendet diese Nummer, um die Textnachricht oder den Anruf zu initiieren.• Wenn Sie keine Standard-Rufnummer konfigurieren, müssen Sie eine Rufnummer in der

Eigenschaft from_number im Textkörper der Eingabemeldung angeben.• Wenn Sie eine Standard-Rufnummer konfigurieren, können Sie die Standardeinstellung optional

überschreiben, indem Sie die Eigenschaft from_number im Textkörper der Eingabemeldungangeben.

Anzeigename in der Konsole: Default from phone number (Standard Telefonnummer)

Erforderlich: false

Typ: string

Gültiges Muster: ^$|\+[0-9]+


Der folgende CLI-Beispielbefehl erstellt eine ConnectorDefinition mit einer Initialversion, die denTwilio-Benachrichtigungen-Konnektor enthält.

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyTwilioNotificationsConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2", "Parameters": { "TWILIO_ACCOUNT_SID": "abcd12345xyz", "TwilioAuthTokenSecretArn": "arn:aws:secretsmanager:region:account-id:secret:greengrass-secret-hash", "TwilioAuthTokenSecretArn-ResourceId": "MyTwilioSecret", "DefaultFromPhoneNumber": "+19999999999" } } ]}'

Tutorials, die zeigen, wie man den Twilio-Benachrichtigungen-Konnektor zu einer Gruppe hinzufügt,finden Sie unter the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401) und the section called“Beginnen Sie mit Konnektoren (Konsole)” (p. 390).

EingabedatenDieser Konnektor akzeptiert Twilio-Nachrichteninformationen zu zwei MQTT-Themen. Eingabemeldungenmüssen das JSON-Format aufweisen.

• Textnachrichteninformationen zum Thema twilio/txt.• Telefonnachrichteninformationen zum Thema twilio/call.

384


Note

Die Nutzlast der Eingabemeldung kann eine Textnachricht (message) oder eine Sprachnachricht(voice_message_location) beinhalten, aber nicht beide.

Themenfilter: twilio/txtNachrichten-Eigenschaften

request

Informationen über die Twilio-Benachrichtigung.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:recipient

Der Nachrichtenempfänger. Nur ein Empfänger wird unterstützt.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:name

Der Name des Empfängers.

Erforderlich: true

Typ: string

Gültiges Muster: .*phone_number

Die Telefonnummer des Empfängers.

Erforderlich: true

Typ: string

Gültiges Muster: \+[1-9]+message

Der Textinhalt der Textnachricht. Zu diesem Thema werden nur Textnachrichtenunterstützt. Für Sprachnachrichten verwenden Sie twilio/call.

Erforderlich: true

Typ: string

Gültiges Muster: .+from_number

Die Telefonnummer des Absenders. Twilio verwendet diese Telefonnummer, umdie Nachricht zu senden. Diese Eigenschaft ist erforderlich, wenn der ParameterDefaultFromPhoneNumber nicht konfiguriert ist. Wenn DefaultFromPhoneNumberkonfiguriert ist, können Sie diese Eigenschaft verwenden, um den Standard zuüberschreiben.

Erforderlich: false

Typ: string

385


Gültiges Muster: \+[1-9]+retries

Die Anzahl der Wiederholungen Der Standardwert ist 0.

Erforderlich: false

Typ: integerid


Erforderlich: true

Typ: string


{ "request": { "recipient": { "name": "Darla", "phone_number": "+12345000000", "message": "Hello from the edge" }, "from_number": "+19999999999", "retries": 3 }, "id": "request123"}

Themenfilter: twilio/callNachrichten-Eigenschaften

request

Informationen über die Twilio-Benachrichtigung.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:recipient

Der Nachrichtenempfänger. Nur ein Empfänger wird unterstützt.

Erforderlich: true

Typ: object, das die folgenden Eigenschaften beinhaltet:name

Der Name des Empfängers.

Erforderlich: true

Typ: string

Gültiges Muster: .+phone_number

Die Telefonnummer des Empfängers.

386


Erforderlich: true

Typ: string

Gültiges Muster: \+[1-9]+voice_message_location

Die URL des Audioinhalts für die Sprachnachricht. Diese muss im TwiML-Formatvorliegen. Zu diesem Thema werden nur Sprachnachrichten unterstützt. FürTextnachrichten verwenden Sie twilio/txt.

Erforderlich: true

Typ: string

Gültiges Muster: .+from_number

Die Telefonnummer des Absenders. Twilio verwendet diese Telefonnummer, umdie Nachricht zu senden. Diese Eigenschaft ist erforderlich, wenn der ParameterDefaultFromPhoneNumber nicht konfiguriert ist. Wenn DefaultFromPhoneNumberkonfiguriert ist, können Sie diese Eigenschaft verwenden, um den Standard zuüberschreiben.

Erforderlich: false

Typ: string

Gültiges Muster: \+[1-9]+retries

Die Anzahl der Wiederholungen Der Standardwert ist 0.

Erforderlich: false

Typ: integerid


Erforderlich: true

Typ: string


{ "request": { "recipient": { "name": "Darla", "phone_number": "+12345000000", "voice_message_location": "https://some-public-TwiML" }, "from_number": "+19999999999", "retries": 3 }, "id": "request123"

387


}


Themenfilter

twilio/message/status


{ "response": { "status": "success", "payload": { "from_number": "+19999999999", "messages": { "message_status": "queued", "to_number": "+12345000000", "name": "Darla" } } }, "id": "request123"}


{ "response": { "status": "fail", "error_message": "Recipient name cannot be None", "error": "InvalidParameter", "payload": None } }, "id": "request123"}

Die Eigenschaft payload in der Ausgabe ist die Antwort der Twilio-API beim Senden der Nachricht.Wenn der Konnektor erkennt, dass die Eingabedaten ungültig sind (z. B. kein erforderlichesEingabefeld angegeben ist), gibt der Konnektor einen Fehler zurück und setzt den Wert auf None. ImFolgenden finden Sie Beispiele für Nutzlasten:

{ 'from_number':'+19999999999', 'messages': { 'name':'Darla', 'to_number':'+12345000000', 'message_status':'undelivered' }}

{ 'from_number':'+19999999999', 'messages': { 'name':'Darla', 'to_number':'+12345000000', 'message_status':'queued'

388


}}

VerwendungsbeispielDie folgende Lambda-Beispielfunktion sendet eine Eingabenachricht an den Connector. Dieses Beispiellöst eine Textnachricht aus.

Note




iot_client = greengrasssdk.client('iot-data')TXT_INPUT_TOPIC = 'twilio/txt'CALL_INPUT_TOPIC = 'twilio/call'

def publish_basic_message():

txt = { "request": { "recipient" : { "name": "Darla", "phone_number": "+12345000000", "message": 'Hello from the edge' }, "from_number" : "+19999999999" }, "id" : "request123" } print "Message To Publish: ", txt

client.publish(topic=TXT_INPUT_TOPIC, payload=json.dumps(txt))



LizenzenDer Twilio-Benachrichtigungen-Konnektor enthält die folgende Drittanbieter-Software/Lizenz:

• twilio-python/MIT



389


https://github.com/twilio/twilio-python


AWS IoT Greengrass EntwicklerhandbuchBeginnen Sie mit Konnektoren (Konsole)

Version Änderungen

2 Kleinere Fehlerbehebungen und Verbesserungen.

1 Erstversion.


Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Beginnen Sie mit Konnektoren (Konsole)” (p. 390)• the section called “Beginnen Sie mit Konnektoren (CLI)” (p. 401)• Twilio-API-Referenz

Erste Schritte mit Greengrass-Konnektoren(Konsole)


Dieses Tutorial zeigt, wie man die AWS Management Console verwendet, um mit Konnektoren zu arbeiten.

Verwenden Sie Konnektoren, um Ihren Entwicklungslebenszyklus zu beschleunigen. Konnektoren sindvorgefertigte, wiederverwendbare Module, die die Interaktion mit Services, Protokollen und Ressourcenerleichtern können. Sie können Ihnen helfen, die Geschäftslogik schneller auf Greengrass-Geräten zuimplementieren. Weitere Informationen finden Sie unter Integrieren von Services und Protokollen mitKonnektoren (p. 297).

In diesem Tutorial konfigurieren und stellen Sie den Twilio-Benachrichtigungen (p. 382)-Konnektor bereit.Der Konnektor empfängt Twilio-Nachrichteninformationen als Eingangsdaten und löst dann eine Twilio-SMS aus. Der Datenfluss ist in der folgenden Abbildung dargestellt.

Nach dem Konfigurieren des Konnektors erstellen Sie eine Lambda-Funktion und ein Abonnement.

• Die Funktion wertet simulierte Daten eines Temperatursensors aus. Es veröffentlicht bedingt die Twilio-Nachrichteninformationen zu einem MQTT-Thema. Dies ist das Thema, dass der Konnektor abonnierthat.

390

https://www.twilio.com/docs/api


• Das Abonnement ermöglicht es der Funktion, zum Thema zu veröffentlichen, und dem Konnektor, dieDaten vom Thema zu empfangen.

Der Twilio-Benachrichtigungen-Konnektor erfordert einen Twilio-Authentifizierungs-Token für die Interaktionmit der Twilio-API. Das Token ist ein Texttyp-Secret, das in AWS Secrets Manager erstellt und von einerGruppenressource referenziert wird. Dies ermöglicht es AWS IoT Greengrass, eine lokale Kopie desSecrets auf dem Greengrass Core zu erstellen, wo es verschlüsselt und dem Konnektor zur Verfügunggestellt wird. Weitere Informationen finden Sie unter Secrets für Core bereitstellen (p. 274).


1. Erstellen eines Secrets Manager-Secrets (p. 391)2. Hinzufügen einer geheimen Ressource zu einer Gruppe (p. 393)3. Hinzufügen eines Konnektors zur Gruppe (p. 394)4. Erstellen eines Bereitstellungspakets für eine Lambda-Funktion (p. 394)5. Erstellen Sie eine Lambda-Funktion (p. 396)6. Hinzufügen einer Funktion zur Gruppe (p. 397)7. Hinzufügen von Abonnements zur Gruppe (p. 398)8. Bereitstellen der Gruppe (p. 399)



• Eine Greengrass-Gruppe und ein Greengrass-Core (v1.7 or later). Weitere Informationen zumErstellen einer Greengrass-Gruppe und Greengrass Core finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69). Das Tutorial „Erste Schritte“ enthält auch die Schritte zur Installation der AWS IoTGreengrass-Core Software.

• AWS IoT Greengrass muss zur Unterstützung lokaler Secrets konfiguriert sein, wie unterVoraussetzungen für Secrets (p. 276) beschrieben.

Note



Note


Schritt 1: Erstellen eines Secrets Manager-SecretsIn diesem Schritt verwenden Sie die AWS Secrets Manager-Console, um ein Texttyp-Secret für IhrenTwilio-Authent-Token zu erstellen.

391




1. Melden Sie sich bei der AWS Secrets Manager-Konsole an.

Note

Weitere Informationen zu diesem Prozess finden Sie unter Schritt 1: Erstellen und SpeichernIhres Secrets in AWS Secrets Manager im AWS Secrets Manager-Benutzerhandbuch.

2. Wählen Sie Store a new secret (Ein neues Secret speichern).3. Wählen Sie unter Select secret type (Secret-Typ auswählen) die Option Other type of secrets (Anderer

Secret-Typ) aus.4. Geben Sie auf der Registerkarte Plaintext (Klartext) unter Specify the key/value pairs to be stored for

this secret (Angeben der Schlüssel/Wertpaare, die für dieses Secret gespeichert werden sollen) IhrTwilio-Authent-Token ein. Entfernen Sie alle JSON-Formatierungen und geben Sie nur den Token-Wert ein.

5. Belassen Sie DefaultEncryptionKey für den Verschlüsselungscode ausgewählt und wählen Sie Next(Weiter).

Note

Wenn Sie den von AWS verwalteten Standardschlüssel verwenden, den Secrets Manager inIhrem Konto erstellt, wird Ihnen dies von AWS KMS nicht berechnet.

6. Geben Sie für Secret name (Secret-Name) greengrass-TwilioAuthToken ein und klicken Sie aufNext (Weiter).

Note


392

https://console.aws.amazon.com/secretsmanager/



AWS IoT Greengrass EntwicklerhandbuchHinzufügen einer geheimen Ressource zu einer Gruppe

7. Dieses Tutorial erfordert keine Rotation. Wählen Sie also Disable automatic rotation (AutomatischeRotation deaktivieren) und danach Next (Weiter) aus.

8. Prüfen Sie auf der Seite Review (Prüfen) Ihre Einstellungen und wählen Sie Store (Speichern).

Als nächstes erstellen Sie in Ihrer Greengrass-Gruppe eine geheime Ressource, die auf das Secretverweist.

Schritt 2: Hinzufügen einer geheimen Ressource zueiner Greengrass-GruppeIn diesem Schritt fügen Sie eine geheime Ressource zur Greengrass-Gruppe hinzu. Diese Ressource isteine Referenz auf das Secret, das Sie im vorherigen Schritt angelegt haben.

1. Wählen Sie in der AWS IoT-Konsole Greengrass und dann Groups.2. Wählen Sie die Gruppe, zu der Sie die geheime Ressource hinzufügen möchten.3. Klicken Sie auf der Gruppenkonfigurationsseite auf Resources (Ressourcen) und wählen Sie dann

Secret. Auf dieser Registerkarte werden die geheimen Ressourcen angezeigt, die zur Gruppe gehören.Auf dieser Registerkarte können Sie geheime Ressourcen hinzufügen, bearbeiten und entfernen.

Note

Alternativ können Sie mit der Konsole ein Geheimnis und eine geheime Ressource erstellen,wenn Sie einen Connector oder eine Lambda-Funktion konfigurieren. Sie können dies überdie Seite Configure parameters (Parameter konfigurieren) des Connectors oder die SeiteRessourcen der Lambda-Funktion durchführen.

4. Wählen Sie Add a secret resource (Auswählen einer geheimen Ressource).5. Wählen Sie auf der Seite Add a secret resource to your group (Hinzufügen einer geheimen Ressource

zu Ihrer Gruppe) Select (Auswählen), und wählen Sie dann greengrass-TwilioAuthToken.6. Wählen Sie auf der Seite Select labels (Optional) (Bezeichnungen auswählen) aus und wählen Sie

dann Next (Weiter) aus. Das Staging-Label AWSCURRENT stellt die neueste Version des Secrets dar.Dieses Label ist immer in einer geheimen Ressource enthalten.

Note

Dieses Tutorial erfordert nur das Label AWSCURRENT. Sie können optional Bezeichnungenhinzufügen, die von Ihrer Lambda-Funktion oder vom Konnektor benötigt werden.

393

AWS IoT Greengrass EntwicklerhandbuchHinzufügen eines Konnektors zur Gruppe

7. Geben Sie auf der Seite Name your secret resource (Name Ihrer geheimen Ressource eingeben)MyTwilioAuthToken ein und klicken Sie dann auf Save (Speichern).

Schritt 3: Hinzufügen eines Konnektors zurGreengrass-GruppeIn diesem Schritt konfigurieren Sie Parameter für den Twilio-Benachrichtigungen-Konnektor (p. 382) undfügen ihn der Gruppe hinzu.

1. Wählen Sie auf der Gruppenkonfigurationsseite die Option Connectors (Konnektoren), und wählen Siedann Add a connector (Konnektor hinzufügen).

2. Wählen Sie auf der Seite Select a connector (Einen Konnektor auswählen) die Option TwilioNotifications (Twilio-Benachrichtigungen) aus und klicken Sie dann auf Next (Weiter).

3. Auf der Seite Configure parameters (Parameter konfigurieren):

• Wählen Sie für Twilio auth token resource (Twilio auth Token-Ressource) die OptionMyTwilioAuthToken. Dies ist die geheime Ressource, die Sie im vorherigen Schritt erstellt haben.

Note

Wenn Sie die Ressource auswählen, wird die Eigenschaft ARN of Twilio auth token secret(ARN von Twilio auth Token Secret) für Sie ausgefüllt.

• Geben Sie unter Default from phone number (Standard Telefonnummer) Ihre Twilio-aktivierteTelefonnummer ein.

• Geben Sie für Twilio account SID (Twilio-Konto-SID) Ihre Twilio-Konto-SID ein.4. Wählen Sie Add aus.



394




3. Speichern Sie die folgende Pythoncode-Funktion in einer lokalen Datei namens temp_monitor.py.

from __future__ import print_functionimport greengrasssdkimport jsonimport random


# publish to the Twilio Notifications connector through the twilio/txt topicdef function_handler(event, context): temp = event['temperature'] # check the temperature # if greater than 30C, send a notification if temp > 30: data = build_request(event) client.publish(topic='twilio/txt', payload=json.dumps(data)) print('published:' + str(data)) print('temperature:' + str(temp)) return

# build the Twilio request from the input datadef build_request(event): to_name = event['to_name'] to_number = event['to_number'] temp_report = 'temperature:' + str(event['temperature'])

return { "request": { "recipient": { "name": to_name, "phone_number": to_number, "message": temp_report } }, "id": "request_" + str(random.randint(1,101)) }

4. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen temp_monitor_python.zip.Verwenden Sie zum Erstellen der ZIP-Datei nur den Code und die entsprechenden Abhängigkeitenund nicht den dazugehörigen Ordner.

• temp_monitor.py. App-Logik.• greengrasssdk. Erforderliche Bibliothek für Python-Greengrass Lambda-Funktionen, die MQTT-

Nachrichten veröffentlichen.


Erstellen Sie nun eine Lambda-Funktion, die das Bereitstellungspaket verwendet.

395


Schritt 5: Erstellen einer Lambda-Funktion in der AWSLambda-KonsoleIn diesem Schritt erstellen Sie mithilfe der AWS Lambda-Konsole eine Lambda-Funktion und konfigurierendiese zur Verwendung des Bereitstellungspakets. Anschließend veröffentlichen Sie eine Funktionsversionund erstellen einen Alias.

1. Zunächst erstellen Sie die Lambda-Funktion.

a. Wählen Sie in der AWS Management Console Services und öffnen Sie die AWS Lambda-Konsole.b. Wählen Sie Create function und Author from scratch aus.c. Verwenden Sie im Abschnitt Basic information (Basisinformationen) folgende Werte:

• Geben Sie für Function name (Funktionsname) TempMonitor ein.• Wählen Sie für Runtime die Option Python 2.7 aus.• Behalten Sie für Permissions (Berechtigungen) die Standardeinstellung bei. Dadurch wird eine


d. Wählen Sie unten auf der Seite Create function aus.2. Registrieren Sie jetzt den Handler und laden Sie Ihr Bereitstellungspaket für die Lambda-Funktion

hoch.

a. Geben Sie auf der Registerkarte Configuration (Konfiguration) für die Funktion "TempMonitor"unter Function code (Funktionscode) folgende Werte an:


• Wählen Sie für Runtime die Option Python 2.7 aus.• Geben Sie unter Handler temp_monitor.function_handler ein.

b. Wählen Sie Upload aus.c. Wählen Sie das Bereitstellungspaket temp_monitor_python.zip aus.d. Wählen Sie Save aus.

Note


Tip

Sie sehen Ihren Code im Abschnitt Function code (Funktionscode), indem Sie im MenüCode entry type (Codeeingabetyp) die Option Edit code inline (Code inline bearbeiten)auswählen.

3. Veröffentlichen Sie jetzt die erste Version der Lambda-Funktion und erstellen Sie einen Alias für dieVersion.

Note

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nachVersion referenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, dadie Abonnementtabelle oder Gruppendefinition bei der Aktualisierung des Funktionscodes

396



AWS IoT Greengrass EntwicklerhandbuchHinzufügen einer Funktion zur Gruppe

nicht geändert werden müssen. Stattdessen lassen Sie den Alias einfach auf die neueFunktionsversion verweisen.

a. Wählen Sie im Menü Actions die Option Publish new version aus.b. Geben Sie unter Version description (Versionsbeschreibung) den Wert First version ein und

wählen Sie dann Publish (Veröffentlichen) aus.c. Wählen Sie auf der Konfigurationsseite für TempMonitor: 1 im Menü Actions (Aktionen) die Option

Create alias (Alias erstellen) aus.d. Geben Sie auf der Seite Create a new alias folgende Werte an:

• Geben Sie unter Name GG_TempMonitor ein.• Wählen Sie für Version die Option 1.

Note

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen.e. Wählen Sie Create aus.

Jetzt sind Sie bereit, die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzuzufügen.

Schritt 6: Hinzufügen einer Lambda-Funktion zurGreengrass-GruppeIn diesem Schritt fügen Sie die Lambda-Funktion der Gruppe hinzu und konfigurieren dann denLebenszyklus und die Umgebungsvariablen. Weitere Informationen finden Sie unter the section called“Steuern der Greengrass Lambda-Funktionsausführung” (p. 179).



397


3. Wählen Sie auf der Seite Use existing Lambda (Vorhandene Lambda verwenden) TempMonitor unddann Next.

4. Wählen Sie auf der Seite Select a Lambda version (Auswählen einer Lambda-Version) die OptionAlias:GG_TempMonitor und dann Finish.

Schritt 7: Hinzufügen von Abonnements zurGreengrass-GruppeIn diesem Schritt fügen Sie ein Abonnement hinzu, mit dem die Lambda-Funktion Eingabedaten anden Konnektor senden kann. Der Konnektor definiert die MQTT-Themen, die er abonniert, und diesesAbonnement verwendet eines dieser Themen. Es ist das gleiche Thema, zu dem die Beispielfunktionveröffentlicht.

In diesem Tutorial erstellen Sie auch Abonnements, die es der Funktion ermöglichen, simulierteTemperaturmessungen von AWS IoT zu empfangen, und dem AWS IoT gestatten, Statusinformationenvom Konnektor zu empfangen.



a. Wählen Sie für Eine Quelle auswählen die Option Lambdas und danach TempMonitor aus.b. Wählen Sie für Select a target (Ein Ziel auswählen) die Option Connectors (Konnektoren) und

dann Twilio-Benachrichtigungen aus.c. Wählen Sie Next.

3. Geben Sie auf der Seite Ihre Daten mit einem Thema filtern für Required topic syntax (ErforderlicheThemensyntax) twilio/txt ein. Wählen Sie dann Next aus.

4. Wählen Sie Finish aus.5. Wiederholen Sie die Schritte 1 - 4, um ein Abonnement zu erstellen, das es AWS IoT ermöglicht,

Nachrichten an die Funktion zu veröffentlichen.


b. Wählen Sie für Ein Ziel auswählen die Option Lambdas und danach TempMonitor aus.c. Geben Sie für Topic filter (Themenfilter) die Zeichenfolge temperature/input ein.

6. Wiederholen Sie die Schritte 1 - 4, um ein Abonnement zu erstellen, das es dem Konnektor ermöglicht,Nachrichten an AWS IoT zu veröffentlichen.

a. Wählen Sie für Select a source (Eine Quelle auswählen) die Option Connectors (Konnektoren)und dann Twilio-Benachrichtigungen aus.

398


b. Wählen Sie für Select a target (Ein Ziel auswählen) die Option Services und dann IoT Cloud aus.c. Für Themenfilter wird automatisch twilio/message/status eingegeben. Dies ist das

vordefinierte Thema, in das der Konnektor veröffentlicht.

Schritt 8: Bereitstellen der Greengrass-GruppeStellen Sie die Gruppe auf dem Core-Gerät bereit.





Note







399

AWS IoT Greengrass EntwicklerhandbuchTesten der Lösung

Note


Auf der Seite Deployments werden der Zeitstempel, die Versions-ID und der Status der Bereitstellungangegeben. Nach abgeschlossener Bereitstellung sollte der Status Successfully completed lauten.


Testen der Lösung1. Wählen Sie auf der AWS IoT-Konsole-Startseite die Option Test.

400


2. Verwenden Sie für Subscriptions (Abonnements) die folgenden Werte und wählen Sie dann Subscribeto topic. Die Statusinformationen zu diesem Thema veröffentlicht der Twilio-Benachrichtigungen-Konnektor.

Eigenschaft Value

Abonnementthema twilio/message/status



Eigenschaft Wert

Thema Temperatur/Input

Nachricht Ersetzen Sie recipient-name durch einenNamen und recipient-phone-number durchdie Telefonnummer des Empfängers der SMS.Beispiel: +12345000000

{ "to_name": "recipient-name", "to_number": "recipient-phone-number", "temperature": 31}

Wenn Sie ein Testkonto verwenden, müssen SieTelefonnummern von Nicht-Twilio-Empfängerneiner Liste verifizierter Telefonnummernhinzufügen. Weitere Informationen findenSie unter Überprüfen Ihrer persönlichenTelefonnummer.

Wenn erfolgreich, erhält der Empfänger die Textnachricht und die Konsole zeigt den Status successfür die Ausgangsdaten (p. 388).

Ändern Sie nun den temperature in der Eingabemeldung auf 29 und veröffentlichen Sie. Da diesweniger als 30 ist, löst die TempMonitor-Funktion keine Twilio-Nachricht aus.

Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Von AWS bereitgestellte Greengrass-Konnektoren” (p. 302)

Erste Schritte mit Greengrass-Konnektoren (CLI)Diese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

Dieses Tutorial zeigt, wie man die AWS CLI verwendet, um mit Konnektoren zu arbeiten.

401

https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account#verify-your-personal-phone-number


AWS IoT Greengrass EntwicklerhandbuchBeginnen Sie mit Konnektoren (CLI)

Verwenden Sie Konnektoren, um Ihren Entwicklungslebenszyklus zu beschleunigen. Konnektoren sindvorgefertigte, wiederverwendbare Module, die die Interaktion mit Services, Protokollen und Ressourcenerleichtern können. Sie können Ihnen helfen, die Geschäftslogik schneller auf Greengrass-Geräten zuimplementieren. Weitere Informationen finden Sie unter Integrieren von Services und Protokollen mitKonnektoren (p. 297).

In diesem Tutorial konfigurieren und stellen Sie den Twilio-Benachrichtigungen (p. 382)-Konnektor bereit.Der Konnektor empfängt Twilio-Nachrichteninformationen als Eingangsdaten und löst dann eine Twilio-SMS aus. Der Datenfluss ist in der folgenden Abbildung dargestellt.

Nach dem Konfigurieren des Konnektors erstellen Sie eine Lambda-Funktion und ein Abonnement.

• Die Funktion wertet simulierte Daten eines Temperatursensors aus. Es veröffentlicht bedingt die Twilio-Nachrichteninformationen zu einem MQTT-Thema. Dies ist das Thema, dass der Konnektor abonnierthat.

• Das Abonnement ermöglicht es der Funktion, zum Thema zu veröffentlichen, und dem Konnektor, dieDaten vom Thema zu empfangen.

Der Twilio-Benachrichtigungen-Konnektor erfordert einen Twilio-Authentifizierungs-Token für die Interaktionmit der Twilio-API. Das Token ist ein Texttyp-Secret, das in AWS Secrets Manager erstellt und von einerGruppenressource referenziert wird. Dies ermöglicht es AWS IoT Greengrass, eine lokale Kopie desSecrets auf dem Greengrass Core zu erstellen, wo es verschlüsselt und dem Konnektor zur Verfügunggestellt wird. Weitere Informationen finden Sie unter Secrets für Core bereitstellen (p. 274).


1. Erstellen eines Secrets Manager-Secrets (p. 404)2. Erstellen einer Ressourcendefinition und -version (p. 404)3. Erstellen einer Konnektordefinition und -version (p. 405)4. Erstellen eines Bereitstellungspakets für eine Lambda-Funktion (p. 406)5. Erstellen Sie eine Lambda-Funktion (p. 407)6. Erstellen einer Funktionsdefinition und -version (p. 408)7. Erstellen einer Abonnementdefinition und -version (p. 409)8. Erstellen einer Gruppenversion (p. 410)9. Erstellen einer Bereitstellung (p. 411)


Verwenden der AWS IoT Greengrass-API

402


Es ist hilfreich, die folgenden Muster zu verstehen, wenn Sie mit Greengrass-Gruppen und -Gruppenkomponenten arbeiten (z. B. die Konnektoren, Funktionen und Ressourcen in der Gruppe).

• An der Spitze der Hierarchie befindet sich ein Definition-Objekt, das ein Container für Version-Objekte ist. Eine Version wiederum ist ein Container für die Konnektoren, Funktionen oder andereKomponententypen.

• Wenn Sie im Greengrass Core bereitstellen, stellen Sie eine bestimmte Gruppenversion bereit. EineGruppenversion kann eine Version jeder Art von Komponente enthalten. Ein Core ist erforderlich, aberdie anderen werden bei Bedarf einbezogen.

• Versionen sind unveränderlich, daher müssen Sie neue Versionen anlegen, wenn Sie Änderungenvornehmen möchten.

Tip

Wenn Sie beim Ausführen eines AWS CLI-Befehls einen Fehler erhalten, fügen Sie denParameter --debug hinzu und führen Sie den Befehl erneut aus, um weitere Informationen überden Fehler zu erhalten.

Mit der AWS IoT Greengrass-API können Sie mehrere Definitionen für einen Komponententyp erstellen.Beispielsweise können Sie jedes Mal, wenn Sie ein FunctionDefinition-Objekt erstellen, einFunctionDefinitionVersion erstellen, oder Sie können neue Versionen zu einer bestehendenDefinition hinzufügen. Diese Flexibilität ermöglicht es Ihnen, Ihr Versionsmanagementsystem individuellanzupassen.


• Eine Greengrass-Gruppe und ein Greengrass-Core (v1.7 or later). Weitere Informationen zumErstellen einer Greengrass-Gruppe und Greengrass Core finden Sie unter Erste Schritte mit AWS IoTGreengrass (p. 69). Das Tutorial „Erste Schritte“ enthält auch die Schritte zur Installation der AWS IoTGreengrass-Core Software.

• AWS IoT Greengrass muss zur Unterstützung lokaler Secrets konfiguriert sein, wie unterVoraussetzungen für Secrets (p. 276) beschrieben.

Note



Note


• Die AWS CLI ist auf Ihrem Computer installiert und konfiguriert. Weitere Informationen finden Sie unterInstallieren der AWS Command Line Interface und Konfigurieren der AWS CLI im Benutzerhandbuch fürAWS Command Line Interface.

403






Die Beispiele in diesem Tutorial sind für Linux und andere Unix-basierte Systeme geschrieben. Wenn SieWindows verwenden, lesen Sie Festlegen von Parameterwerten für die AWS-Befehlszeilenschnittstelle,um mehr über die Unterschiede in der Syntax zu erfahren.

Wenn der Befehl eine JSON-Zeichenkette enthält, zeigt das Tutorial ein Beispiel, das das JSON auf einereinzigen Zeile hat. Auf einigen Systemen ist es möglicherweise einfacher, Befehle in diesem Format zubearbeiten und auszuführen.

Schritt 1: Erstellen eines Secrets Manager-SecretsIn diesem Schritt verwenden Sie die AWS Secrets Manager-API, um ein Secret für Ihren Twilio-Authent-Token zu erstellen.

1. Erstellen Sie zunächst das Secret.

• Ersetzen Sie twilio-auth-token durch Ihren Twilio-Authent-Token.

aws secretsmanager create-secret --name greengrass-TwilioAuthToken --secret-string twilio-auth-token

Note


2. Kopieren Sie den ARN des Secrets aus der Ausgabe. Damit erstellen Sie die geheime Ressource undkonfigurieren den Twilio-Benachrichtigungen-Konnektor.

Schritt 2: Erstellen einer Ressourcendefinition und -versionIn diesem Schritt verwenden Sie die AWS IoT Greengrass-API, um eine geheime Ressource für Ihr SecretsManager-Secret zu erstellen.

1. Erstellen Sie eine Ressourcendefinition, die eine Initialversion enthält.

• Ersetzen Sie secret-arn durch den ARN des Secrets, das Sie im vorherigen Schritt kopiert haben.

JSON Erweitert

aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{ "Resources": [ { "Id": "TwilioAuthToken", "Name": "MyTwilioAuthToken", "ResourceDataContainer": { "SecretsManagerSecretResourceData": { "ARN": "secret-arn" }

404

https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Konnektordefinition und -version

} } ]}'

JSON Single-line

aws greengrass create-resource-definition \--name MyGreengrassResources \--initial-version '{"Resources": [{"Id": "TwilioAuthToken", "Name": "MyTwilioAuthToken", "ResourceDataContainer": {"SecretsManagerSecretResourceData": {"ARN": "secret-arn"}}}]}'

2. Kopieren Sie den LatestVersionArn der Ressourcendefinition aus der Ausgabe. Mit diesemWert fügen Sie die Version der Ressourcendefinition der Gruppenversion hinzu, die Sie im Corebereitstellen.

Schritt 3: Erstellen einer Konnektordefinition und -versionIn diesem Schritt konfigurieren Sie die Parameter für den Twilio-Benachrichtigungen-Konnektor.

1. Erstellen Sie eine Konnektordefinition mit einer Initialversion.

• Ersetzen Sie account-sid durch Ihre Twilio-Konto-SID.• Ersetzen Sie secret-arn mit dem ARN Ihres geheimen Schlüssels vom Secrets Manager. Der

Konnektor verwendet dies, um den Wert des lokalen Secrets zu erhalten.• Ersetzen Sie phone-number durch Ihre Twilio-aktivierte Telefonnummer. Twilio verwendet sie,

um die Textnachricht zu initiieren. Dies kann in der Nutzlast der Eingabenachricht überschriebenwerden. Verwenden Sie das folgende Format: +19999999999.

JSON Erweitert

aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyTwilioNotificationsConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2", "Parameters": { "TWILIO_ACCOUNT_SID": "account-sid", "TwilioAuthTokenSecretArn": "secret-arn", "TwilioAuthTokenSecretArn-ResourceId": "TwilioAuthToken", "DefaultFromPhoneNumber": "phone-number" } } ]}'

JSON Single-line

aws greengrass create-connector-definition \--name MyGreengrassConnectors \

405



--initial-version '{"Connectors": [{"Id": "MyTwilioNotificationsConnector", "ConnectorArn": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2", "Parameters": {"TWILIO_ACCOUNT_SID": "account-sid", "TwilioAuthTokenSecretArn": "secret-arn", "TwilioAuthTokenSecretArn-ResourceId": "TwilioAuthToken", "DefaultFromPhoneNumber": "phone-number"}}]}'

Note

TwilioAuthToken ist die ID, die Sie im vorherigen Schritt zum Erstellen der geheimenRessource verwendet haben.

2. Kopieren Sie den LatestVersionArn der Konnektordefinition aus der Ausgabe. Mit diesem Wertfügen Sie die Version der Konnektordefinition der Gruppenversion hinzu, die Sie im Core bereitstellen.




3. Speichern Sie die folgende Pythoncode-Funktion in einer lokalen Datei namens temp_monitor.py.

from __future__ import print_functionimport greengrasssdkimport jsonimport random


# publish to the Twilio Notifications connector through the twilio/txt topicdef function_handler(event, context): temp = event['temperature'] # check the temperature # if greater than 30C, send a notification if temp > 30: data = build_request(event) client.publish(topic='twilio/txt', payload=json.dumps(data)) print('published:' + str(data)) print('temperature:' + str(temp)) return

# build the Twilio request from the input datadef build_request(event): to_name = event['to_name'] to_number = event['to_number'] temp_report = 'temperature:' + str(event['temperature'])

return { "request": {

406


"recipient": { "name": to_name, "phone_number": to_number, "message": temp_report } }, "id": "request_" + str(random.randint(1,101)) }

4. Packen Sie die folgenden Elemente in einer ZIP-Datei mit dem Namen temp_monitor_python.zip.Verwenden Sie zum Erstellen der ZIP-Datei nur den Code und die entsprechenden Abhängigkeitenund nicht den dazugehörigen Ordner.

• temp_monitor.py. App-Logik.• greengrasssdk. Erforderliche Bibliothek für Python-Greengrass Lambda-Funktionen, die MQTT-

Nachrichten veröffentlichen.


Schritt 5: Erstellen von einer Lambda-FunktionErstellen Sie nun eine Lambda-Funktion, die das Bereitstellungspaket verwendet.

1. Erstellen Sie zunächst eine IAM-Rolle, damit Sie beim Anlegen der Funktion den ARN übergebenkönnen.

Note

AWS IoT Greengrass verwendet diese Rolle nicht, da Berechtigungen für Ihre GreengrassLambda-Funktionen in der Greengrass-Gruppenrolle angegeben sind. Für dieses Tutorialerstellen Sie eine leere Rolle oder Sie können alternativ eine vorhandene Ausführungsrolleverwenden.

JSON Erweitert

aws iam create-role --role-name Lambda_empty --assume-role-policy '{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ]}'

JSON Single-line

aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'

2. Kopieren Sie den Arn aus der Ausgabe.

407

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Funktionsdefinition und -version

3. Erstellen Sie mit der AWS Lambda-API die TempMonitor-Funktion. Der folgende Befehl geht davonaus, dass sich die Zip-Datei im aktuellen Verzeichnis befindet.

• Ersetzen Sie role-arn durch den kopierten Arn.

aws lambda create-function \--function-name TempMonitor \--zip-file fileb://temp_monitor_python.zip \--role role-arn \--handler temp_monitor.function_handler \--runtime python2.7

4. Veröffentlichen einer Version der Funktion.

aws lambda publish-version --function-name TempMonitor --description 'First version'

5. Erstellen Sie einen Alias für die veröffentlichte Version.

Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nachVersion referenzieren. Mit einem Alias lassen sich Code-Updates einfacher verwalten, da dieAbonnementtabelle oder Gruppendefinition bei der Aktualisierung des Funktionscodes nicht geändertwerden müssen. Stattdessen lassen Sie den Alias einfach auf die neue Funktionsversion verweisen.

Note

AWS IoT Greengrass unterstützt keine Lambda-Aliase für $LATEST-Versionen.

aws lambda create-alias --function-name TempMonitor --name GG_TempMonitor --function-version 1

6. Kopieren Sie die AliasArn aus der Ausgabe. Diesen Wert verwenden Sie bei der Konfiguration derFunktion für AWS IoT Greengrass und beim Anlegen eines Abonnements.

Jetzt sind Sie bereit, die Funktion für AWS IoT Greengrass zu konfigurieren.

Schritt 6: Erstellen einer Funktionsdefinition und -versionUm eine Lambda-Funktion auf einem AWS IoT Greengrass-Core zu verwenden, erstellen Sie eineFunktionsdefinitionsversion, die die Lambda-Funktion über einen Alias referenziert und die Konfigurationauf Gruppenebene definiert. Weitere Informationen finden Sie unter the section called “Steuern derGreengrass Lambda-Funktionsausführung” (p. 179).

1. Erstellen Sie eine Funktionsdefinition, die eine Initialversion enthält.

• Ersetzen Sie alias-arn durch den AliasArn, den Sie beim Erstellen des Alias kopiert haben.

JSON Erweitert

aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{ "Functions": [ { "Id": "TempMonitorFunction",

408

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Abonnementdefinition und -version

"FunctionArn": "alias-arn", "FunctionConfiguration": { "Executable": "temp_monitor.function_handler", "MemorySize": 16000, "Timeout": 5 } } ]}'

JSON Single-line

aws greengrass create-function-definition \--name MyGreengrassFunctions \--initial-version '{"Functions": [{"Id": "TempMonitorFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "temp_monitor.function_handler", "MemorySize": 16000,"Timeout": 5}}]}'

2. Kopieren Sie die LatestVersionArn aus der Ausgabe. Mit diesem Wert fügen Sie die Version derFunktionsdefinition der Gruppenversion hinzu, die Sie im Core bereitstellen.

3. Kopieren Sie die Id aus der Ausgabe. Diesen Wert verwenden Sie später, wenn Sie die Funktionaktualisieren.

Schritt 7: Erstellen einer Abonnementdefinition und -versionIn diesem Schritt fügen Sie ein Abonnement hinzu, mit dem die Lambda-Funktion Eingabedaten anden Konnektor senden kann. Der Konnektor definiert die MQTT-Themen, die er abonniert, und diesesAbonnement verwendet eines dieser Themen. Es ist das gleiche Thema, zu dem die Beispielfunktionveröffentlicht.

In diesem Tutorial erstellen Sie auch Abonnements, die es der Funktion ermöglichen, simulierteTemperaturmessungen von AWS IoT zu empfangen, und dem AWS IoT gestatten, Statusinformationenvom Konnektor zu empfangen.

1. Erstellen Sie eine Abonnementdefinition, die eine Initialversion enthält, die die Abonnements umfasst.

• Ersetzen Sie alias-arn durch den AliasArn, den Sie beim Erstellen des Alias für die Funktionkopiert haben. Verwenden Sie diesen ARN für beide Abonnements, die ihn verwenden.

JSON Erweitert

aws greengrass create-subscription-definition --initial-version '{ "Subscriptions": [ { "Id": "TriggerNotification", "Source": "alias-arn", "Subject": "twilio/txt", "Target": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2" }, { "Id": "TemperatureInput", "Source": "cloud", "Subject": "temperature/input",

409

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Gruppenversion

"Target": "alias-arn" }, { "Id": "OutputStatus", "Source": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2", "Subject": "twilio/message/status", "Target": "cloud" } ]}'

JSON Single-line

aws greengrass create-subscription-definition \--initial-version '{"Subscriptions": [{"Id": "TriggerNotification", "Source": "alias-arn", "Subject": "twilio/txt", "Target": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2"},{"Id": "TemperatureInput", "Source": "cloud", "Subject": "temperature/input", "Target": "alias-arn"},{"Id": "OutputStatus", "Source": "arn:aws:greengrass:Region::/connectors/TwilioNotifications/versions/2", "Subject": "twilio/message/status", "Target": "cloud"}]}'

2. Kopieren Sie die LatestVersionArn aus der Ausgabe. Mit diesem Wert fügen Sie die Version derAbonnementdefinition der Gruppenversion hinzu, die Sie im Core bereitstellen.

Schritt 8: Erstellen einer GruppenversionJetzt können Sie eine Gruppenversion erstellen, die alle Elemente enthält, die Sie bereitstellen möchten.Dazu legen Sie eine Gruppenversion an, die auf die Zielversion jedes Komponententyps verweist.

Zuerst erhalten Sie die Gruppen-ID und den ARN der Core-Definitionsversion. Diese Werte sinderforderlich, um die Gruppenversion zu erstellen.

1. Abrufen der ID der Gruppe:

a. Listen Sie Ihre Gruppen auf.


b. Kopieren Sie die Id der Zielgruppe aus der Ausgabe. Sie verwenden sie, um die Core-Definitionsversion zu erhalten, und wenn Sie die Gruppe bereitstellen.

c. Kopieren Sie die LatestVersion der Gruppenversion aus der Ausgabe. Damit erhalten Sie dieCore-Definitionsversion.

2. Abrufen des ARN der Core-Definitionsversion:

a. Abrufen der Gruppenversion. Für diesen Schritt gehen wir davon aus, dass die neuesteGruppenversion eine Core-Definitionsversion enthält.

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie group-version-id durch die kopierte LatestVersion für die Gruppe.

aws greengrass get-group-version \--group-id group-id \--group-version-id group-version-id

b. Kopieren Sie die CoreDefinitionVersionArn aus der Ausgabe.

410

AWS IoT Greengrass EntwicklerhandbuchErstellen einer Bereitstellung

3. Erstellen einer Gruppenversion

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie core-definition-version-arn durch den CoreDefinitionVersionArn, den

Sie für die Core-Definitionsversion kopiert haben.• Ersetzen Sie resource-definition-version-arn durch den LatestVersionArn, den Sie für

die Ressourcendefinitionsversion kopiert haben.• Ersetzen Sie connector-definition-version-arn durch den LatestVersionArn, den Sie

für die Konnektordefinition kopiert haben.• Ersetzen Sie function-definition-version-arn durch den LatestVersionArn, den Sie für

die Funktionsdefinition kopiert haben.• Ersetzen Sie subscription-definition-version-arn durch den LatestVersionArn, den

Sie für die Abonnementdefinition kopiert haben.

aws greengrass create-group-version \--group-id group-id \--core-definition-version-arn core-definition-version-arn \--resource-definition-version-arn resource-definition-version-arn \--connector-definition-version-arn connector-definition-version-arn \--function-definition-version-arn function-definition-version-arn \--subscription-definition-version-arn subscription-definition-version-arn

4. Kopieren Sie den Wert Version aus der Ausgabe. Dies ist die ID der Gruppenversion. Mit diesemWert können Sie die Gruppenversion bereitstellen.

Schritt 9: Erstellen einer BereitstellungStellen Sie die Gruppe auf dem Core-Gerät bereit.

1. Stellen Sie in einem Core-Gerät-Terminal sicher, dass der AWS IoT Greengrass-Daemon läuft.






2. Erstellen einer Bereitstellung.

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie group-version-id durch die Version, die Sie für die Gruppenversion kopiert

haben.

aws greengrass create-deployment \--deployment-type NewDeployment \--group-id group-id \--group-version-id group-version-id

411

AWS IoT Greengrass EntwicklerhandbuchTesten der Lösung

3. Kopieren Sie die DeploymentId aus der Ausgabe.4. Abrufen des Bereitstellungsstatus.

• Ersetzen Sie group-id durch die kopierte Id für die Gruppe.• Ersetzen Sie deployment-id durch die DeploymentId, die Sie für die Bereitstellung kopiert

haben.

aws greengrass get-deployment-status \--group-id group-id \--deployment-id deployment-id

Wenn der Status Success lautet, war die Bereitstellung erfolgreich. Hilfe zur Problembehebung findenSie unter Fehlersuche (p. 500).

Testen der Lösung1. Wählen Sie auf der AWS IoT-Konsole-Startseite die Option Test.

2. Verwenden Sie für Subscriptions (Abonnements) die folgenden Werte und wählen Sie dann Subscribeto topic. Die Statusinformationen zu diesem Thema veröffentlicht der Twilio-Benachrichtigungen-Konnektor.

Eigenschaft Value

Abonnementthema twilio/message/status

412


Eigenschaft Value



Eigenschaft Wert

Thema Temperatur/Input

Nachricht Ersetzen Sie recipient-name durch einenNamen und recipient-phone-number durchdie Telefonnummer des Empfängers der SMS.Beispiel: +12345000000

{ "to_name": "recipient-name", "to_number": "recipient-phone-number", "temperature": 31}

Wenn Sie ein Testkonto verwenden, müssen SieTelefonnummern von Nicht-Twilio-Empfängerneiner Liste verifizierter Telefonnummernhinzufügen. Weitere Informationen findenSie unter Überprüfen Ihrer persönlichenTelefonnummer.

Wenn erfolgreich, erhält der Empfänger die Textnachricht und die Konsole zeigt den Status successfür die Ausgangsdaten (p. 388).

Ändern Sie nun den temperature in der Eingabemeldung auf 29 und veröffentlichen Sie. Da diesweniger als 30 ist, löst die TempMonitor-Funktion keine Twilio-Nachricht aus.

Weitere Informationen finden Sie auch unter:• Integrieren von Services und Protokollen mit Konnektoren (p. 297)• the section called “Von AWS bereitgestellte Greengrass-Konnektoren” (p. 302)• AWS Secrets Manager-Befehle im AWS CLI Command Reference• IAM-Befehle im AWS CLI Command Reference• AWS Lambda-Befehle im AWS CLI Command Reference• AWS IoT Greengrass-Befehle im AWS CLI Command Reference

413



https://docs.aws.amazon.com/cli/latest/reference/secretsmanager

https://docs.aws.amazon.com/cli/latest/reference/iam

https://docs.aws.amazon.com/cli/latest/reference/lambda

https://docs.aws.amazon.com/cli/latest/reference/greengrass

AWS IoT Greengrass EntwicklerhandbuchAnforderung

RESTful-API für GreengrassDiscovery

Alle Geräte, die mit einer AWS IoT Greengrass-Core kommunizieren sollen, müssen Mitglied einerGreengrass-Gruppe sein. Jede Gruppe benötigt eine AWS IoT Greengrass-Core. Die Discovery-APIermöglicht Geräten den Abruf von Informationen, die zum Herstellen einer Verbindung mit einer AWSIoT Greengrass-Core erforderlich sind, die sich in derselben Greengrass-Gruppe wie das Gerät befindet.Wenn ein Gerät erstmals online geht, kann es eine Verbindung zum AWS IoT Greengrass-Cloud-Serviceherstellen und mithilfe der Discovery-API Folgendes abrufen:

• Die Gruppe, zu der es gehört• Die IP-Adresse und den Port für die AWS IoT Greengrass-Core in der Gruppe.• Das CA-Stammzertifikat der Gruppe, das zur Authentifizierung des AWS IoT Greengrass-Core-Geräts

verwendet werden kann

Senden Sie zur Nutzung dieser API HTTP-Anfragen an den Discovery API-Endpunkt. Beispiel:

https://greengrass-ats.iot.Region.amazonaws.com:port/greengrass/discover/thing/thing-name

Eine Liste aller unterstützten AWS-Regionen und -Endpunkte für die AWS IoT Greengrass-Discovery-APIfinden Sie unter AWS-Regionen und -Endpunkte in den allgemeinen AWS-Referenzen. Dies ist nur eineDatenebenen-API. Die Endpunkte für die Gruppenverwaltung und AWS IoT-Operationen unterscheidensich von den Discovery API-Endpunkten.

AnforderungDie Anfrage enthält die Standard-HTTP-Header und wird an den Greengrass Discovery-Endpunktgesendet, wie in den folgenden Beispielen gezeigt.

Die Portnummer hängt davon ab, ob der Core für das Senden von HTTPS-Datenverkehr überPort 8443 oder Port 443 konfiguriert ist. Weitere Informationen finden Sie unter the section called“Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy” (p. 49).

Port 8443

HTTP GET https://greengrass-ats.iot.Region.amazonaws.com:8443/greengrass/discover/thing/thing-name

Port 443

HTTP GET https://greengrass-ats.iot.Region.amazonaws.com:443/greengrass/discover/thing/thing-name

Clients, die eine Verbindung auf Port 443 einrichten, müssen die TLS-Erweiterung ApplicationLayer Protocol Negotiation (ALPN) implementieren und x-amzn-http-ca als ProtocolName inProtocolNameList übergeben. Weitere Informationen finden Sie unter Protokolle im AWS IoT-Entwicklerhandbuch.

414




https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html

AWS IoT Greengrass EntwicklerhandbuchAntwort

Note

Diese Beispiele verwenden den Amazon Trust Services (ATS)-Endpunkt, der mit ATS-Stammzertifizierungsstellenzertifikat verwendet wird (empfohlen). Endpunkte müssen demTyp des Stammzertifizierungsstellenzertifikats entsprechen. Weitere Informationen finden Sieunter the section called “Endpunkte müssen dem Zertifikattyp entsprechen” (p. 48).

AntwortBei erfolgreicher Anfrage enthält die Antwort die Standard-HTTP-Kopfzeilen sowie den folgenden Code undText:

HTTP 200BODY: response document

Weitere Informationen finden Sie unter Beispieldokumente für Discovery-Antwort (p. 415).

AutorisierungFür das Abrufen der Verbindungsinformationen ist eine Richtlinie erforderlich, die es dem Aufrufer erlaubt,die Aktion greengrass:Discover durchzuführen. Die einzige akzeptierte Form der Authentifizierungist die gegenseitige TLS-Authentifizierung mit einem Client-Zertifikat. Im Folgenden finden Sie eineBeispielrichtlinie, die einem Aufrufer das Durchführen dieser Aktion ermöglicht:

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "greengrass:Discover", "Resource": ["arn:aws:iot:us-west-2:123456789012:thing/MyThingName"] }]}

Beispieldokumente für Discovery-AntwortDas folgende Dokument zeigt die Antwort für ein Gerät, das Mitglied einer Gruppe mit einer AWS IoTGreengrass-Core, einem Endpunkt und einem Gruppen-CA ist:

{ "GGGroups": [ { "GGGroupId": "gg-group-01-id", "Cores": [ { "thingArn": "core-01-thing-arn", "Connectivity": [ { "id": "core-01-connection-id", "hostAddress": "core-01-address", "portNumber": core-01-port, "metadata": "core-01-description" }

415

AWS IoT Greengrass EntwicklerhandbuchBeispieldokumente für Discovery-Antwort

] } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] } ]}

Das folgende Dokument zeigt die Antwort für ein Gerät, das Mitglied zweier Gruppe mit einer AWS IoTGreengrass-Core, mehreren Endpunkten und mehreren Gruppen-CAs ist:

{ "GGGroups": [ { "GGGroupId": "gg-group-01-id", "Cores": [ { "thingArn": "core-01-thing-arn", "Connectivity": [ { "id": "core-01-connection-id", "hostAddress": "core-01-address", "portNumber": core-01-port, "metadata": "core-01-connection-1-description" }, { "id": "core-01-connection-id-2", "hostAddress": "core-01-address-2", "portNumber": core-01-port-2, "metadata": "core-01-connection-2-description" } ] } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] }, { "GGGroupId": "gg-group-02-id", "Cores": [ { "thingArn":"core-02-thing-arn", "Connectivity" : [ { "id": "core-02-connection-id", "hostAddress": "core-02-address", "portNumber": core-02-port, "metadata": "core-02-connection-1-description" } ], "CAs": [ "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----cert-contents-----END CERTIFICATE-----" ] } ] }}

416

AWS IoT Greengrass EntwicklerhandbuchBeispieldokumente für Discovery-Antwort

Note

Ein AWS IoT Greengrass-Gruppe muss genau eine AWS IoT Greengrass-Core definieren. JedeAntwort vom AWS IoT Greengrass-Cloud-Service mit einer Liste mit AWS IoT Greengrass-Coresenthält nur eine AWS IoT Greengrass-Core.

Wenn Sie cURL installiert haben, können Sie die Discovery-Anfrage testen. Beispiel:

$ curl --cert 1a23bc4d56.cert.pem --key 1a23bc4d56.private.key https://greengrass-ats.iot.us-west-2.amazonaws.com:8443/greengrass/discover/thing/MyDevice{"GGGroups":[{"GGGroupId":"1234a5b6-78cd-901e-2fgh-3i45j6k1789","Cores":[{"thingArn":"arn:aws:iot:us-west-2:123456789012:thing/MyFirstGroup_Core","Connectivity":[{"Id":"AUTOIP_192.168.1.4_1","HostAddress":"192.168.1.5","PortNumber":8883,"Metadata":""}]}],"CAs":["-----BEGIN CERTIFICATE-----\ncert-contents\n-----END CERTIFICATE-----\n"]}]}

417

AWS IoT Greengrass EntwicklerhandbuchÜbersicht über die Architektur

Verwenden von Greengrass OPC-UA für die Kommunikation mitindustriellen Geräten

Greengrass unterstützt OPC-UA, einen Standard für den Informationsaustausch für die industrielleKommunikation. Mit OPC-UA können Sie Mitteilungen von industriellen Geräten importieren undverarbeiten und diese Geräten in Ihrer Greengrass-Gruppe oder in der Cloud bereitstellen, abhängig vonden Regeln, die Sie definieren.

Die Greengrass-Implementierung von OPC-UA unterstützt die zertifikatbasierte Authentifizierung. Siebasiert auf einer Open-Source-Implementierung und kann vollständig angepasst werden. Sie könnenauch Ihre eigene OPC-UA-Implementierung verwenden und Ihre eigene Unterstützung für weiterebenutzerdefinierte, vorhandene und proprietäre Messaging-Protokolle implementieren.

In diesem Abschnitt werden die folgenden Schritte behandelt:

• Verbinden mit einem vorhandenen OPC-UA-Server• Überwachen eines vorhandenen OPC-UA-Knotens auf diesem Server• Rückruf bei Änderungen des Werts des überwachten Knotens

Übersicht über die ArchitekturGreengrass implementiert OPC-UA als eine Lambda-Funktion in NodeJS. Da auf Greengrass-Kernenausgeführte Lambda-Funktionen auf Netzwerkressourcen zugreifen können, können Sie Lambda-Funktionen erstellen, die Informationen von Ihren vorhandenen OPC-UA-Servern über TCP für andereFunktionen oder Services in Ihrer Greengrass-Gruppe als Proxys bereitstellen.

Sie können Greengrass für eine Langzeitverbindung mit Ihren OPC-UA-Servern konfigurieren und mithilfevon OPC-UA-Abonnements kann Ihre Lambda-Funktion OPCUA_Adapter Änderungen an vorab definierten

418

AWS IoT Greengrass EntwicklerhandbuchEinrichten eines OPC-UA-Testservers

Knoten überwachen. Änderungen an diesen Knoten lösen ein Veröffentlichungsereignis vom OPC-UA-Server aus. Dieses Ereignis wird von Ihrer Lambda-Funktion empfangen und erneut zu vorab definiertenThemennamen veröffentlicht.

Die Themastruktur ist wie folgt konstruiert:

Einrichten eines OPC-UA-TestserversVerwenden Sie die folgenden Befehle, um einen OPC-UA-Testserver einzurichten. Wenn Sie bereits einenOPC-UA-Server besitzen, den Sie verwenden möchten, können Sie diesen Schritt überspringen.

git clone git://github.com/node-opcua/node-opcua.gitcd node-opcuagit checkout v0.0.65npm installnode bin/simple_server

Der Server produziert die folgende Ausgabe:

[ec2-user@<your_instance_id> node-opcua]$ node bin/simple_server server PID : 28585

registering server to :opc.tcp://<your_instance_id>4840/UADiscoveryerr Cannot find module 'usage'skipping installation of cpu_usage and memory_usage nodes server on port : 26543 endpointUrl : opc.tcp://<your_instance_id>us-west-2.compute.internal:26543 serverInfo : applicationUri : urn:54f7890cca4c49a1:NodeOPCUA-Server productUri : NodeOPCUA-Server applicationName : locale=en text=NodeOPCUA applicationType : SERVER gatewayServerUri : null discoveryProfileUri : null discoveryUrls : productName : NODEOPCUA-SERVER buildInfo : productUri : NodeOPCUA-Server manufacturerName : Node-OPCUA : MIT Licence ( see http://node-opcua.github.io/) productName : NODEOPCUA-SERVER softwareVersion : 0.0.65 buildNumber : 1234 buildDate : Thu Aug 03 2017 00:13:50 GMT+0000 (UTC)

server now waiting for connections. CTRL+C to stop

419

AWS IoT Greengrass EntwicklerhandbuchStellen Sie sicher, dass Ihre Greengrass-Gruppe bereit ist.

Stellen Sie sicher, dass Ihre Greengrass-Gruppebereit ist.

• Erstellen Sie eine Greengrass-Gruppe. Weitere Informationen finden Sie unter Konfigurieren von AWSIoT Greengrass auf AWS IoT (p. 82).

• Richten Sie auf einer der unterstützten Plattformen (beispielsweise (p. 70) Raspberry-pi) Raspberry Coreein.

• Richten Sie (p. 12) Ihren Greengrass Core für die Ausführung von nodejs8.x-Lambda-Funktionen ein.

Verwenden Sie Greengrass OPC-UA fürInteraktionen mit Ihrem OPC-UA-Server.

1. Bereiten Sie Ihre Lambda-Funktion vor.

Rufen Sie den Code für eine OPC-UA Adapter-Lambda-Funktion von GitHub ab:

git clone https://github.com/aws-samples/aws-greengrass-samples.gitcd aws-greengrass-samples/greengrass-opcua-adapter-nodejsnpm install

Note

Diese Lambda-Funktion verwendet die Bibliothek node-opcua (v0.0.65). Diese Bibliothekversucht, einige Modelldateien zur Laufzeit erneut zu generieren. Dies funktioniert bei derAusführung als Lambda-Funktion auf Greengrass nicht, da Lambda-Funktionen mit einemschreibgeschützten Dateisystem starten. Daher funktioniert ein Code, der versucht, anderenCode zu generieren, nicht. Dies wird im nächsten Schritt behoben.

2. Ändern Sie die Datei unter node_modules/node-opcua/lib/misc/factories.js: Zeile 109 zu:

var generated_source_is_outdated = (!generated_source_exists);

Führen Sie diesen Befehl aus, um diese Änderungen durchzuführen:

sed -i '109s/.*/ var generated_source_is_outdated = (!generated_source_exists);/' node_modules/node-opcua/lib/misc/factories.js

3. Konfigurieren Sie den Server und überwachte Knoten.

Ändern Sie die configSet-Variable in der index.js-Datei der OPC-UA-Lambda-Funktion so, dasssie die Server-IP und den Port, zu dem Sie eine Verbindung herstellen möchten, sowie die Knoten-IDs,die Sie überwachen möchten, enthält. Standardmäßig besteht die folgende Beispielkonfiguration:

const configSet = { server: { name: 'server', url: 'opc.tcp://localhost:26543', }, subscriptions: [ { name: 'MyPumpSpeed',

420

AWS IoT Greengrass EntwicklerhandbuchVerwenden Sie Greengrass OPC-UA fürInteraktionen mit Ihrem OPC-UA-Server.

nodeId: 'ns=1;s=PumpSpeed', }, ], };

In diesem Fall stellen wir eine Verbindung zu einem OPC-UA-Server her, der auf demselben Host wieder Greengrass Core auf Port 26543 ausgeführt wird, und überwachen einen Knoten mit der OPC UA-ID 'ns=1;s=PumpSpeed'.

4. Konfigurieren Sie den Authentifizierungsmodus.

Die in diesem Beispiel verwendete OPC-UA-Bibliothek unterstützt drei Authentifizierungsmodi für IhrenOPC-UA-Server. Die sicherste Methode ist die Certificate Based Authentication, aber die Bibliothekermöglicht auch die Angabe von Benutzername/Passwort oder die Arbeit ohne Authentifizierung.

So stellen Sie die Certificate Based Authentication ein:

• Verpacken Sie Ihr Zertifikat und Ihren privaten Schlüssel mit Ihrer Lambda-Funktion, beispielsweiseunter einem Verzeichnis mit dem Namen certs/.

• Ändern Sie die clientOptions-Variable so, dass Sie die Optionen certificateFile, privateKeyFileund securityModes, securityPolicies enthält:

const clientOptions = { keepSessionAlive: true, certificateFile: /lambda/certs/<certificate_name>.pem.crt, privateKeyFile: /lambda/certs/<private_key_name>.pem.key, securityModes: MessageSecurityMode.SIGN, securityPolicies: SecurityPolicy.BASIC256, connectionStrategy: { maxRetry: 1000000, initialDelay: 2000, maxDelay: 10 * 1000, }, };

5. Laden Sie das NodeJS AWS IoT Greengrass-SDK aus dem AWS IoT GreengrassCore-SDK (p. 21)-Downloads herunter.

6. Laden Sie Ihre Lambda-Funktion hoch.

Erstellen Sie eine Greengrass-Lambda-Funktion. Weitere Informationen finden Sie unter Konfigurierender Lambda-Funktion für AWS IoT Greengrass (p. 94). Sie können folgendermaßen ein Lambda-Funktionscodearchiv erstellen:

# Install Greengrass SDK in the node_modules directory. If you used the curl command to download the SDK, replace the tar.gz filename # with the name you used.tar -zxvf aws-greengrass-core-sdk-js-*.tar.gz -C /tmp/unzip /tmp/aws_greengrass_core_sdk_js/sdk/aws-greengrass-core-sdk-js.zip -d node_modules

# Archive the whole directory as a zip filezip -r opcuaLambda.zip * -x \*.git\*

# Create an AWS Lambda with the created zipaws lambda create-function --function-name function-name --runtime 'nodejs8.10' --role your_role --handler 'index.handler' --zip-file opcuaLambda.zip

Fügen Sie dieses Lambda Ihrer Greengrass-Gruppe hinzu. Weitere Informationen finden Sie unterKonfigurieren der Lambda-Funktion für AWS IoT Greengrass (p. 94).

421

https://github.com/node-opcua/node-opcua

AWS IoT Greengrass EntwicklerhandbuchStellen Sie sicher, dass Ihre Lambda-Funktion OPC-UA-Veröffentlichungen erhält und sie auf Greengrass postet.

7. Konfigurieren und Bereitstellen der Lambda-Funktion für Ihre Greengrass-Gruppe

Nachdem Sie Ihre AWS Lambda-Funktion erstellt haben, fügen Sie sie Ihrer Greengrass-Gruppehinzu. Befolgen Sie die Anweisungen in demselben Abschnitt wie oben.

• Stellen Sie sicher, dass die Lambda-Funktion als „Long-Running“ spezifiziert ist.• Geben Sie Ihr eine Speichergröße von mindestens 64 MB.

Sie können nun eine Bereitstellung mit Ihrer neuesten Konfiguration erstellen. Weitere Informationenfinden Sie unter Bereitstellen von Cloud-Konfigurationen für ein AWS IoT Greengrass Core-Gerät (p. 100).

Stellen Sie sicher, dass Ihre Lambda-FunktionOPC-UA-Veröffentlichungen erhält und sie aufGreengrass postet.

Wie im Abschnitt Architektur (p. 418) beschrieben, sollte Ihre Lambda-Funktion beginnen, Meldungenvon Ihrem OPC-UA-Server zu erhalten. Wenn Sie Ihre eigenen benutzerdefinierten OPC-UA Serververwenden, stellen Sie sicher, dass Sie eine Änderung in der angegebenen OPC-UA-Knoten-ID auslösen,damit Sie die Änderung sehen können, die Ihre Lambda-Funktion erhalten hat. Wenn Sie die obenbeschriebenen Beispielserver verwenden, ist der PumpSpeed-Knoten so konfiguriert, dass eine Reiheaufeinanderfolgender Aktualisierungen simuliert wird – Ihre Lambda-Funktion sollte daher pro Sekundemehrere Meldungen empfangen.

Sie können die von Ihrer Lambda-Funktion empfangenen Meldungen auf zweierlei Weise sehen:

• Beobachten Sie die Protokolle der Lambda-Funktion.

Sie können die Protokolle aus Ihrer Lambda-Funktion anzeigen, indem Sie den folgenden Befehlausführen:

sudo cat ggc/var/log/user/us-west-2/your_account_id/your_function_name.log

Die Protokolle sehen etwa wie folgt aus:

[2017-11-14T16:33:09.05Z][INFO]-started subscription : 305964

[2017-11-14T16:33:09.05Z][INFO]-monitoring node id = ns=1;s=PumpSpeed

[2017-11-14T16:33:09.099Z][INFO]-monitoredItem initialized

[2017-11-15T23:49:34.752Z][INFO]-Publishing message on topic "/opcua/server/node/MyPumpSpeed" with Payload "{"id":"ns=1;s=PumpSpeed","value":{"dataType":"Double","arrayType":"Scalar","value":237.5250759433095}}"

• Konfigurieren Sie Greengrass so, dass Meldungen von Ihrer Lambda-Funktion an die IoT-Cloudweitergeleitet werden.

Befolgen Sie die Anweisungen in Überprüfen Sie, ob die Lambda-Funktion auf dem Gerät ausgeführtwird (p. 101) für den Empfang von Meldungen auf der AWS IoT-Konsole.

Hinweis:

422


• Stellen Sie sicher, dass ein Abonnement von Ihrer Lambda-Funktion zur IoT-Cloud besteht. Einzelheitenhierzu finden Sie in Konfigurieren der Lambda-Funktion für AWS IoT Greengrass (p. 94).

• Da die Nachrichten in die Cloud weitergeleitet werden, stellen Sie sicher, dass Sie entweder den obenkonfigurierten Beispielserver oder den Greengrass Core anhalten, damit Sie nicht eine große Menge vonMeldungen kostenpflichtig in der IoT-Cloud veröffentlichen!

Nächste SchritteMit Greengrass können Sie diese Architektur verwenden, um eine eigene Implementierung von OPC-UA zuerstellen und eine eigene Unterstützung für benutzerdefinierte, ältere und proprietäre Messaging-Protokollezu implementieren. Da auf Greengrass Cores ausgeführte Lambda-Funktionen auf Netzwerkressourcenzugreifen können, können Sie diese verwenden, um die Unterstützung für jedes Protokoll auf TCP-IP zu implementieren. Weiterhin können Sie den Greengrass Local Resource Access nutzen, um dieUnterstützung für Protokolle zu implementieren, die auf Hardwareadapter oder -treiber zugreifen müssen.

423


AWS IoT Greengrass SicherheitAWS IoT Greengrass verwendet X.509-Zertifikate, verwaltete Abonnements, AWS IoT- und IAM-Richtliniensowie Rollen, um sicherzustellen, dass Ihre Greengrass-Anwendungen sicher sind.

AWS IoT Greengrass-Core-Geräte benötigen ein AWS IoT-Objekt, ein Gerätezertifikat und eine AWS IoT-Richtlinie, damit sie mit dem Greengrass-Cloud-Service kommunizieren können.

Auf diese Weise können AWS IoT Greengrass-Core-Geräte eine sichere Verbindung zu den AWSIoT-Cloud-Services herstellen. Zudem wird dem Greengrass-Cloud-Service so die Bereitstellung vonKonfigurationsinformationen, Lambda-Funktionen, Konnektoren und verwalteten Abonnements auf AWSIoT Greengrass-Core-Geräten ermöglicht.

Greengrass-Geräte (p. 8) benötigen ein AWS IoT-Objekt, ein Gerätezertifikat und eine AWS IoT-Richtlinie,um eine Verbindung zum Greengrass-Service herstellen zu können. Auf diese Weise können Greengrass-Geräte mithilfe des Greengrass Discovery-Services ein AWS IoT Greengrass-Core-Gerät suchen und eineVerbindung dazu herstellen. Greengrass-Geräte verwenden für die Verbindung mit dem AWS IoT-Geräte-Gateway und AWS IoT Greengrass-Core-Geräten dasselbe Gerätezertifikat.

Das folgende Diagramm zeigt die Komponenten des AWS IoT Greengrass-Sicherheitsmodells:

A – Rolle des Greengrass-Services

Eine vom Kunden erstellte IAM-Rolle, die AWS IoT Greengrass Zugriff auf Ihre AWS IoT-, Lambda-und anderen AWS-Ressourcen gewährt. Weitere Informationen finden Sie unter the section called“Greengrass-Servicerolle” (p. 432).

424

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der Greengrass-Sicherheit

B – Core-Gerätezertifikat

Ein X.509-Zertifikat zur Authentifizierung eines AWS IoT Greengrass-CoreC – Gerätezertifikat

Ein X.509-Zertifikat zur Authentifizierung eines AWS IoT Greengrass-Geräts.D – Gruppenrolle

Eine benutzerdefinierte IAM-Rolle, die von AWS IoT Greengrass angenommen wird, wenn AWS-Services von einer Lambda-Funktion oder einem Konnektor auf einem AWS IoT Greengrass-Coreaufgerufen werden.

Dies ist die Lambda-Ausführungsrolle für alle Greengrass Lambda-Funktionen und Konnektoren, dieauf dem Core laufen. Verwenden Sie diese Rolle, um Zugriffsberechtigungen anzugeben, die Ihrebenutzerdefinierten Lambda-Funktionen und Konnektoren für den Zugriff auf AWS-Services benötigen,wie beispielsweise DynamoDB.

Note

AWS IoT Greengrass verwendet für die Cloud-Version der Funktion nicht die Lambda-Ausführungsrolle, die in AWS Lambda angegeben ist.

E – Gruppen-CA

Ein CA-Stammzertifikat für AWS IoT Greengrass-Geräte zur Validierung des von einem AWS IoTGreengrass-Core-Gerät bei der gegenseitigen TLS-Authentifizierung (Transport Layer Security)übermittelten Zertifikats.

Konfigurieren der Greengrass-SicherheitSo konfigurieren Sie die Sicherheit Ihrer Greengrass-Anwendung:

1. Erstellen Sie ein AWS IoT-Objekt für Ihr AWS IoT Greengrass-Core-Gerät.2. Generieren Sie ein Schlüsselpaar und Gerätezertifikat für Ihr AWS IoT Greengrass-Core-Gerät.3. Erstellen Sie eine AWS IoT-Richtlinie, und fügen Sie sie an das Gerätezertifikat an. Das Zertifikat und

die Richtlinie gewähren dem AWS IoT Greengrass-Core-Gerät Zugriff auf das AWS IoT und AWS IoTGreengrass-Services. Weitere Informationen finden Sie unter the section called “Minimale AWS IoT-Richtlinie für das AWS IoT Greengrass Core-Gerät” (p. 426).

4. Erstellen Sie eine Greengrass-Servicerolle. Diese IAM-Rolle berechtigt AWS IoT Greengrass zumZugriff auf Ressourcen von anderen AWS-Services in Ihrem Namen. Auf diese Weise kann AWS IoTGreengrass grundlegende Aufgaben durchführen, wie z. B. Abrufen von AWS Lambda-Funktionen undVerwalten von AWS IoT-Schatten. Sie können die gleiche Servicerolle über AWS-Regionen hinwegverwenden, aber sie muss jeder AWS-Region, in der Sie AWS IoT Greengrass verwenden, zugeordnetsein. Weitere Informationen finden Sie unter the section called “Greengrass-Servicerolle” (p. 432).

5. (Optional) Erstellen Sie eine Greengrass-Gruppenrolle. Diese IAM-Rolle erteilt Lambda-Funktionenund Konnektoren, die auf einem AWS IoT Greengrass-Core ausgeführt werden, die Berechtigungzum Aufrufen von AWS-Services. Beispiel: Der Kinesis Firehose-Konnektor (p. 332) erfordert eineBerechtigung zum Schreiben von Datensätzen in einen Amazon Kinesis Data Firehose-Bereitstellungs-Stream. Sie erstellen eine separate Gruppenrolle für jede Greengrass-Gruppe.

6. Erstellen Sie ein AWS IoT-Objekt für jedes Gerät, das eine Verbindung zur AWS IoT Greengrass-Coreherstellt.

7. Erstellen Sie Gerätezertifikate, Schlüsselpaare und AWS IoT-Richtlinien für jedes Gerät, das eineVerbindung mit der AWS IoT Greengrass-Core herstellt.

425

AWS IoT Greengrass EntwicklerhandbuchMinimale AWS IoT-Richtlinie für das

AWS IoT Greengrass Core-Gerät

Note

Sie können auch bestehende AWS IoT-Objekte und -Zertifikate nutzen.

Minimale AWS IoT-Richtlinie für das AWS IoTGreengrass Core-GerätEine AWS IoT-Richtlinie definiert die zulässigen Aktionen für ein AWS IoT-Objekt (in diesem Fall dasGreengrass Core-Gerät). Die Richtlinie ist dem Gerätezertifikat zugewiesen und wird für den Zugriff aufdas AWS IoT und AWS IoT Greengrass-Services verwendet. AWS IoT-Richtlinien sind JSON-Dokumente,die den Konventionen der IAM-Richtlinien entsprechen. Weitere Informationen finden Sie unter AWS IoT-Richtlinien im AWS IoT-Entwicklerhandbuch.

Die folgende Beispielrichtlinie enthält den Mindestsatz von Aktionen, die erforderlich sind, um einegrundlegende Greengrass-Funktionalität für Ihr Core-Gerät zu unterstützen. Notieren Sie sich Folgendes:

• Die Richtlinie listet die MQTT-Themen und Themenfilter auf, für die das Core-Gerät Nachrichtenveröffentlichen, abonnieren und empfangen kann, einschließlich Themen für den Schattenstatus. Umden Austausch von Nachrichten zwischen AWS IoT, Lambda-Funktionen, Konnektoren und Geräten inder Greengrass-Gruppe zu unterstützen, geben Sie die Themen und Themenfilter an, die Sie zulassenmöchten. Weitere Informationen finden Sie unter Beispiele für die Veröffentlichen/Abonnieren-Richtlinieim AWS IoT-Entwicklerhandbuch.

• Die Richtlinie enthält einen Abschnitt, der AWS IoT zum Abrufen, Aktualisieren und Löschender Core-Geräteschatten berechtigt. Um die Schattensynchronisierung für andere Geräte inder Greengrass-Gruppe zuzulassen, geben Sie die Ziel-ARNs in der Resource-Liste an (z. B.arn:aws:iot:Region:account-id:thing/device-name).

• Für die greengrass:UpdateCoreDeploymentStatus-Berechtigung ist das letzte Segment imResource-ARN der URL-codierte ARN des Core-Geräts.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Connect" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe", "iot:Receive" ], "Resource": [ "arn:aws:iot:Region:account-id:topicfilter/$aws/things/core-name-*", "arn:aws:iot:Region:account-id:topic/$aws/things/core-name-*" ] }, { "Effect": "Allow", "Action": [ "iot:GetThingShadow", "iot:UpdateThingShadow",

426

https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html

https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html

https://docs.aws.amazon.com/iot/latest/developerguide/pub-sub-policy.html

AWS IoT Greengrass EntwicklerhandbuchMinimale AWS IoT-Richtlinie für das

AWS IoT Greengrass Core-Gerät

"iot:DeleteThingShadow" ], "Resource": [ "arn:aws:iot:Region:account-id:thing/core-name-*" ] }, { "Effect": "Allow", "Action": [ "greengrass:AssumeRoleForGroup", "greengrass:CreateCertificate" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "greengrass:GetDeployment" ], "Resource": [ "arn:aws:greengrass:Region:account-id:/greengrass/groups/group-id/deployments/*" ] }, { "Effect": "Allow", "Action": [ "greengrass:GetDeploymentArtifacts" ], "Resource": [ "arn:aws:greengrass:Region:account-id:/greengrass/groups/group-id/deployments/*" ] }, { "Effect": "Allow", "Action": [ "greengrass:UpdateCoreDeploymentStatus" ], "Resource": [ "arn:aws:greengrass:Region:account-id:/greengrass/groups/group-id/deployments/*/cores/arn%3Aaws%3Aiot%3ARegion%3Aaccount-id%3Athing%2Fcore-name" ] }, { "Effect": "Allow", "Action": [ "greengrass:GetConnectivityInfo", "greengrass:UpdateConnectivityInfo" ], "Resource": [ "arn:aws:iot:Region:account-id:thing/core-name" ] } ]}

Sie können die dem Core-Zertifikat zugewiesene Richtlinie für die AWS IoT-Konsole ganz einfach anzeigenund bearbeiten.

1. Wählen Sie im Navigationsbereich Manage (Verwalten) und danach Things (Objekte) und Ihren Coreaus.

2. Klicken Sie auf der Core-Konfigurationsseite auf Security (Sicherheit).3. Wählen Sie auf der Seite Certificates (Zertifikate) Ihr Zertifikat aus.

427

AWS IoT Greengrass EntwicklerhandbuchSicherheitsprinzipale

4. Klicken Sie auf der Konfigurationsseite des Zertifikats auf Policies (Richtlinien) und wählen Sie danndie Richtlinie aus.

Wenn Sie die Richtlinie bearbeiten möchten, wählen Sie Edit policy document (Richtliniendokumentbearbeiten).

AWS IoT Greengrass-Core-SicherheitsprinzipaleDas AWS IoT Greengrass-Core verwendet die folgenden Sicherheitsprinzipale: AWS IoT-Client, lokalenMQTT-Server und lokalen Secrets Manager. Die Konfiguration für diese Prinzipale ist im crypto-Objektin der Konfigurationsdatei config.json gespeichert. Weitere Informationen finden Sie unter the sectioncalled “AWS IoT Greengrass-Core-Konfigurationsdatei” (p. 23).

Diese Konfiguration beinhaltet den Pfad zum privaten Schlüssel, der von der Prinzipal-Komponentefür die Authentifizierung und Verschlüsselung verwendet wird. AWS IoT Greengrass unterstützt zweiModi der Speicherung privater Schlüssel: hardwarebasiert oder dateisystembasiert (Standard). WeitereInformationen zum Speichern von Schlüsseln auf Hardware-Sicherheitsmodulen finden Sie unter thesection called “Hardware-Sicherheit” (p. 435).

AWS IoT-Client

Der AWS IoT-Client verwaltet die Kommunikation über das Internet zwischen dem GreengrassCore und AWS IoT. AWS IoT Greengrass verwendet X.509-Zertifikate mit öffentlichen und privatenSchlüsseln für gegenseitige Authentifizierung beim Einrichten von TLS-Verbindungen für dieseKommunikation. Weitere Informationen finden Sie unter X.509-Zertifikate und AWS IoT im AWS IoT-Entwicklerhandbuch.

Der IoT-Client unterstützt RSA- und EC-Zertifikate und -Schlüssel. Der Pfad zu Zertifikaten undprivatem Schlüssel sind für den IoTCertificate-Prinzipal in config.json angegeben.

MQTT-Server

Der lokale MQTT-Server verwaltet die Kommunikation über das lokale Netzwerk zwischen demGreengrass-Core und anderen Greengrass-Geräten in der Gruppe. AWS IoT Greengrass verwendetX.509-Zertifikate mit öffentlichen und privaten Schlüsseln zur gegenseitigen Authentifizierung beimAufbau von TLS-Verbindungen für diese Kommunikation.

Standardmäßig generiert AWS IoT Greengrass einen privaten RSA-Schlüssel für Sie. Um den Core sozu konfigurieren, dass er einen anderen privaten Schlüssel verwendet, müssen Sie den Schlüsselpfadfür den MQTTServerCertificate-Prinzipal in config.json angeben.

Support für privaten Schlüssel

RSA-Schlüssel EC-Schlüssel

Schlüsseltyp Unterstützt Unterstützt

Hauptparameter Mindestlänge von 2048 Bit NIST P-256- oder NIST P-384-Kurve

Datenträgerformat PKCS#1, PKCS#8 SECG1, PKCS#8

Minimale GGC-Version • Verwenden Sie Standard-RSA-Schlüssel: 1.0

• Geben Sie einen RSA-Schlüssel an: 1.7

• Geben Sie einen EC-Schlüssel an: 1.9

428

https://docs.aws.amazon.com/iot/latest/developerguide/managing-device-certs.html

AWS IoT Greengrass EntwicklerhandbuchSicherheitsprinzipale

Die Konfiguration des privaten Schlüssels bestimmt die zugehörigen Prozesse. Eine Liste derVerschlüsselungs-Suites, die der Greengrass-Core als Server unterstützt, finden Sie unter the sectioncalled “AWS IoT Greengrass Cipher Suites” (p. 431).Wenn kein privater Schlüssel angegeben ist (Standard)

• AWS IoT Greengrass rotiert den Schlüssel basierend auf Ihren Einstellungen zur Rotation.• Der Core generiert einen RSA-Schlüssel, der verwendet wird, um das Zertifikat zu generieren.• Das MQTT-Serverzertifikat verfügt über einen öffentlichen RSA-Schlüssel und eine SHA-256-

RSA-Signatur.Wenn eine privater RSA-Schlüssel angegeben ist (erfordert GGC v1.7 or later)

• Sie sind für das Rotieren des Schlüssels verantwortlich.• Der Core verwendet den angegebenen Schlüssel, um das Zertifikat zu generieren.• Der RSA-Schlüssel muss eine Mindestlänge von 2048 Bits haben.• Das MQTT-Serverzertifikat verfügt über einen öffentlichen RSA-Schlüssel und eine SHA-256-

RSA-Signatur.Wenn ein privater EC-Schlüssel angegeben ist (erfordert GGC v1.9)

• Sie sind für das Rotieren des Schlüssels verantwortlich.• Der Core verwendet den angegebenen Schlüssel, um das Zertifikat zu generieren.• Der private EC-Schlüssel muss eine NIST P-256- oder NIST P-384-Kurve verwenden.• Das MQTT-Serverzertifikat verfügt über einen öffentlichen EC-Schlüssel und eine SHA-256-

RSA-Signatur.

Das vom Core präsentierte MQTT-Serverzertifikat verfügt über eine SHA-256-RSA-Signatur,unabhängig vom Schlüsseltyp. Aus diesem Grund müssen Clients die Validierung von SHA-256-RSA-Zertifikaten unterstützen, um eine sichere Verbindung mit dem Core herzustellen.

Secrets Manager

Der lokale Secrets Manager verwaltet auf sichere Weise lokale Kopien der Secrets, die Sie in AWSSecrets Manager erstellen. Er verwendet einen privaten Schlüssel, um den Datenschlüssel zu sichern,der zum Verschlüsseln der Secrets verwendet wird. Weitere Informationen finden Sie unter Secrets fürCore bereitstellen (p. 274).

Standardmäßig wird der private Schlüssel des IoT-Clients verwendet, aber Sie können einen anderenprivaten Schlüssel für den SecretsManager-Prinzipal in config.json angeben. Nur der RSA-Schlüsseltyp wird unterstützt. Weitere Informationen finden Sie unter the section called “Angeben desprivaten Schlüssels für die Verschlüsselung von Secrets” (p. 276).

Note


Support für privaten Schlüssel

RSA-Schlüssel EC-Schlüssel

Schlüsseltyp Unterstützt Nicht unterstützt

Hauptparameter Mindestlänge von 2048 Bit Nicht zutreffend

Datenträgerformat PKCS#1, PKCS#8 Nicht zutreffend

Minimale GGC-Version 1.7 Nicht zutreffend

429


AWS IoT Greengrass EntwicklerhandbuchGeräteverbindung – Workflow

Geräteverbindung – WorkflowIn diesem Abschnitt wird beschrieben, wie die Geräte eine Verbindung mit dem AWS IoT Greengrass-Cloud-Service und den AWS IoT Greengrass-Core-Geräten herstellen.

• Ein AWS IoT Greengrass-Core-Gerät nutzt sein Gerätezertifikat, seinen privaten Schlüssel und das CA-Stammzertifikat für AWS IoT, um eine Verbindung mit dem Greengrass-Cloud-Service herzustellen.

• Das AWS IoT Greengrass-Core-Gerät lädt die Informationen über Gruppenmitgliedschaften aus demGreengrass-Service herunter.

• Wenn auf dem AWS IoT Greengrass-Core-Gerät eine Bereitstellung stattfindet, übernimmt der DeviceCertificate Manager (DCM) die Zertifikatverwaltung für das AWS IoT Greengrass-Core-Gerät.

• Ein AWS IoT-Gerät stellt mithilfe seines Gerätezertifikats, privaten Schlüssels und des CA-Stammzertifikats für AWS IoT eine Verbindung zum Greengrass-Cloud-Service her. Wenn dieVerbindung hergestellt wurde, ermittelt das AWS IoT-Gerät mithilfe des Greengrass Discovery-Servicesdie IP-Adresse seines AWS IoT Greengrass-Core-Geräts. Das Gerät kann auch das CA-Stammzertifikatder Gruppe herunterladen, das zur Authentifizierung des Greengrass-Core-Geräts verwendet werdenkann.

• Ein AWS IoT-Gerät versucht, durch Übermitteln des Gerätezertifikats und der Client-ID eine Verbindungzum AWS IoT Greengrass-Core herzustellen. Wenn die Client-ID mit dem Objektnamen des Gerätsübereinstimmt und das Zertifikat gültig ist, wird eine Verbindung hergestellt. Falls nicht, wird dieVerbindungsanfrage beendet.

Greengrass-Messaging – WorkflowAWS IoT Greengrass verwendet eine Abonnementtabelle, um zu definieren, wie MQTT-Nachrichtenzwischen Geräten, Funktionen und Konnektoren in einer Greengrass-Gruppe und mit AWS IoT oderdem lokalen Shadow-Service ausgetauscht werden können. Jedes Abonnement spezifiziert eine Quelle,ein Ziel und ein MQTT-Thema (oder Betreff), über das Nachrichten gesendet oder empfangen werden.AWS IoT Greengrass erlaubt das Senden von Nachrichten von einer Quelle an ein Ziel nur, wenn einentsprechendes Abonnement definiert ist.

Ein Abonnement definiert den Nachrichtenflusses nur in eine Richtung, von der Quelle zum Ziel. Um denbidirektionalen Nachrichtenaustausch zu unterstützen, müssen Sie zwei Abonnements anlegen, eines fürjede Richtung.

Zertifikatrotation auf dem MQTT-Core-ServerGreengrass-Geräte verwenden das MQTT-Core-Server-Zertifikat, um sich bei dem Greengrass-Core-Gerät zu authentifizieren. Standardmäßig läuft dieses Zertifikat in 7 Tagen ab. Seine Gültigkeit ist ausSicherheitsgründen begrenzt, sodass, wenn Unbefugte das Zertifikat erhalten, es nicht lange genutztwerden kann.

Für die Zertifikatrotation muss Ihr Greengrass-fähiges Gerät online sein und regelmäßig direkt auf denGreengrass-Cloud-Service zugreifen können. Wenn das Zertifikat abgelaufen ist, versucht das GreengrassCore-Gerät, eine Verbindung zum Greengrass-Cloud-Service herzustellen, um ein neues Zertifikatanzufordern. Wenn eine Verbindung hergestellt wurde, lädt das Core-Gerät das neue MQTT-Core-Server-Zertifikat herunter und startet den lokalen MQTT-Service neu. An diesem Punkt werden alle Greengrass-Geräte vom Core getrennt. Wenn das Gerät zum Zeitpunkt des Ablaufs offline ist, empfängt es dasErsatzzertifikat nicht. Alle neuen Versuche, eine Verbindung mit dem Core-Gerät herzustellen, werdenabgelehnt. Bestehende Verbindungen bleiben davon unberührt. Geräte können erst dann eine Verbindung

430

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass Cipher Suites

mit dem Core-Gerät herstellen, wenn die Verbindung zum Greengrass-Cloud-Service wiederhergestelltwurde und ein neues MQTT-Core-Server-Zertifikat heruntergeladen werden kann.

Die Zeit bis zum Ablauf kann je nach Ihren Anforderungen auf einen Wert zwischen 7 und 30 Tagenfestgelegt werden. Häufigere Rotationen erfordern häufigere Cloud-Verbindungen. Weniger häufigeRotationen können Sicherheitsrisiken darstellen. Wenn Sie für das Ablaufdatum des Zertifikats einenhöheren Wert als 30 Tage festlegen möchten, wenden Sie sich an den AWS-Support.

Wenn das MQTT-Core-Server-Zertifikat abgelaufen ist, schlägt jeder Validierungsversuch fehl. Das Gerätmuss den Fehler erkennen und die Verbindung beenden können.

AWS IoT Greengrass Cipher SuitesAWS IoT Greengrass verwendet das AWS IoT-Transport-Sicherheitsmodell zum Verschlüsseln derKommunikation mit der Cloud unter Verwendung von TLS Cipher Suites. Darüber hinaus sind die AWSIoT Greengrass-Daten im Ruhezustand (in der Cloud) verschlüsselt. Weitere Informationen über AWS IoT-Transportsicherheit und unterstützte Verschlüsselungs-Suites finden Sie unter Transportsicherheit im AWSIoT-Entwicklerhandbuch.

Unterstützte Verschlüsselungs-Suites für lokale Netzwerkkommunikation

Im Gegensatz zur AWS IoT-Cloud unterstützt AWS IoT Greengrass-Core die folgenden TLS-Verschlüsselungs-Suites für das lokale Netzwerk für Algorithmen zur Signierung von Zertifikaten.Alle diese Verschlüsselungs-Suites werden unterstützt, wenn private Schlüssel im Dateisystemgespeichert werden. Eine Teilmenge wird unterstützt, wenn der Core so konfiguriert ist, dass Hardware-Sicherheitsmodule (HSM) verwendet werden. Weitere Informationen finden Sie unter the section called“Sicherheitsprinzipale” (p. 428) und the section called “Hardware-Sicherheit” (p. 435). Die Tabelleumfasst außerdem die Version der AWS IoT Greengrass Core-Software, die mindestens erforderlich ist, umSupport zu erhalten.

VerschlüsselungsverfahrenHSM-Support GGC-Mindestversion

TLS_ECDHE_RSA_WITH_AES_128_CBC_SHAUnterstützt 1.0


TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384Unterstützt 1.0

TLS_RSA_WITH_AES_128_CBC_SHANicht unterstützt 1.0

TLS_RSA_WITH_AES_128_GCM_SHA256Nicht unterstützt 1.0


TLS_RSA_WITH_AES_256_GCM_SHA384Nicht unterstützt 1.0

TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256Unterstützt 1.9

TLSv1.2

TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384Unterstützt 1.9




TLSv1.1


TLSv1.0 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHAUnterstützt 1.0

431

https://en.wikipedia.org/wiki/Transport_Layer_Security

https://en.wikipedia.org/wiki/Cipher_suite

https://docs.aws.amazon.com/iot/latest/developerguide/iot-security-identity.html#transport-security

AWS IoT Greengrass EntwicklerhandbuchGreengrass-Servicerolle

VerschlüsselungsverfahrenHSM-Support GGC-Mindestversion




Greengrass-ServicerolleDie Greengrass-Servicerolle ist eine AWS Identity and Access Management (IAM)-Servicerolle, mit derAWS IoT Greengrass für den Zugriff auf Ressourcen von AWS-Services in Ihrem Namen autorisiert wird.Dadurch kann AWS IoT Greengrass grundlegende Aufgaben durchführen, wie z. B. das Abrufen Ihrer AWSLambda-Funktionen und das Verwalten von AWS IoT-Schatten.

Damit AWS IoT Greengrass die Erlaubnis für den Zugriff auf Ihre Ressourcen erhält, müssendie Greengrass-Servicerolle Ihrem AWS-Konto zugewiesen und AWS IoT Greengrassals vertrauenswürdige Entität angegeben werden. Die Rolle muss auch die verwalteteAWSGreengrassResourceAccessRolePolicy-Richtlinie enthalten oder entsprechende Berechtigungendefinieren. AWSGreengrassResourceAccessRolePolicy wird von AWS verwaltet und definiert denSatz der von AWS IoT Greengrass geforderten Berechtigungen.

Sie können die gleiche Servicerolle in mehreren AWS-Regionen wiederverwenden, müssen Sie aberin jeder AWS-Region, in der Sie AWS IoT Greengrass verwenden, Ihrem AWS-Konto zuordnen. DieGruppenbereitstellung schlägt fehl, wenn die Servicerolle nicht im aktuellen AWS-Konto und der Regionvorhanden ist.

Note

Zusätzlich zu der Servicerolle, mit der Zugriff auf Serviceebene autorisiert wird, können Sie einemAWS IoT Greengrass-Gruppe eine Grupperolle zuweisen. Dabei handelt es sich um eine IAM-Rolle, die steuert, wie Greengrass Lambda-Funktionen und -Konnektoren in der Gruppe auf AWS-Services zugreifen können.

Im folgenden Verfahren gehen wir davon aus, dass die AWS CLI installiert und für die VerwendungIhrer AWS-Konto-ID konfiguriert ist. Weitere Informationen finden Sie unter Installieren der AWS-Befehlszeilenschnittstelle und Konfigurieren der AWS CLI im Benutzerhandbuch für AWS Command LineInterface.

Abrufen der Greengrass-ServicerolleMit der folgenden Vorgehensweise können Sie herausfinden, ob eine Greengrass-Servicerolle Ihrem AWS-Konto in einer AWS-Region zugewiesen ist.

• Rufen Sie die Servicerolle ab. Ersetzen Sie Region durch Ihre AWS-Region (z. B. us-west-2).

aws greengrass get-service-role-for-account --region Region

Wenn Ihrem Konto bereits eine Greengrass-Servicerolle zugewiesen ist, werden die folgendenRollenmetadaten zurückgegeben.

{ "AssociatedAt": "time-stamp", "RoleArn": "arn:aws:iam::account-id:role/service-role/role-name"}

432

https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy




AWS IoT Greengrass EntwicklerhandbuchDie Servicerolle erstellen

Werden keine Rollenmetadaten zurückgegeben, müssen Sie die Servicerolle erstellen (sofern sie nochnicht vorhanden ist) und Ihrem Konto in der AWS-Region zuweisen.

Erstellen der Greengrass-ServicerolleMit den folgenden Verfahren können Sie eine Greengrass-Servicerolle erstellen und Ihrem AWS-Kontozuweisen.

Sie können eine Greengrass-Servicerolle erstellen, die über AWS-Regionen hinweg angewendet wird. Siemuss jedoch in jeder AWS-Region, in der Sie AWS IoT Greengrass verwenden, Ihrem Konto zugewiesenwerden.

Note

Wenn Sie eine Greengrass-Gruppe über AWS IoT-Konsole bereitstellen, prüft die Konsole, obeine Greengrass-Servicerolle Ihrem AWS-Konto in der aktuellen AWS-Region zugeordnet ist.Andernfalls werden Sie aufgefordert, AWS IoT Greengrass das Lesen und Schreiben in AWS-Services in Ihrem Namen zu erlauben. Wenn Sie die Berechtigung erteilen, erstellt die Konsoleeine Rolle mit der Bezeichnung Greengrass_ServiceRole (falls noch nicht vorhanden) undverknüpft sie mit Ihrem AWS-Konto in der aktuellen AWS-Region.

So erstellen Sie die Servicerolle in IAM

1. Erstellen Sie die Rolle mit einer Vertrauensrichtlinie, die es AWS IoT Greengrass erlaubt, die Rolleanzunehmen. In diesem Beispiel wird eine Rolle namens Greengrass_ServiceRole erstellt, aberSie können einen anderen Namen verwenden.

Linux, macOS, or Unix

aws iam create-role --role-name Greengrass_ServiceRole --assume-role-policy-document '{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "greengrass.amazonaws.com" }, "Action": "sts:AssumeRole" } ]}'

Windows Command Prompt

aws iam create-role --role-name Greengrass_ServiceRole --assume-role-policy-document "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"greengrass.amazonaws.com\"},\"Action\":\"sts:AssumeRole\"}]}"

2. Kopieren Sie den Rollen-ARN aus den Rollenmetadaten in der Ausgabe. Sie verknüpfen dieServicerolle mithilfe des ARN mit Ihrem Konto.

3. Fügen Sie der Rolle die AWSGreengrassResourceAccessRolePolicy-Richtlinie an.

aws iam attach-role-policy --role-name Greengrass_ServiceRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy

433

AWS IoT Greengrass EntwicklerhandbuchServicerollen entfernen

So verknüpfen Sie die Servicerolle mit Ihrem AWS-Konto

• Weisen Sie die Rolle Ihrem Konto zu. Ersetzen Sie role-arn durch den ARN der Servicerolle undRegion durch Ihre AWS-Region (z. B. us-west-2).

aws greengrass associate-service-role-to-account --role-arn role-arn --region Region

Bei erfolgreicher Durchführung wird die folgende Meldung zurückgegeben.

{ "AssociatedAt": "time-stamp"}

Entfernen der Greengrass-ServicerolleMit dem folgenden Verfahren können Sie die Zuweisung der Greengrass-Servicerolle aus Ihrem AWS-Konto löschen.

• Haben Sie die Zuordnung der Servicerolle bei Ihrem Konto auf. Ersetzen Sie Region durch Ihre AWS-Region (z. B. us-west-2).

aws greengrass disassociate-service-role-from-account --region Region

Bei erfolgreicher Durchführung wird die folgende Meldung zurückgegeben.

{ "DisassociatedAt": "time-stamp"}

Note

Sie sollten die Servicerolle löschen, wenn Sie sie in keiner AWS-Regionverwenden. Verwenden Sie zuerst delete-role-policy, um die verwalteteAWSGreengrassResourceAccessRolePolicy-Richtlinie von der Rolle zu lösen, undverwenden Sie dann delete-role, um die Rolle zu löschen. Weitere Informationen finden Sieunter Löschen von Rollen oder Instance-Profilen in IAM-Benutzerhandbuch.

Weitere Informationen finden Sie auch unter:• Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS-Service im IAM-

Benutzerhandbuch• Löschen von Rollen oder Instance-Profilen in IAM-Benutzerhandbuch• AWS IoT Greengrass-Befehle im AWS CLI Command Reference

• associate-service-role-to-account• disassociate-service-role-from-account• get-service-role-for-account

• IAM-Befehle im AWS CLI Command Reference• attach-role-policy• create-role• delete-role

434

https://docs.aws.amazon.com/cli/latest/reference/iam/delete-role-policy.html

https://docs.aws.amazon.com/cli/latest/reference/iam/delete-role.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/associate-service-role-to-account.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/disassociate-service-role-from-account.html

https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-service-role-for-account.html

https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html

https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html

https://docs.aws.amazon.com/cli/latest/reference/iam/delete-role.html

AWS IoT Greengrass EntwicklerhandbuchHardware-Sicherheit

• delete-role-policy

Integration von Hardware-SicherheitDiese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.

AWS IoT Greengrass unterstützt den Einsatz von Hardware-Sicherheitsmodulen (HSM) über die PKCS#11-Schnittstelle (p. 443) zur sicheren Speicherung und Entladung privater Schlüssel. Dadurch wirdverhindert, dass Schlüssel in der Software freigelegt oder dupliziert werden. Private Schlüssel könnensicher auf Hardwaremodulen wie HSMs, Trusted Platform Modules (TPM) oder anderen kryptographischenElementen gespeichert werden.

Suchen Sie im Gerätekatalog der AWS-Partner nach Geräten, die für diese Funktion qualifiziert sind.

Das folgende Diagramm zeigt die Hardware-Sicherheitsarchitektur für ein AWS IoT Greengrass-Core.

Bei einer Standardinstallation verwendet AWS IoT Greengrass zwei private Schlüssel. Ein Schlüsselwird von der AWS IoT-Client-Komponente während des Transport Layer Security (TLS)-Handshakeverwendet, wenn sich ein Greengrass Core mit AWS IoT verbindet. (Dieser Schlüssel wird auch als privaterKernschlüssel bezeichnet.) Der andere Schlüssel wird vom lokalen MQTT-Server verwendet, wodurchGreengrass-Geräte mit dem Greengrass Core kommunizieren können. Wenn Sie die Hardware-Sicherheitfür beide Komponenten verwenden möchten, können Sie einen gemeinsamen privaten Schlüssel oderseparate private Schlüssel verwenden. Weitere Informationen finden Sie unter the section called “Bereitstellungspraktiken” (p. 439).

Note

Bei einer Standardinstallation verwendet der lokale Secrets-Manager auch den IoT-Client-Schlüssel für seinen Verschlüsselungsprozess, aber Sie können auch Ihren eigenen privatenSchlüssel verwenden. Es muss ein RSA-Schlüssel mit einer minimalen Länge von 2048 Bit sein.Weitere Informationen finden Sie unter the section called “Angeben des privaten Schlüssels für dieVerschlüsselung von Secrets” (p. 276).

VoraussetzungenBevor Sie die Hardwaresicherheit für einen Greengrass Core konfigurieren können, müssen Sie Folgendesbeachten:

• Ein Hardwaresicherheitsmodul (HSM), das Ihre private Schlüsselkonfiguration für den IoT-Client,den lokalen MQTT-Server und lokale Secrets-Manager-Komponenten unterstützt. Die Konfiguration

435

https://docs.aws.amazon.com/cli/latest/reference/iam/delete-role-policy.html

https://devices.amazonaws.com/search?kw=22HSI22&page=1

AWS IoT Greengrass EntwicklerhandbuchHardware-Sicherheitskonfiguration

kann einen, zwei oder drei hardwarebasierte private Schlüssel beinhalten, je nachdem, ob Sie dieKomponenten für die Freigabe von Schlüsseln konfigurieren. Weitere Informationen zur Unterstützungvon privaten Schlüsseln finden Sie unter the section called “Sicherheitsprinzipale” (p. 428).• Für RSA-Schlüssel: Eine RSA-Schlüsselgröße von 2048 (oder größer) und ein PKCS#1

v1.5 (p. 443)-Signaturschema.• Für EC-Schlüssel: Eine NIST P-256- oder NIST P-384-Kurve.

Note

Suchen Sie im Gerätekatalog der AWS-Partner nach Geräten, die für diese Funktion qualifiziertsind.

• Eine PKCS#11-Anbieterbibliothek, die zur Laufzeit (mit libdl) geladen werden kann undPKCS#11 (p. 443)-Funktionen bereitstellt.

• Das Hardwaremodul muss nach Slot-Label auflösbar sein, wie in der PKCS#11-Spezifikation definiert.• Der private Schlüssel muss mit Hilfe der vom Hersteller bereitgestellten Provisionierungswerkzeuge

generiert und auf das HSM geladen werden.• Der private Schlüssel muss durch ein Objektlabel auflösbar sein.• Das Core-Gerätezertifikat. Dies ist ein AWS IoT-Client-Zertifikat, das dem privaten Schlüssel entspricht.• Wenn Sie den Greengrass OTA-Aktualisierungsagent verwenden, muss die OpenSSL libp11

PKCS#11-Wrapper-Bibliothek installiert sein. Weitere Informationen finden Sie unter the section called“Konfigurieren von OTA-Updates” (p. 442).

Stellen Sie außerdem sicher, dass die folgenden Bedingungen erfüllt sind:

• Die IoT-Client-Zertifikate, die dem privaten Schlüssel zugeordnet sind, wurden in AWS IoT registriert undaktiviert. Sie können dies auf der Seite Manage (Verwalten) für das Core-Objekt in der AWS IoT-Konsoleüberprüfen.

• Die AWS IoT Greengrass Core-Software (v1.7 or later) ist auf dem Core-Gerät installiert, wie in Modul2 (p. 81) des Erste Schritte-Tutorials beschrieben. Version 1.9 ist erforderlich zur Verwendung eines EC-Schlüssels für den MQTT-Server.

• Die Zertifikate sind dem Greengrass Core angefügt. Sie können dies auf der Seite Manage (Verwalten)für das Core-Objekt in der AWS IoT-Konsole überprüfen.

Note

Derzeit unterstützt AWS IoT Greengrass nicht das Laden des CA-Zertifikats oder des AWS IoT-Client-Zertifikats direkt aus dem HSM. Die Zertifikate müssen als Klartextdateien an einem Ort imDateisystem geladen werden, der von Greengrass gelesen werden kann.

Hardware-Sicherheitskonfiguration für einen AWS IoTGreengrass CoreDie Hardware-Sicherheit wird in der Greengrass-Konfigurationsdatei konfiguriert. Dies ist die Dateiconfig.json (p. 23), die sich im Verzeichnis /greengrass-root/config befindet.

Note

Um den Prozess der Einrichtung einer HSM-Konfiguration mit einer reinen Software-Implementierung zu durchlaufen, siehe the section called “Modul 7: Simulation der Hardware-Sicherheitsintegration” (p. 151).

Important

Die simulierte Konfiguration im Beispiel bietet keine Sicherheitsvorteile. Das Beispiel sollIhnen ermöglichen, sich über die PKCS#11-Spezifikation zu informieren und erste Tests

436

https://devices.amazonaws.com/search?kw=22HSI22&page=1

https://github.com/OpenSC/libp11



Ihrer Software durchzuführen, wenn Sie planen, in Zukunft ein hardwarebasiertes HSMeinzusetzen.

Um die Hardware-Sicherheit in AWS IoT Greengrass zu konfigurieren, bearbeiten Sie das Objekt cryptoin config.json.

Bei der Verwendung von Hardware-Sicherheit wird das Objekt crypto eingesetzt, um Pfade zuZertifikaten, privaten Schlüsseln und Assets für die PKCS#11-Anbieterbibliothek im Core anzugeben, wieim folgenden Beispiel gezeigt.

"crypto": { "PKCS11" : { "OpenSSLEngine" : "/path-to-p11-openssl-engine", "P11Provider" : "/path-to-pkcs11-provider-so", "slotLabel" : "crypto-token-name", "slotUserPin" : "crypto-token-user-pin" }, "principals" : { "IoTCertificate" : { "privateKeyPath" : "pkcs11:object=core-private-key-label;type=private", "certificatePath" : "file:///path-to-core-device-certificate" }, "MQTTServerCertificate" : { "privateKeyPath" : "pkcs11:object=server-private-key-label;type=private" }, "SecretsManager" : { "privateKeyPath": "pkcs11:object=core-private-key-label;type=private" } }, "caPath" : "file:///path-to-root-ca"

Das crypto-Objekt enthält die folgenden Eigenschaften:




Note


PKCS11



Diese Eigenschaft ist erforderlich,wenn Sie den Greengrass-OTA-Aktualisierungsagent mitHardware-Sicherheit verwenden.Weitere Informationen findenSie unter the section called“Konfigurieren von OTA-Updates” (p. 442).

437





slotLabel Das Slot-Label, daszur Identifizierung desHardwaremoduls verwendet wird.



Muss über ausreichendeBerechtigungen verfügen, umC_Sign mit den konfiguriertenprivaten Schlüsseln auszuführen.

principals





Muss für einen HSM-Speicherein RFC 7512 PKCS#11-Pfadsein, der eine Objektbezeichnungangibt.





438


AWS IoT Greengrass EntwicklerhandbuchBereitstellungspraktiken



Der Pfad zum privaten Schlüsseldes lokalen MQTT-Servers.

Verwenden Sie diesen Wert, umeinen eigenen privaten Schlüsselfür den lokalen MQTT-Serveranzugeben.


Muss für einen HSM-Speicherein RFC 7512 PKCS#11-Pfadsein, der eine Objektbezeichnungangibt.


SecretsManager Der private Schlüssel, der den für die Verschlüsselung verwendetenDatenschlüssel schützt. Weitere Informationen finden Sie unterSecrets für Core bereitstellen (p. 274).


Der Pfad zum privaten Schlüsseldes lokalen Secrets Managers.



Muss für einen HSM-Speicherein RFC 7512 PKCS#11-Pfadsein, der eine Objektbezeichnungangibt. Der private Schlüsselmuss erstellt werden, indemSie den PKCS#1 v1.5-Padding-Mechanismus verwenden.

Bereitstellungspraktiken für die AWS IoT GreengrassHardware-SicherheitIm Folgenden werden die sicherheits- und leistungsbezogenen Bereitstellungspraktiken beschrieben.

439





Sicherheit• Generieren Sie private Schlüssel direkt auf dem HSM mit Hilfe des internen Hardware-

Zufallszahlengenerators.

Note

Wenn Sie private Schlüssel für die Verwendung mit dieser Funktion konfigurieren (indemSie die Anweisungen des Hardwareherstellers befolgen), beachten Sie, dass AWSIoT Greengrass derzeit nur den Padding-Mechanismus PKCS1 v1.5 für die Ver- undEntschlüsselung von lokalen Secrets (p. 274) unterstützt. AWS IoT Greengrass unterstütztnicht Optimal Asymmetric Encryption Padding (OAEP).

• Konfigurieren Sie private Schlüssel, um den Export zu verhindern.• Verwenden Sie das Bereitstellungstool, das vom Hardwarehersteller zur Verfügung gestellt wird,

um eine Zertifikatsignieranforderung (CSR) mit dem hardwaregeschützten privaten Schlüssel zugenerieren. Erstellen Sie dann mithilfe AWS IoT-Konsole ein Client-Zertifikat.

Note

Die Praxis des Rotierens von Schlüsseln gilt nicht, wenn private Schlüssel auf einem HSMerzeugt werden.

Leistung

Das folgende Diagramm zeigt die AWS IoT-Client-Komponente und den lokalen MQTT-Server auf demAWS IoT Greengrass-Core. Wenn Sie eine HSM-Konfiguration für beide Komponenten verwendenmöchten, können Sie den gleichen privaten Schlüssel oder separate private Schlüssel verwenden.Wenn Sie separate Schlüssel verwenden, müssen diese im gleichen Slot gespeichert sein.

Note

AWS IoT Greengrass setzt der Anzahl der Schlüssel, die Sie auf dem HSM speichern,keine Grenzen, sodass Sie private Schlüssel für den IoT-Client, den MQTT-Server und dieKomponenten des Secret-Manager speichern können. Einige HSM-Anbieter können jedochdie Anzahl der Schlüssel, die Sie in einem Slot speichern können, begrenzen.

Im Allgemeinen wird der IoT-Client-Key nicht sehr häufig verwendet, da die AWS IoT GreengrassCore-Software langlebige Verbindungen zur Cloud unterhält. Der MQTT-Server-Schlüssel wird jedochjedes Mal verwendet, wenn sich ein Greengrass-Gerät mit dem Kern verbindet. Diese Interaktionenwirken sich direkt auf die Leistung aus.

440


Wenn der MQTT-Server-Schlüssel auf dem HSM gespeichert ist, hängt die Geschwindigkeit, mit dersich Geräte verbinden können, von der Anzahl der RSA-Signaturvorgänge pro Sekunde ab, die dasHSM ausführen kann. Wenn das HSM beispielsweise 300 Millisekunden benötigt, um eine RSASSA-PKCS1-v1.5-Signatur auf einem privaten Schlüssel des RSA-2048 auszuführen, können sich nur dreiGeräte pro Sekunde mit dem Greengrass Core verbinden. Nach dem Herstellen der Verbindungenwird das HSM nicht mehr verwendet, und es gelten die standardmäßigen Greengrass-Limits.

Um Leistungsengpässe zu vermeiden, können Sie den privaten Schlüssel für den MQTT-Server aufdem Dateisystem statt auf dem HSM speichern. Bei dieser Konfiguration verhält sich der MQTT-Serverso, als ob die Hardware-Sicherheit nicht aktiviert wäre.

AWS IoT Greengrass unterstützt mehrere Schlüsselspeicher-Konfigurationen für die IoT-Client-und MQTT-Serverkomponenten, sodass Sie die beste Konfiguration für Ihre Sicherheits- undLeistungsanforderungen auswählen können. Die folgende Tabelle enthält Beispielkonfigurationen.

Konfiguration IoT-Schlüssel MQTT-Schlüssel Performance

Gemeinsamer HSM-Schlüssel

HSM: Schlüssel A HSM: Schlüssel A Begrenzt durch dasHSM oder die CPU

HSM SeparateSchlüssel

HSM: Schlüssel A HSM: Schlüssel B Begrenzt durch dasHSM oder die CPU

HSM nur für IoT HSM: Schlüssel A Dateisystem: SchlüsselB

Begrenzt durch dieCPU

Veraltet Dateisystem: SchlüsselA

Dateisystem: SchlüsselB

Begrenzt durch dieCPU

Um Greengrass Core so zu konfigurieren, dass der Dateisystem-basierte Schlüssel für den MQTT-Server verwendet wird, lassen Sie den Abschnitt principals.MQTTServerCertificate der Dateiconfig.json weg (oder geben Sie einen dateibasierten Pfad zum Schlüssel an, wenn Sie nicht denvon AWS IoT Greengrass erzeugten Standardschlüssel verwenden). Das resultierende Objekt cryptosieht folgendermaßen aus:

"crypto": { "PKCS11": { "OpenSSLEngine": "...", "P11Provider": "...", "slotLabel": "...", "slotUserPin": "..." }, "principals": { "IoTCertificate": { "privateKeyPath": "...", "certificatePath": "..." }, "SecretsManager": { "privateKeyPath": "..." } }, "caPath" : "..."}

441


AWS IoT Greengrass EntwicklerhandbuchUnterstützte Verschlüsselungs-Suiten

Unterstützte Verschlüsselungs-Suiten für dieHardware-SicherheitsintegrationAWS IoT Greengrass unterstützt eine Reihe von Verschlüsselungs-Suiten, wenn der Core für dieHardwaresicherheit konfiguriert ist. Dies ist eine Teilmenge der Verschlüsselungs-Suiten, die unterstütztwerden, wenn der Kern für die Verwendung dateibasierter Sicherheit konfiguriert ist. Weitere Informationenfinden Sie unter the section called “AWS IoT Greengrass Cipher Suites” (p. 431).

Note

Wenn Sie sich von Greengrass-Geräten über das lokale Netzwerk mit dem Greengrass-Coreverbinden, stellen Sie sicher, dass Sie eine der unterstützten Verschlüsselungs-Suiten verwenden,um die TLS-Verbindung herzustellen.

Unterstützung für Over-the-Air-Updates konfigurierenUm Over-The-Air (OTA)-Updates der AWS IoT Greengrass Core-Software bei Verwendung von Hardware-Sicherheit zu ermöglichen, müssen Sie die OpenSC libp11 PKCS#11 Wrapper-Bibliothek installieren unddie Greengrass-Konfigurationsdatei bearbeiten. Weitere Informationen zu OTA-Updates finden Sie unterOTA-Updates der AWS IoT Greengrass Core-Software (p. 158).

1. Stoppen Sie den AWS Greengrass-Daemon.

cd /greengrass-root/ggc/core/sudo ./greengrassd stop

Note

greengrass-root steht für den Pfad, unter dem die AWS IoT Greengrass Core-Software auf Ihrem Gerät installiert ist. Falls Sie die Software anhand des im Tutorial ErsteSchritte (p. 69) beschriebenen Verfahrens installiert haben, handelt es sich hierbei um dasVerzeichnis /greengrass.

2. Installieren der OpenSSL-Engine.

sudo apt-get install libengine-pkcs11-openssl

3. Suchen Sie den Pfad zur OpenSSL-Engine (libpkcs11.so) auf Ihrem System:

a. Holen Sie sich die Liste der installierten Pakete für die Bibliothek.

sudo dpkg -L libengine-pkcs11-openssl

Die Datei libpkcs11.so befindet sich im Verzeichnis engines.b. Kopieren Sie den vollständigen Pfad in die Datei (z. B. /usr/lib/ssl/engines/

libpkcs11.so).4. Öffnen Sie die Greengrass-Konfigurationsdatei. Dies ist die Datei config.json (p. 23) im Verzeichnis

/greengrass-root/config.5. Geben Sie für die Eigenschaft OpenSSLEngine den Pfad zur Datei libpkcs11.so ein.

{ "crypto": { "caPath" : "file:///path-to-root-ca", "PKCS11" : { "OpenSSLEngine" : "/path-to-p11-openssl-engine",

442


AWS IoT Greengrass EntwicklerhandbuchAbwärtskompatibilität

"P11Provider" : "/path-to-pkcs11-provider-so", "slotLabel" : "crypto-token-name", "slotUserPin" : "crypto-token-user-pin" }, ... } ...}

Note

Wenn die Eigenschaft OpenSSLEngine im Objekt PKCS11 nicht vorhanden ist, dann fügenSie sie hinzu.

6. Starten Sie den AWS Greengrass-Daemon.


Abwärtskompatibilität mit früheren Versionen der AWSIoT Greengrass Core-SoftwareDie AWS IoT Greengrass Core-Software mit Hardware-Sicherheitsunterstützung ist vollständigabwärtskompatibel mit config.json-Dateien, die für v1.6. und früher erzeugt werden. Wenn das Objektcrypto nicht in der Konfigurationsdatei config.json vorhanden ist, verwendet AWS IoT Greengrass diedateibasierten Eigenschaften coreThing.certPath, coreThing.keyPath und coreThing.caPath.Diese Abwärtskompatibilität gilt für Greengrass OTA-Updates, die eine dateibasierte Konfiguration, die inconfig.json angegeben ist, nicht überschreiben.

Hardware ohne PKCS#11-UnterstützungDie PKCS#11-Bibliothek wird typischerweise vom Hardwarehersteller bereitgestellt oder ist OpenSource. So ist es beispielsweise bei standardkonformer Hardware (z. B. TPM1.2) möglich, vorhandeneOpen-Source-Software zu nutzen. Wenn Ihre Hardware jedoch keine entsprechende PKCS#11-Bibliotheksimplementierung hat oder wenn Sie einen benutzerdefinierten PKCS#11-Anbieter schreibenmöchten, sollten Sie sich mit den Fragen zur Integration an Ihren AWS Enterprise Support Mitarbeiterwenden.

Weitere Informationen finden Sie auch unter:• PKCS #11 Kryptographische Token-Schnittstelle, Bedienungsanleitung Version 2.40. Herausgegeben

von John Leiseboer und Robert Griffin. 16. November 2014. OASIS-Ausschuss Anmerkung 02. http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html. Letzte Version: http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html.

• RFC 7512• PKCS #1: RSA Encryption Version 1.5

443







AWS IoT Greengrass EntwicklerhandbuchCloudWatch Logs

Überwachung mit AWS IoTGreengrass-Protokollen

AWS IoT Greengrass besteht aus dem Cloud-Service und der AWS IoT Greengrass Core-Software.Die AWS IoT Greengrass Core-Software kann Protokolle in Amazon CloudWatch oder auf das lokaleDateisystem Ihres Core-Geräts schreiben. Sie können die Protokolle verwenden, um Ereignisse zuüberwachen und Probleme zu beheben. Alle AWS IoT Greengrass-Protokolleinträge enthalten einenZeitstempel, die Protokollebene sowie Informationen über das Ereignis.

Die Protokollierung wird auf Gruppenebene konfiguriert. Die Schritte, wie man die Protokollierung für AWSIoT Greengrass-Gruppe konfiguriert, finden Sie unter the section called “Konfigurieren der Protokollierungfür AWS IoT Greengrass” (p. 446).

CloudWatch LogsWenn Sie die CloudWatch-Protokollierung konfigurieren, können Sie die Protokolle auf der Seite Logs derAmazon CloudWatch-Konsole anzeigen. Protokollgruppen für AWS IoT Greengrass-Protokolle verwendendie folgenden Namenskonventionen:

/aws/greengrass/GreengrassSystem/greengrass-system-component-name/aws/greengrass/Lambda/aws-region/account-id/lambda-function-name

Jede Protokollgruppe enthält Protokollströme, die die folgende Namenskonvention verwenden:

date/account-id/greengrass-group-id/name-of-core-that-generated-log

Die folgenden Hinweise gelten für die Verwendung von CloudWatch Logs:

•Ihre Greengrass-Gruppenrolle muss es AWS IoT Greengrass gestatten, in CloudWatch Logs zuschreiben. Zum Erteilen der Berechtigungen betten Sie die folgende Inline-Richtlinie in Ihre Gruppenrolleein.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:*:*:*" ] } ]}

444

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console

AWS IoT Greengrass EntwicklerhandbuchDateisystemprotokolle

Sie können einen detaillierteren Zugriff auf Ihre Protokoll-Ressourcen gewähren. Weitere Informationenfinden Sie unter Verwenden von identitätsbasierten Richtlinien (IAM-Richtlinien) für CloudWatch Logs imAmazon CloudWatch-Benutzerhandbuch.

• Protokolle werden an CloudWatch Logs gesendet – für den Fall, dass es keine Internetverbindunggibt, mit einer begrenzten Anzahl von Wiederholungen. Wenn die Zahl der zulässigen Wiederholungenerreicht ist, wird das Ereignis entfernt.

• Es gelten Einschränkungen für Transaktionen, Arbeitsspeicher und anderes. Weitere Informationenfinden Sie unter the section called “Einschränkungen für die Protokollierung” (p. 448).

DateisystemprotokolleWenn Sie die Protokollierung des Dateisystems konfigurieren, werden die Protokolldateien untergreengrass-root/ggc/var/log auf dem Kerngerät gespeichert. Im Folgenden finden Sie dieübergeordnete Verzeichnisstruktur:

greengrass-root/ggc/var/log - crash.log - system - log files for each Greengrass system component - user - log files generated by each user-defined Lambda function

Note

Standardmäßig ist greengrass-root das /greengrass-Verzeichnis. Wenn einSchreibverzeichnis (p. 55) konfiguriert wurde, finden Sie auch die Protokolle dort.

Die folgenden Hinweise gelten für die Verwendung von Dateisystemprotokollen:

• Für das Lesen von AWS IoT Greengrass-Protokollen auf dem Dateisystem sind Root-Berechtigungenerforderlich.

• AWS IoT Greengrass unterstützt eine größenbasierte Rotation und, wenn die Menge der Protokolldatennahe am konfigurierten Limit ist, die automatische Bereinigung von Protokolldaten.

• Die crash.log-Datei ist nur in Dateisystemprotokollen vorhanden. Dieses Protokoll wird nicht inCloudWatch Logs geschrieben.

• Es gelten Einschränkungen im Hinblick auf die Festplattennutzung. Weitere Informationen finden Sieunter the section called “Einschränkungen für die Protokollierung” (p. 448).

Note

Protokolle für AWS IoT Greengrass Core-Software v1.0 werden im Verzeichnis greengrass-root/var/log gespeichert.

Standardkonfiguration für die ProtokollierungWenn die Einstellungen für die Protokollierung nicht explizit konfiguriert sind, verwendet AWSIoT Greengrass die folgende Standardkonfiguration für die Protokollierung nach der erstenGruppenbereitstellung.

AWS IoT Greengrass Systemkomponenten• Typ - FileSystem

445

https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-identity-based-access-control-cwl.html

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren der Protokollierung für AWS IoT Greengrass

• Komponente - GreengrassSystem• Level - INFO• Leerzeichen - 128 KB

Benutzerdefinierte Lambda-Funktionen• Typ - FileSystem• Komponente - Lambda• Level - INFO• Leerzeichen - 128 KB

Note

Vor der ersten Bereitstellung schreiben nur Systemkomponenten Protokolle in das Dateisystem,da keine benutzerdefinierten Lambda-Funktionen bereitgestellt sind.

Konfigurieren der Protokollierung für AWS IoTGreengrass

Sie können die APIs AWS IoT-Konsole oder AWS IoT Greengrass (p. 447) zur Konfiguration der AWSIoT Greengrass-Protokollierung verwenden.

Note

Damit AWS IoT Greengrass Protokolle in CloudWatch Logs schreiben kann, muss IhreGruppenrolle die erforderlichen CloudWatch Logs Aktionen erlauben (p. 444).

Konfigurieren der Protokollierung (Konsole)Sie können die Protokollierung auf der Seite Settings (Einstellungen) der Gruppe konfigurieren.

1. Wählen Sie in der AWS IoT-Konsole Greengrass und dann Groups.2. Wählen Sie die Gruppe, in der Sie die Protokollierung konfigurieren möchten.3. Wählen Sie auf der Gruppenkonfigurationsseite die Option Settings (Einstellungen) aus.4. Wählen Sie den Speicherort für die Protokollierung wie folgt:

• Um die CloudWatch-Protokollierung zu konfigurieren, wählen Sie für die CloudWatch Logs-Konfiguration die Option Edit.

• Um die Dateisystemprotokollierung für die Lokale Protokollkonfiguration zu konfigurieren, wählen SieEdit (Bearbeiten).

Sie können die Protokollierung für einen einzigen Speicherort oder für beide Speicherortekonfigurieren.

5. Wählen Sie auf der Seite Configure Group logging (Gruppenprotokollierung konfigurieren) die OptionAdd another log type (Einen weiteren Protokolltyp hinzufügen).

6. Wählen Sie die Ereignisquelle wie folgt:

• Um Ereignisse von benutzerdefinierten Lambda-Funktionen zu protokollieren, wählen Sie UserLambdas.

• Um Ereignisse von AWS IoT Greengrass-Systemkomponenten zu protokollieren, wählen SieGreengrass system.

446

AWS IoT Greengrass EntwicklerhandbuchProtokollierung konfigurieren (API)

Sie können eine Komponente oder beide Komponenten wählen.7. Wählen Sie Update aus.8. Wählen Sie die niedrigste Ereignisstufe, die Sie protokollieren möchten. Ereignisse, die unterhalb

dieses Grenzwert liegen, werden herausgefiltert und nicht gespeichert.9. Für Dateisystemprotokolle, geben Sie eine Grenze für den Festplattenspeicher an.10. Wählen Sie Save aus.

Protokollierung konfigurieren (API)Sie können die AWS IoT Greengrass-Logger-APIs verwenden, um die Protokollierung programmgesteuertzu konfigurieren. Verwenden Sie z. B. die CreateLoggerDefinition-Aktion, um eine Logger-Definitionzu erstellen, die auf einer LoggerDefinitionVersion-Nutzlast basiert, und die die folgende Syntaxverwendet:

{ "Loggers": [ { "Id": "string", "Type": "FileSystem|AWSCloudWatch", "Component": "GreengrassSystem|Lambda", "Level": "DEBUG|INFO|WARN|ERROR|FATAL", "Space": "integer" }, { "Id": "string", ... } ]}

LoggerDefinitionVersion ist ein Array mit einem oder mehreren Logger-Objekten, die die folgendenEigenschaften haben:

Id

Eine ID für den Logger.Type

Der Speichermechanismus für Protokollereignisse. Wenn AWSCloudWatch verwendet wird, werdenProtokollereignisse an CloudWatch Logs gesendet. Wenn FileSystem verwendet wird, werden dieProtokollereignisse im lokalen Dateisystem gespeichert.

Zulässige Werte: AWSCloudWatch, FileSystemComponent

Die Quelle des Protokollereignisses. Wenn GreengrassSystem verwendet wird, werden Ereignissevon Greengrass-Systemkomponenten protokolliert. Bei Verwendung von Lambda werden Ereignissevon benutzerdefinierten Lambda-Funktionen protokolliert.

Zulässige Werte: GreengrassSystem, LambdaLevel

Der Schwellenwert für die Protokollstufe. Protokollereignisse, die unterhalb dieses Grenzwert liegen,werden herausgefiltert und nicht gespeichert.

Gültige Werte: DEBUG, INFO (empfohlen), WARN, ERROR, FATAL

447

https://docs.aws.amazon.com/greengrass/latest/apireference/createloggerdefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/definitions-loggerdefinitionversion.html

https://docs.aws.amazon.com/greengrass/latest/apireference/definitions-logger.html

AWS IoT Greengrass EntwicklerhandbuchKonfigurationsbeispiel

Space

Die maximale Größe des lokalen Speichers in KB, der zum Speichern von Protokollen verwendetwerden soll. Dieses Feld gilt nur, wenn Type auf FileSystem festgelegt ist.

KonfigurationsbeispielDas folgende LoggerDefinitionVersion-Beispiel verwendet eine Konfiguration für die Protokollierung,die:

• Aktiviert die Dateisystem-ERROR-Protokollierung (und höher) für AWS IoT Greengrass-Systemkomponenten.

• Aktiviert die Dateisystem-INFO-Protokollierung (und höher) für benutzerdefinierte Lambda-Funktionen.• Aktiviert die CloudWatch INFO-Protokollierung (und darüber) für benutzerdefinierte Lambda-Funktionen.

{ "Name": "LoggingExample", "InitialVersion": { "Loggers": [ { "Id": "1", "Component": "GreengrassSystem", "Level": "ERROR", "Space": 10240, "Type": "FileSystem" }, { "Id": "2", "Component": "Lambda", "Level": "INFO", "Space": 10240, "Type": "FileSystem" }, { "Id": "3", "Component": "Lambda", "Level": "INFO", "Type": "AWSCloudWatch" } ] }}

Nach dem Erstellen einer Logger-Definitionsversion können Sie mit ihrem Versions-ARN eineGruppenversion erstellen, bevor Sie die Gruppe bereitstellen.

Einschränkungen für die ProtokollierungBei AWS IoT Greengrass sind folgende Einschränkungen für die Protokollierung vorhanden:

Transaktionen pro SekundeWenn die Protokollierung in CloudWatch aktiviert ist, stapelt die ProtokollierungskomponenteProtokollereignisse lokal, bevor diese an CloudWatch gesendet werden, sodass Protokollierungen mit einerhöheren Rate als fünf Anforderungen pro Sekunde und Protokollstream möglich sind.

448

AWS IoT Greengrass EntwicklerhandbuchArbeitsspeicher

ArbeitsspeicherWenn AWS IoT Greengrass so konfiguriert ist, dass Protokolle an CloudWatch gesendet werden undeine Lambda-Funktion für einen längeren Zeitraum mehr als 5 MB/Sekunde protokolliert, wird die interneVerarbeitungspipeline schließlich gefüllt. Der theoretische Extremfall liegt bei 6 MB pro Lambda-Funktion.

TaktversatzWenn die Protokollierung in CloudWatch aktiviert ist, signiert die ProtokollierungskomponenteAnforderungen an CloudWatch mit dem normalen Signaturprozess mit Signature Version 4. Wenn dieSystemzeit auf dem AWS IoT Greengrass-Core-Gerät um mehr als 15 Minuten abweicht, werden dieAnforderungen abgelehnt.

FestplattennutzungVerwenden Sie die folgende Formel, um die maximale Gesamtgröße der genutzten Festplatte für dieProtokollierung zu berechnen.

greengrass-system-component-space * 8 // 7 if automatic IP detection is disabled + 128KB // the internal log for the local logging component + lambda-space * lambda-count // different versions of a Lambda function are treated as one

Wobei gilt:

greengrass-system-component-space

Die maximale Größe des lokalen Speichers für AWS IoT Greengrass-Systemkomponentenprotokolle.lambda-space

Die maximale Größe des lokalen Speichers für Lambda-Funktionsprotokolle.lambda-count

Die Anzahl der bereitgestellten Lambda-Funktionen.

ProtokollverlustWenn Ihr AWS IoT Greengrass-Core-Gerät so konfiguriert ist, dass nur in CloudWatch protokolliert wirdund keine Internetverbindung besteht, gibt es keine Möglichkeit, die aktuell im Arbeitsspeicher vorhandenenProtokolle abzurufen.

Wenn Lambda-Funktionen beendet werden (beispielsweise während der Bereitstellung), werden fürmehrere Sekunden keine Protokolle in CloudWatch geschrieben.

Protokollieren von AWS IoT Greengrass-API-Aufrufen mit AWS CloudTrail

AWS IoT Greengrass ist in AWS CloudTrail integriert, einen Service, der die Aktionen eines Benutzers,einer Rolle oder eines AWS-Services in AWS IoT Greengrass aufzeichnet. CloudTrail erfasst alle API-Aufrufe für AWS IoT Greengrass als Ereignisse. Zu den erfassten Aufrufen gehören Aufrufe von der

449

https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Greengrass-Informationen in CloudTrail

AWS IoT Greengrass-Konsole und Code-Aufrufe der AWS IoT Greengrass-API-Operationen. Wenn Sieeinen Trail erstellen, können Sie die kontinuierliche Bereitstellung von CloudTrail-Ereignissen an einenAmazon S3-Bucket, einschließlich Ereignissen für AWS IoT Greengrass, aktivieren. Auch wenn Siekeinen Trail konfigurieren, können Sie die neuesten Ereignisse in der CloudTrail-Konsole in Event history(Ereignisverlauf) anzeigen. Mit den von CloudTrail gesammelten Informationen können Sie die an AWS IoTGreengrass gestellte Anfrage, die IP-Adresse, von der die Anfrage gestellt wurde, den Initiator der Anfrage,den Zeitpunkt der Anfrage und weitere Angaben bestimmen.

Weitere Informationen zu CloudTrail finden Sie im AWS CloudTrail User Guide.

AWS IoT Greengrass-Informationen in CloudTrailCloudTrail wird beim Erstellen Ihres AWS-Kontos für Sie aktiviert. Die in AWS IoT Greengrass auftretendenAktivitäten werden als CloudTrail-Ereignis zusammen mit anderen AWS-Serviceereignissen in Eventhistory (Ereignisverlauf) aufgezeichnet. Sie können die neusten Ereignisse in Ihrem AWS-Konto anzeigen,suchen und herunterladen. Weitere Informationen finden Sie unter Anzeigen von Ereignissen mit demCloudTrail-API-Ereignisverlauf.

Erstellen Sie für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS-Konto, darunter Ereignissefür AWS IoT Greengrass, einen Trail. Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateienan einen Amazon S3-Bucket. Wenn Sie einen Pfad in der Konsole anlegen, gilt dieser standardmäßigfür alle AWS-Regionen. Der Trail protokolliert Ereignisse aus allen Regionen in der AWS-Partition undstellt die Protokolldateien in dem Amazon S3-Bucket bereit, den Sie angeben. Darüber hinaus können Sieandere AWS-Services konfigurieren, um die in den CloudTrail-Protokollen erfassten Ereignisdaten weiterzu analysieren und entsprechend zu agieren. Weitere Informationen finden Sie unter:

• Übersicht zum Erstellen eines Pfads• In CloudTrail unterstützte Services und Integrationen• Konfigurieren von Amazon SNS-Benachrichtigungen für CloudTrail• Empfangen von CloudTrail-Protokolldateien aus mehreren Regionen und EmpfangenCloudTrail von

Protokolldateien aus mehreren Konten

Alle AWS IoT Greengrass-Aktionen werden von CloudTrail protokolliert und in der AWS IoTGreengrass-API-Referenz dokumentiert. Zum Beispiel werden durch Aufrufe der AktionenAssociateServiceRoleToAccount, GetGroupVersion, GetConnectivityInfo undCreateFunctionDefinition Einträge in den CloudTrail-Protokolldateien generiert.

Jedes Event oder jeder Protokolleintrag enthält Informationen über den Ersteller der Anfrage. Anhand derIdentitätsinformationen zur Benutzeridentität können Sie Folgendes bestimmen:

• Ob die Anfrage mit Root- oder AWS Identity and Access Management-Benutzeranmeldeinformationen(IAM) ausgeführt wurde.

• Ob die Anfrage mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen föderiertenBenutzer ausgeführt wurde.

• Ob die Anfrage von einem anderen AWS-Service getätigt wurde.

Weitere Informationen finden Sie unter CloudTrail-Element "userIdentity".

Grundlagen zu AWS IoT Greengrass-ProtokolldateieinträgenEin Trail ist eine Konfiguration, durch die Ereignisse an den von Ihnen angegebenen Amazon S3-Bucket übermittelt werden. CloudTrail-Protokolldateien können einen oder mehrere Einträge enthalten.

450

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/greengrass/latest/apireference/api-actions.html

https://docs.aws.amazon.com/greengrass/latest/apireference/api-actions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html

AWS IoT Greengrass EntwicklerhandbuchGrundlagen zu AWS IoT Greengrass-Protokolldateieinträgen

Ein Ereignis stellt eine einzelne Anfrage aus einer beliebigen Quelle dar und enthält unter anderemInformationen über die angeforderte Aktion, das Datum und die Uhrzeit der Aktion sowie über dieAnfrageparameter. CloudTrail-Protokolldateien sind kein geordnetes Stacktrace der öffentlichen API-Aufrufe und erscheinen daher nicht in einer bestimmten Reihenfolge.

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag, der die AktionAssociateServiceRoleToAccount demonstriert.

{ "eventVersion": "1.05", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::123456789012:user/Mary_Major", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Mary_Major" }, "eventTime": "2018-10-17T17:04:02Z", "eventSource": "greengrass.amazonaws.com", "eventName": "AssociateServiceRoleToAccount", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.12", "userAgent": "apimanager.amazonaws.com", "errorCode": "BadRequestException", "requestParameters": null, "responseElements": { "Message": "That role ARN is invalid." }, "requestID": "a5990ec6-d22e-11e8-8ae5-c7d2eEXAMPLE", "eventID": "b9070ce2-0238-451a-a9db-2dbf1EXAMPLE", "readOnly": false, "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag, der die Aktion GetGroupVersiondemonstriert.

{ "eventVersion": "1.05", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::123456789012:user/Mary_Major", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Mary_Major", "sessionContext": { "attributes": { "mfaAuthenticated": "false", "creationDate": "2018-10-17T18:14:57Z" } }, "invokedBy": "apimanager.amazonaws.com" }, "eventTime": "2018-10-17T18:15:11Z", "eventSource": "greengrass.amazonaws.com", "eventName": "GetGroupVersion", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.12", "userAgent": "apimanager.amazonaws.com", "requestParameters": {

451

AWS IoT Greengrass EntwicklerhandbuchGrundlagen zu AWS IoT Greengrass-Protokolldateieinträgen

"GroupVersionId": "6c477753-dbf2-4cb8-acc3-5ba4eEXAMPLE", "GroupId": "90fcf6df-413c-4515-93a8-00056EXAMPLE" }, "responseElements": null, "requestID": "95dcffce-d238-11e8-9240-a3993EXAMPLE", "eventID": "8a608034-82ed-431b-b5e0-87fbdEXAMPLE", "readOnly": true, "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag, der die Aktion GetConnectivityInfodemonstriert.

{ "eventVersion": "1.05", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::123456789012:user/Mary_Major", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Mary_Major" }, "eventTime": "2018-10-17T17:02:12Z", "eventSource": "greengrass.amazonaws.com", "eventName": "GetConnectivityInfo", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.12", "userAgent": "apimanager.amazonaws.com", "requestParameters": { "ThingName": "us-east-1_CIS_1539795000000_" }, "responseElements": null, "requestID": "63e3ebe3-d22e-11e8-9ddd-5baf3EXAMPLE", "eventID": "db2260d1-a8cc-4a65-b92a-13f65EXAMPLE", "readOnly": true, "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag, der die AktionCreateFunctionDefinition demonstriert.

{ "eventVersion": "1.05", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::123456789012:user/Mary_Major", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Mary_Major" }, "eventTime": "2018-10-17T18:01:11Z", "eventSource": "greengrass.amazonaws.com", "eventName": "CreateFunctionDefinition", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.12", "userAgent": "apimanager.amazonaws.com", "requestParameters": { "InitialVersion": "***" },

452

AWS IoT Greengrass EntwicklerhandbuchCloudTrail-Protokolle

"responseElements": { "CreationTimestamp": "2018-10-17T18:01:11.449Z", "LatestVersion": "dae06a61-c32c-41e9-b983-ee5cfEXAMPLE", "LatestVersionArn": "arn:aws:greengrass:us-east-1:123456789012:/greengrass/definition/functions/7a94847d-d4d2-406c-9796-a3529EXAMPLE/versions/dae06a61-c32c-41e9-b983-ee5cfEXAMPLE", "LastUpdatedTimestamp": "2018-10-17T18:01:11.449Z", "Id": "7a94847d-d4d2-406c-9796-a3529EXAMPLE", "Arn": "arn:aws:greengrass:us-east-1:123456789012:/greengrass/definition/functions/7a94847d-d4d2-406c-9796-a3529EXAMPLE" }, "requestID": "a17d4b96-d236-11e8-a74e-3db27EXAMPLE", "eventID": "bdbf6677-a47a-4c78-b227-c5f64EXAMPLE", "readOnly": false, "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

CloudTrail-ProtokolleAWS IoT Greengrass ist in AWS CloudTrail integriert, einen Service, der die Aktionen eines Benutzers,einer Rolle oder eines AWS-Service in AWS IoT Greengrass protokolliert. Weitere Informationenfinden Sie unter the section called “Protokollieren von AWS IoT Greengrass-API-Aufrufen mit AWSCloudTrail” (p. 449).

453

AWS IoT Greengrass EntwicklerhandbuchGrundlagen zu Tags

Markieren Ihrer AWS IoTGreengrass-Ressourcen

Mit Tags können Sie Ihre AWS IoT Greengrass-Gruppen organisieren und verwalten. Sie können mit TagsGruppen und Massenbereitstellungen und den Cores, Geräten sowie anderen Ressourcen, die Gruppenhinzugefügt werden, Metadaten zuzuweisen. Tags können auch in IAM-Richtlinien verwendet werden, umbedingten Zugriff auf Ihre Greengrass-Ressourcen zu definieren.

Note

Derzeit werden Greengrass-Ressourcen-Tags nicht für die AWS IoT-Fakturierungsgruppen oderKostenzuordnungsberichte unterstützt.

Grundlagen zu TagsMit Tags können Sie Ihre AWS IoT Greengrass-Ressourcen kategorisieren (z. B. nach Zweck, Eigentümerund Umgebung). Wenn viele Ressourcen desselben Typs vorhanden sind, können Sie basierend auf denangefügten Tags schnell bestimmte Ressourcen identifizieren. Ein Tag besteht aus einem Schlüssel undeinem optionalen Wert. Beides können Sie bestimmen. Wir empfehlen die Verwendung von Tag-Schlüsselnfür den jeweiligen Ressourcentyp. Eine Anzahl einheitlicher Tag-Schlüssel vereinfacht das Verwalten derRessourcen. Sie können zum Beispiel eine Reihe von Tags für Ihre Gruppen definieren, mit denen Sie denFabrikstandort Ihrer Core-Geräte verfolgen können. Weitere Informationen finden Sie unter AWS Tagging-Strategien.

Markierungsunterstützung in der AWS IoTGreengrass-APISie müssen Tags für AWS IoT Greengrass-Ressourcen, die Markierung unterstützen, mit der AWS IoTGreengrass-API erstellen und verwalten.

• Wenn Sie Tags während der Ressourcenerstellung hinzufügen möchten, definieren Sie sie in der tags-Eigenschaft der Ressource.

• Mit der TagResource-Aktion können Sie Tags nach der Erstellung einer Ressource hinzuzufügen oderTag-Werte aktualisieren.

• Sie können Tags mit der UntagResource-Aktion aus einer Ressource entfernen.• Sie können Tags, die einer Ressource zugeordnet sind, mit der ListTagsForResource-Aktion abrufen

oder die Ressource abrufen und sich deren tags-Eigenschaft ansehen.

In der folgenden Tabelle sind die Ressourcen aufgeführt, die Sie in der AWS IoT Greengrass-APImarkieren können. Außerdem finden Sie die entsprechenden Get- und Create-Aktionen.

Ressource Erstellen Get

Group CreateGroup GetGroup

454

https://aws.amazon.com/answers/account-management/aws-tagging-strategies

https://aws.amazon.com/answers/account-management/aws-tagging-strategies

https://docs.aws.amazon.com/greengrass/latest/apireference/creategroup-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getgroup-get.html

AWS IoT Greengrass EntwicklerhandbuchVerwenden von Tags mit IAM-Richtlinien

Ressource Erstellen Get

ConnectorDefinition CreateConnectorDefinition GetConnectorDefinition

CoreDefinition CreateCoreDefinition GetCoreDefinition

DeviceDefinition CreateDeviceDefinition GetDeviceDefinition

FunctionDefinition CreateFunctionDefinition GetFunctionDefinition

LoggerDefinition CreateLoggerDefinition GetLoggerDefinition

ResourceDefinition CreateResourceDefinition GetResourceDefinition

SubscriptionDefinition CreateSubscriptionDefinitionGetSubscriptionDefinition

BulkDeployment StartBulkDeployment GetBulkDeploymentStatus

Sie können Tags für Ressourcen, die Tagging unterstützen, mit den folgenden Aktionen aufführen undverwalten:

• TagResource. Fügt einer Ressource Tags hinzu. Diese werden auch dazu verwendet, den Wert desSchlüssel-Wert-Paars des Tags zu ändern.

• ListTagsForResource. Führt die Tags für eine Ressource auf.• UntagResource. Entfernt Tags aus einer Ressource.

Sie können die Tags einer Ressource jederzeit hinzufügen, entfernen oder ändern. Wenn Sie den Werteines Tag-Schlüssels ändern möchten, fügen Sie der Ressource, die denselben Schlüssel und den neuenWert definiert, ein Tag hinzu. Der neue Wert überschreibt den alten Wert. Sie können einen Wert zwar aufeine leere Zeichenfolge, jedoch nicht Null festlegen.

Wenn Sie eine Ressource löschen, werden die der Ressource zugeordneten Tags ebenfalls gelöscht.

Note

Verwechseln Sie Ressourcen-Tags nicht mit den Attributen, die Sie AWS IoT-Objekten zuweisenkönnen. Obwohl es sich bei Greengrass-Cores um AWS IoT-Objekte handelt, werden die indiesem Thema beschriebenen Ressourcen-Tags dem CoreDefinition- und nicht dem Core-Objekt angefügt.

Verwenden von Tags mit IAM-RichtlinienSie können in Ihren IAM-Richtlinien Ressourcen-Tags verwenden, um den Zugriff und die Berechtigungenvon Benutzern zu steuern. Beispielsweise können Richtlinien Benutzern erlauben, nur die Ressourcenzu erstellen, die einen spezifisches Tag aufweisen. Richtlinien können auch verhindern, dass BenutzerRessourcen mit bestimmten Tags erstellen oder ändern. Sie können Ressourcen während derErstellung markieren (dies wird als Markierung bei Erstellung bezeichnet). Dadurch müssen Sie späterkeine benutzerdefinierten Skripts ausführen. Beim Start neuer Umgebungen mit Tags werden dieentsprechenden IAM-Berechtigungen automatisch angewendet.

Die folgenden Bedingungskontextschlüssel und -werte können im Condition-Element (auch alsCondition-Block bezeichnet) der Richtlinie verwendet werden.

greengrass:ResourceTag/tag-key: tag-value

Sie können Benutzeraktionen bei Ressourcen mit bestimmten Tags gestatten oder verweigern.

455

https://docs.aws.amazon.com/greengrass/latest/apireference/createconnectordefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getconnectordefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createcoredefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getcoredefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createdevicedefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getdevicedefinition-get.html


https://docs.aws.amazon.com/greengrass/latest/apireference/getfunctiondefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createloggerdefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getloggerdefinition-get.html


https://docs.aws.amazon.com/greengrass/latest/apireference/getresourcedefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/createsubscriptiondefinition-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getsubscriptiondefinition-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/startbulkdeployment-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getbulkdeploymentstatus-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/tagresource-post.html

https://docs.aws.amazon.com/greengrass/latest/apireference/listtagsforresource-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/untagresource-delete.html

AWS IoT Greengrass EntwicklerhandbuchIAM-Beispielrichtlinien

aws:RequestTag/tag-key: tag-value

Sie können verlangen, dass ein bestimmter Tag verwendet wird (oder nicht), wenn Sie API-Anforderungen zum Erstellen oder Ändern von Tags bei einer markierbaren Ressource durchführen.

aws:TagKeys: [tag-key, ...]

Sie können verlangen, dass ein bestimmter Satz mit Tag-Schlüsseln verwendet wird (oder nicht), wenneine API-Anforderung zum Erstellen oder Ändern einer markierbaren Ressource durchgeführt wird.

Bedingungskontextschlüssel und -werte können nur mit AWS IoT Greengrass-Aktionen verwendet werden,die bei einer markierbaren Ressource ausgeführt werden. Diese Aktionen nehmen die Ressource alseinen erforderlicher Parameter an. Sie können beispielsweise bedingten Zugriff auf GetGroupVersionfestlegen. Sie können keinen bedingten Zugriff auf AssociateServiceRoleToAccount festlegen,da keine markierbare Ressource (z. B. Gruppe, Core-Definition oder Gerätedefinition) in der Anfrageverwiesen wird.

Weitere Informationen finden Sie unter Zugriffssteuerung mit Tags und der IAM JSON-Richtlinienreferenzim IAM-Benutzerhandbuch. Die JSON-Richtlinienreferenz enthält detaillierte Syntax, Beschreibungen undBeispiele für die Elemente, Variablen und Auswertungslogik von JSON-Richtlinien in IAM.

IAM-BeispielrichtlinienIn der folgenden Beispielrichtlinie werden Tag-basierte Berechtigungen angewendet, mit denen dieAktionen eines Beta-Benutzers nur auf Beta-Ressourcen eingeschränkt werden.

• Mit der ersten Anweisung kann ein IAM-Benutzer Ressourcen mit nur dem env = Beta-Tag nutzen.• Die zweite Anweisung verhindert, dass ein IAM-Benutzer den env = Beta-Tag von Ressourcen entfernt.

Dadurch wird sichergestellt, dass der Benutzer nicht seinen eigenen Zugriff entfernt.

Note

Wenn Sie den Zugriff auf Ressourcen über Tags steuern, sollten Sie auch die Berechtigungenverwalten, mit denen Benutzer diesen Ressourcen Tags hinzuzufügen oder davon entfernenkönnen. Andernfalls können Benutzer in einigen Fällen möglicherweise Ihre Einschränkungenumgehen und sich Zugriff auf eine Ressource verschaffen, indem sie ihre Tags modifizieren.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "greengrass:*", "Resource": "*", "Condition": { "StringEquals": { "greengrass:ResourceTag/env": "beta" } } }, { "Effect": "Deny", "Action": "greengrass:UntagResource", "Resource": "*", "Condition": { "StringEquals": { "aws:ResourceTag/env": "beta" } }

456

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html

AWS IoT Greengrass EntwicklerhandbuchTag-Einschränkungen

} ]}

Damit Benutzer eine Markierung bei Erstellung durchführen können, müssen Sie Ihnen die erforderlichenBerechtigungen erteilen. Die folgende Beispielrichtlinie enthält die "aws:RequestTag/env": "beta"-Bedingung für die Aktionen greengrass:CreateGroup und greengrass:TagResource, mit denenBenutzer nur dann eine Gruppe erstellen können, wenn sie die Gruppe mit env = beta markieren. Damitwird erreicht, dass Benutzer neue Gruppen markieren müssen.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "greengrass:TagResource", "Resource": "*", "Condition": { "StringEquals": { "aws:RequestTag/env": "beta" } } }, { "Effect": "Allow", "Action": "greengrass:CreateGroup", "Resource": "*", "Condition": { "StringEquals": { "aws:RequestTag/env": "beta" } } } ]}

Im folgenden Ausschnitt wird dargestellt, wie Sie auch mehrere Tag-Werte für einen Tag-Schlüsselangeben können, indem Sie sie in einer Liste angeben:

"StringEquals" : { "greengrass:ResourceTag/env" : ["dev", "test"]}

Tag-EinschränkungenDie folgenden allgemeinen Einschränkungen gelten für Tags:

• Die maximale Anzahl an Tags pro Ressource beträgt 50.• Die maximale Schlüssellänge beträgt 127 Unicode-Zeichen in UTF-8.• Die maximale Wertelänge beträgt 255 Unicode-Zeichen in UTF-8.• Bei Tag-Schlüsseln und -Werten muss die Groß-/Kleinschreibung beachtet werden.• Verwenden Sie in Tag-Namen oder Werten nicht das Präfix aws:, da es für die AWS-Verwendung

reserviert ist. Sie können keine Tag-Namen oder Werte bearbeiten oder löschen, die diesen Präfixverwenden. Tags mit diesem Präfix werden nicht als Ihre Tags pro Ressourcenlimit angerechnet.

• Wenn Ihr Markierungsschema für mehrere Services und Ressourcen verwendet wird, denken Sie daran,dass die zulässigen Zeichen bei andere Services möglicherweise eingeschränkt sind. Generell sind

457

AWS IoT Greengrass EntwicklerhandbuchTag-Einschränkungen

Buchstaben, Leerzeichen und Zahlen, die in UTF-8 darstellbar sind, sowie die folgenden Sonderzeichenerlaubt: + - = . _ : / @

458

AWS IoT Greengrass EntwicklerhandbuchErstellen von Ressourcen

AWS CloudFormation-Unterstützungfür AWS IoT Greengrass

AWS CloudFormation ist ein Service, mit dessen Hilfe Sie Ihre AWS-Ressourcen erstellen, verwaltenund replizieren können. Mit AWS CloudFormation-Vorlagen können Sie AWS IoT Greengrass-Gruppensowie die Geräte, Abonnements und anderen Komponenten, die Sie bereitstellen möchten, definieren. EinBeispiel finden Sie unter the section called “Beispielvorlage” (p. 460).

Die Ressourcen und Infrastruktur, die Sie aus einer Vorlage generieren, wird als Stack bezeichnet.Sie können alle Ihre Ressourcen in einer Vorlage definieren oder auf Ressourcen von anderen Stacksverweisen. Weitere Informationen zu AWS CloudFormation-Vorlagen und -Funktionen finden Sie unter Wasist AWS CloudFormation? im AWS CloudFormation-Benutzerhandbuch.

Derzeit können Sie nur in den folgenden AWS-Regionen AWS IoT Greengrass-Ressourcen erstellen undverwalten:

• USA Ost (Nord-Virginia)• USA West (Oregon)• Asien-Pazifik (Sydney)• Asien-Pazifik (Tokio)• EU (Frankfurt)• EU (Irland)

Erstellen von RessourcenBei AWS CloudFormation-Vorlagen handelt es sich um JSON- oder YAML-Dokumente, in denen dieEigenschaften und Beziehungen von AWS-Ressourcen beschrieben werden. Folgende AWS IoTGreengrass-Ressourcen werden unterstützt:

• Gruppen• Kerne• Geräte• Lambda-Funktionen• Konnektoren• Ressourcen (lokal, Machine Learning und geheime Schlüssel)• Abonnements• Logger (Protokollierungskonfigurationen)

Die Struktur und Syntax von Greengrass-Ressourcen basieren in AWS CloudFormation-Vorlagenauf der AWS IoT Greengrass-API. Beispiel: Die Beispielvorlage (p. 460) weist eine allgemeineDeviceDefinition einem DeviceDefinitionVersion mit einem einzelnen Gerät zu. WeitereInformationen finden Sie in der AWS IoT Greengrass-Ressourcentypenreferenz in der AWSCloudFormation-Benutzerhandbuch.

Wenn Sie AWS CloudFormation-Vorlagen verwenden, um AWS-Ressourcen zu erstellen, empfehlen wir,dass Sie sie nur aus AWS CloudFormation verwalten. Beispielsweise sollten Sie Ihre Vorlage aktualisieren,wenn Sie ein Gerät mithilfe der AWS IoT Greengrass-API (und nicht mit der AWS IoT-Konsole) hinzufügen,ändern oder entfernen möchten. Auf diese Weise können Sie Rollback und andere Funktionen der AWSCloudFormation-Änderungsverwaltung verwenden. Weitere Informationen zur Verwendung von AWS

459

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Greengrass.html

AWS IoT Greengrass EntwicklerhandbuchRessourcen bereitstellen

CloudFormation zum Erstellen und Verwalten Ihrer Ressourcen und Stapel finden Sie unter Arbeiten mitStacks in der AWS CloudFormation-Benutzerhandbuch.

Eine Schritt-für-Schritt-Anleitung zum Erstellen und Bereitstellen von AWS IoT Greengrass Ressourcenin einer AWS CloudFormation Vorlage finden Sie im offiziellen Blog unter Automatisierung AWS IoTGreengrass Einrichten mit AWS CloudFormation Das Internet der Dinge in AWS.

Bereitstellen von RessourcenNachdem Sie einen AWS CloudFormation-Stack mit Ihrer Gruppenversion erstellt haben, können Sie ihnmit der AWS CLI oder mit AWS IoT-Konsole bereitstellen.

Note

Wenn Sie eine Gruppe bereitstellen, benötigen Sie eine mit Ihrem AWS-Konto verknüpfteGreengrass-Servicerolle. Die Servicerolle ermöglicht AWS IoT Greengrass den Zugriff auf IhreRessourcen in AWS Lambda und anderen AWS-Services. Diese Rolle sollte vorhanden sein,wenn Sie bereits eine Greengrass-Gruppe in der aktuellen AWS-Region bereitgestellt haben.Weitere Informationen finden Sie unter the section called “Greengrass-Servicerolle” (p. 432).

So stellen Sie die Gruppe bereit (AWS CLI)

• Führen Sie den Befehl create-deployment aus.

aws greengrass create-deployment --group-id GroupId --group-version-id GroupVersionId --deployment-type NewDeployment

Note

Die CommandToDeployGroup -Anweisung in der Beispielvorlage (p. 460) zeigt, wieSie den Befehl bei Stack-Erstellung mit Ihrer Gruppe und den Gruppenversions-IDsausgeben.

So stellen Sie die Gruppe bereit (Konsole)

1. Wählen Sie in der AWS IoT-Konsole die Option Greengrass und dann Groups (Gruppen) aus.2. Wählen Sie Ihre Gruppe aus.3. Wählen Sie auf der Gruppenkonfigurationsseite unter Actions (Aktionen) die Option Deploy

(Bereitstellen) aus.

Hiermit wird die Gruppenkonfiguration für Ihr AWS IoT Greengrass-Core-Gerät bereitgestellt. Hilfezur Problembehebung finden Sie unter Fehlersuche (p. 500).

BeispielvorlageMit der folgenden Beispielvorlage wird eine Greengrass-Gruppe erstellt, die einen Core, ein Gerät, eineFunktion, einen Logger, ein Abonnement und zwei Ressourcen enthält. Die Vorlage folgt dazu dem

460

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html

https://aws.amazon.com/blogs/iot/automating-aws-iot-greengrass-setup-with-aws-cloudformation/

https://aws.amazon.com/blogs/iot/automating-aws-iot-greengrass-setup-with-aws-cloudformation/

https://docs.aws.amazon.com/greengrass/latest/apireference/createdeployment-post.html

AWS IoT Greengrass EntwicklerhandbuchBeispielvorlage

Objektmodell der AWS IoT Greengrass-API. Beispiel: Die Geräte, die Sie der Gruppe hinzufügen möchten,sind in einer DeviceDefinitionVersion-Ressource enthalten, die einer DeviceDefinition-Ressource zugeordnet ist. Wenn Sie der Gruppe die Geräte hinzufügen möchten, verweist dieGruppenversion auf den ARN von DeviceDefinitionVersion.

Die Vorlage enthält Parameter, mit denen Sie die Zertifikats-ARNs für die Core- und Geräte- und Versions-ARN der Quell- Lambda-Funktion angeben können (dabei handelt es sich um eine AWS Lambda-Ressource). In der Vorlage werden die intrinsischen Funktionen GetAtt und Ref verwendet, um auf IDs,ARNs sowie andere Attribute zu verweisen, die zum Erstellen von Greengrass-Ressourcen erforderlichsind.

Die Vorlage definiert auch zwei AWS IoT-Geräte (Objekte), mit denen der Core und das Gerät dargestelltwerden, die der Greengrass-Gruppe hinzugefügt werden.

Nach der Stack-Erstellung mit Ihren Greengrass-Ressourcen ist die Gruppenbereitstellung (p. 460) überdie AWS CLI oder die AWS IoT-Konsole möglich.

Note

Die CommandToDeployGroup-Anweisung im Beispiel zeigt, wie Sie einen kompletten create-deployment-CLI-Befehl ausgeben, mit dem Sie Ihre Gruppe bereitstellen können.

JSON

{ "AWSTemplateFormatVersion": "2010-09-09", "Description": "AWS IoT Greengrass example template that creates a group version with a core, device, function, logger, subscription, and resources.", "Parameters": { "CoreCertificateArn": { "Type": "String" }, "DeviceCertificateArn": { "Type": "String" }, "LambdaVersionArn": { "Type": "String" } }, "Resources": { "TestCore1": { "Type": "AWS::IoT::Thing", "Properties": { "ThingName": "TestCore1" } }, "TestCoreDefinition": { "Type": "AWS::Greengrass::CoreDefinition", "Properties": { "Name": "DemoTestCoreDefinition" } }, "TestCoreDefinitionVersion": { "Type": "AWS::Greengrass::CoreDefinitionVersion", "Properties": { "CoreDefinitionId": { "Ref": "TestCoreDefinition" }, "Cores": [ { "Id": "TestCore1", "CertificateArn": { "Ref": "CoreCertificateArn"

461


}, "SyncShadow": "false", "ThingArn": { "Fn::Join": [ ":", [ "arn:aws:iot", { "Ref": "AWS::Region" }, { "Ref": "AWS::AccountId" }, "thing/TestCore1" ] ] } } ] } }, "TestDevice1": { "Type": "AWS::IoT::Thing", "Properties": { "ThingName": "TestDevice1" } }, "TestDeviceDefinition": { "Type": "AWS::Greengrass::DeviceDefinition", "Properties": { "Name": "DemoTestDeviceDefinition" } }, "TestDeviceDefinitionVersion": { "Type": "AWS::Greengrass::DeviceDefinitionVersion", "Properties": { "DeviceDefinitionId": { "Fn::GetAtt": [ "TestDeviceDefinition", "Id" ] }, "Devices": [ { "Id": "TestDevice1", "CertificateArn": { "Ref": "DeviceCertificateArn" }, "SyncShadow": "true", "ThingArn": { "Fn::Join": [ ":", [ "arn:aws:iot", { "Ref": "AWS::Region" }, { "Ref": "AWS::AccountId" }, "thing/TestDevice1" ] ] } } ]

462


} }, "TestFunctionDefinition": { "Type": "AWS::Greengrass::FunctionDefinition", "Properties": { "Name": "DemoTestFunctionDefinition" } }, "TestFunctionDefinitionVersion": { "Type": "AWS::Greengrass::FunctionDefinitionVersion", "Properties": { "FunctionDefinitionId": { "Fn::GetAtt": [ "TestFunctionDefinition", "Id" ] }, "DefaultConfig": { "Execution": { "IsolationMode": "GreengrassContainer" } }, "Functions": [ { "Id": "TestLambda1", "FunctionArn": { "Ref": "LambdaVersionArn" }, "FunctionConfiguration": { "Pinned": "true", "Executable": "run.exe", "ExecArgs": "argument1", "MemorySize": "512", "Timeout": "2000", "EncodingType": "binary", "Environment": { "Variables": { "variable1": "value1" }, "ResourceAccessPolicies": [ { "ResourceId": "ResourceId1", "Permission": "ro" }, { "ResourceId": "ResourceId2", "Permission": "rw" } ], "AccessSysfs": "false", "Execution": { "IsolationMode": "GreengrassContainer", "RunAs": { "Uid": "1", "Gid": "10" } } } } } ] } }, "TestLoggerDefinition": { "Type": "AWS::Greengrass::LoggerDefinition", "Properties": {

463


"Name": "DemoTestLoggerDefinition" } }, "TestLoggerDefinitionVersion": { "Type": "AWS::Greengrass::LoggerDefinitionVersion", "Properties": { "LoggerDefinitionId": { "Ref": "TestLoggerDefinition" }, "Loggers": [ { "Id": "TestLogger1", "Type": "AWSCloudWatch", "Component": "GreengrassSystem", "Level": "INFO" } ] } }, "TestResourceDefinition": { "Type": "AWS::Greengrass::ResourceDefinition", "Properties": { "Name": "DemoTestResourceDefinition" } }, "TestResourceDefinitionVersion": { "Type": "AWS::Greengrass::ResourceDefinitionVersion", "Properties": { "ResourceDefinitionId": { "Ref": "TestResourceDefinition" }, "Resources": [ { "Id": "ResourceId1", "Name": "LocalDeviceResource", "ResourceDataContainer": { "LocalDeviceResourceData": { "SourcePath": "/dev/TestSourcePath1", "GroupOwnerSetting": { "AutoAddGroupOwner": "false", "GroupOwner": "TestOwner" } } } }, { "Id": "ResourceId2", "Name": "LocalVolumeResourceData", "ResourceDataContainer": { "LocalVolumeResourceData": { "SourcePath": "/dev/TestSourcePath2", "DestinationPath": "/volumes/TestDestinationPath2", "GroupOwnerSetting": { "AutoAddGroupOwner": "false", "GroupOwner": "TestOwner" } } } } ] } }, "TestSubscriptionDefinition": { "Type": "AWS::Greengrass::SubscriptionDefinition", "Properties": { "Name": "DemoTestSubscriptionDefinition"

464


} }, "TestSubscriptionDefinitionVersion": { "Type": "AWS::Greengrass::SubscriptionDefinitionVersion", "Properties": { "SubscriptionDefinitionId": { "Ref": "TestSubscriptionDefinition" }, "Subscriptions": [ { "Id": "TestSubscription1", "Source": { "Fn::Join": [ ":", [ "arn:aws:iot", { "Ref": "AWS::Region" }, { "Ref": "AWS::AccountId" }, "thing/TestDevice1" ] ] }, "Subject": "TestSubjectUpdated", "Target": { "Ref": "LambdaVersionArn" } } ] } }, "TestGroup": { "Type": "AWS::Greengrass::Group", "Properties": { "Name": "DemoTestGroupNewName", "RoleArn": { "Fn::Join": [ ":", [ "arn:aws:iam:", { "Ref": "AWS::AccountId" }, "role/TestUser" ] ] }, "InitialVersion": { "CoreDefinitionVersionArn": { "Ref": "TestCoreDefinitionVersion" }, "DeviceDefinitionVersionArn": { "Ref": "TestDeviceDefinitionVersion" }, "FunctionDefinitionVersionArn": { "Ref": "TestFunctionDefinitionVersion" }, "SubscriptionDefinitionVersionArn": { "Ref": "TestSubscriptionDefinitionVersion" }, "LoggerDefinitionVersionArn": { "Ref": "TestLoggerDefinitionVersion" },

465


"ResourceDefinitionVersionArn": { "Ref": "TestResourceDefinitionVersion" } } } } }, "Outputs": { "CommandToDeployGroup": { "Value": { "Fn::Join": [ " ", [ "groupVersion=$(cut -d'/' -f6 <<<", { "Fn::GetAtt": [ "TestGroup", "LatestVersionArn" ] }, ");", "aws --region", { "Ref": "AWS::Region" }, "greengrass create-deployment --group-id", { "Ref": "TestGroup" }, "--deployment-type NewDeployment --group-version-id", "$groupVersion" ] ] } } }}

YAML

AWSTemplateFormatVersion: 2010-09-09Description: >- AWS IoT Greengrass example template that creates a group version with a core, device, function, logger, subscription, and resources.Parameters: CoreCertificateArn: Type: String DeviceCertificateArn: Type: String LambdaVersionArn: Type: StringResources: TestCore1: Type: 'AWS::IoT::Thing' Properties: ThingName: TestCore1 TestCoreDefinition: Type: 'AWS::Greengrass::CoreDefinition' Properties: Name: DemoTestCoreDefinition TestCoreDefinitionVersion: Type: 'AWS::Greengrass::CoreDefinitionVersion' Properties: CoreDefinitionId: !Ref TestCoreDefinition Cores:

466


- Id: TestCore1 CertificateArn: !Ref CoreCertificateArn SyncShadow: 'false' ThingArn: !Join - ':' - - 'arn:aws:iot' - !Ref 'AWS::Region' - !Ref 'AWS::AccountId' - thing/TestCore1 TestDevice1: Type: 'AWS::IoT::Thing' Properties: ThingName: TestDevice1 TestDeviceDefinition: Type: 'AWS::Greengrass::DeviceDefinition' Properties: Name: DemoTestDeviceDefinition TestDeviceDefinitionVersion: Type: 'AWS::Greengrass::DeviceDefinitionVersion' Properties: DeviceDefinitionId: !GetAtt - TestDeviceDefinition - Id Devices: - Id: TestDevice1 CertificateArn: !Ref DeviceCertificateArn SyncShadow: 'true' ThingArn: !Join - ':' - - 'arn:aws:iot' - !Ref 'AWS::Region' - !Ref 'AWS::AccountId' - thing/TestDevice1 TestFunctionDefinition: Type: 'AWS::Greengrass::FunctionDefinition' Properties: Name: DemoTestFunctionDefinition TestFunctionDefinitionVersion: Type: 'AWS::Greengrass::FunctionDefinitionVersion' Properties: FunctionDefinitionId: !GetAtt - TestFunctionDefinition - Id DefaultConfig: Execution: IsolationMode: GreengrassContainer Functions: - Id: TestLambda1 FunctionArn: !Ref LambdaVersionArn FunctionConfiguration: Pinned: 'true' Executable: run.exe ExecArgs: argument1 MemorySize: '512' Timeout: '2000' EncodingType: binary Environment: Variables: variable1: value1 ResourceAccessPolicies: - ResourceId: ResourceId1 Permission: ro - ResourceId: ResourceId2 Permission: rw AccessSysfs: 'false' Execution:

467


IsolationMode: GreengrassContainer RunAs: Uid: '1' Gid: '10' TestLoggerDefinition: Type: 'AWS::Greengrass::LoggerDefinition' Properties: Name: DemoTestLoggerDefinition TestLoggerDefinitionVersion: Type: 'AWS::Greengrass::LoggerDefinitionVersion' Properties: LoggerDefinitionId: !Ref TestLoggerDefinition Loggers: - Id: TestLogger1 Type: AWSCloudWatch Component: GreengrassSystem Level: INFO TestResourceDefinition: Type: 'AWS::Greengrass::ResourceDefinition' Properties: Name: DemoTestResourceDefinition TestResourceDefinitionVersion: Type: 'AWS::Greengrass::ResourceDefinitionVersion' Properties: ResourceDefinitionId: !Ref TestResourceDefinition Resources: - Id: ResourceId1 Name: LocalDeviceResource ResourceDataContainer: LocalDeviceResourceData: SourcePath: /dev/TestSourcePath1 GroupOwnerSetting: AutoAddGroupOwner: 'false' GroupOwner: TestOwner - Id: ResourceId2 Name: LocalVolumeResourceData ResourceDataContainer: LocalVolumeResourceData: SourcePath: /dev/TestSourcePath2 DestinationPath: /volumes/TestDestinationPath2 GroupOwnerSetting: AutoAddGroupOwner: 'false' GroupOwner: TestOwner TestSubscriptionDefinition: Type: 'AWS::Greengrass::SubscriptionDefinition' Properties: Name: DemoTestSubscriptionDefinition TestSubscriptionDefinitionVersion: Type: 'AWS::Greengrass::SubscriptionDefinitionVersion' Properties: SubscriptionDefinitionId: !Ref TestSubscriptionDefinition Subscriptions: - Id: TestSubscription1 Source: !Join - ':' - - 'arn:aws:iot' - !Ref 'AWS::Region' - !Ref 'AWS::AccountId' - thing/TestDevice1 Subject: TestSubjectUpdated Target: !Ref LambdaVersionArn TestGroup: Type: 'AWS::Greengrass::Group' Properties: Name: DemoTestGroupNewName RoleArn: !Join

468


- ':' - - 'arn:aws:iam:' - !Ref 'AWS::AccountId' - role/TestUser InitialVersion: CoreDefinitionVersionArn: !Ref TestCoreDefinitionVersion DeviceDefinitionVersionArn: !Ref TestDeviceDefinitionVersion FunctionDefinitionVersionArn: !Ref TestFunctionDefinitionVersion SubscriptionDefinitionVersionArn: !Ref TestSubscriptionDefinitionVersion LoggerDefinitionVersionArn: !Ref TestLoggerDefinitionVersion ResourceDefinitionVersionArn: !Ref TestResourceDefinitionVersionOutputs: CommandToDeployGroup: Value: !Join - ' ' - - groupVersion=$(cut -d'/' -f6 <<< - !GetAtt - TestGroup - LatestVersionArn - ); - aws --region - !Ref 'AWS::Region' - greengrass create-deployment --group-id - !Ref TestGroup - '--deployment-type NewDeployment --group-version-id' - $groupVersion

469


Verwendung des AWS IoT DeviceTesters für AWS IoT Greengrass

Sie können den AWS IoT Device Tester (IDT) für AWS IoT Greengrass verwenden, um zu überprüfen,ob die AWS IoT Greengrass Core-Software auf Ihrer Hardware ausgeführt wird und mit der AWS IoT-Cloud kommunizieren kann. Außerdem werden End-to-End-Tests mit AWS IoT-Kern ausgeführt. So wirdbeispielsweise überprüft, ob Ihr Gerät MQTT-Nachrichten senden und empfangen und korrekt verarbeitenkann. IDT für AWS IoT Greengrass generiert Prüfberichte, die Sie an das AWS IoT senden können, umIhre Hardware in den AWS Partner Device Catalog aufzunehmen. Weitere Informationen finden Sie unterAWS Gerätequalifizierungsprogramm.

IDT für AWS IoT Greengrass läuft auf Ihrem Host-Computer (Windows, macOS oder Linux), der mit demzu testenden Gerät verbunden ist. Er führt Tests durch und fasst die Ergebnisse zusammen. Er bietet aucheine Befehlszeilenschnittstelle zur Verwaltung der Testprozesse.

Zusätzlich zum Testen von Geräten erstellt IDT für AWS IoT Greengrass Ressourcen (z. B. AWS IoTObjekte, AWS IoT Greengrass-Gruppen, Lambda-Funktionen und so weiter), um den Qualifikationsprozesszu erleichtern.

Um diese Ressourcen zu erstellen, verwendet IDT für AWS IoT Greengrass die AWS-Anmeldeinformationen, die in config.json konfiguriert sind, um API-Aufrufe in Ihrem Namendurchzuführen. Diese Ressourcen werden zu verschiedenen Zeiten während eines Tests bereitgestellt.

Wenn Sie IDT für AWS IoT Greengrass auf Ihrem Host-Computer ausführen, führt er die folgenden Schritteaus:

1. Laden und überprüfen Sie die Konfiguration Ihres Geräts und Ihrer Anmeldeinformationen.2. Führen Sie ausgewählte Tests mit den erforderlichen lokalen und Cloud-Ressourcen durch.3. Bereinigen Sie lokale und Cloud-Ressourcen.4. Erstellt Testberichte, die anzeigen, ob Ihr Board die für die Qualifikation erforderlichen Tests bestanden

hat.

470

https://aws.amazon.com/partners/dqp/

AWS IoT Greengrass EntwicklerhandbuchAWS IoT Device Tester für AWS IoT Greengrass-Versionen

IDT für AWS IoT Greengrass organisiert Tests mit den Konzepten einer Testsuite und Testgruppen.

Die Testsuite ist die Sammlung aller Testgruppen, die verwendet werden, um sicherzustellen, dass einGerät mit AWS IoT Greengrass arbeitet.

Eine Testgruppe besteht aus allen Einzelprüfungen, die sich auf ein zu testendes Merkmal beziehen.Weitere Informationen finden Sie unter Beschreibung der Testgruppen (p. 486).

AWS IoT Device Tester für AWS IoT Greengrass-Versionen

Die neueste Version von IDT für AWS IoT Greengrass unterstützt die hier aufgelisteten AWS IoTGreengrass-Versionen. Wenn Sie eine frühere Version von AWS IoT Greengrass testen müssen, sieheFrühere IDT-Versionen für AWS IoT Greengrass (p. 471).

Indem Sie diese Software herunterladen, stimmen Sie der Lizenzvereinbarung für AWS IoT Device Testerzu. Neue Versionen von AWS IoT Greengrass erfordern möglicherweise, dass Sie eine neue Version vonIDT für AWS IoT Greengrass herunterladen. IDT für AWS IoT Greengrass benachrichtigt Sie, wenn es mitIhrer Version von AWS IoT Greengrass nicht kompatibel ist, sobald Sie einen Testlauf starten.

IDT v1.3.3 für AWS IoT Greengrass v1.9.2, v1.9.1, v1.9.0, v1.8.3 und v1.8.2

• IDT für AWS IoT Greengrass: Linux• IDT für AWS IoT Greengrass macOS• IDT für AWS IoT Greengrass: Windows

Versionshinweise:

• Zusätzliche Unterstützung für Greengrass v1.9.2 und v1.8.3.• Zusätzliche Unterstützung für Greengrass OpenWRT.• Zusätzliche SSH-Benutzername/Passwort-Gerätanmeldung.• Zusätzlicher nativer Test-Bugfix für OpenWRT-ARMv7l-Plattform.

Frühere IDT-Versionen für AWS IoT GreengrassDieser Abschnitt enthält die Download-Links für frühere Versionen von IDT.

IDT v1.3.2 für AWS IoT Greengrass v1.9.2, v1.9.1, v1.9.0, v1.8.3 und v1.8.2


Versionshinweise:

• Zusätzliche Unterstützung für Greengrass v1.9.2 und v1.8.3.• Zusätzliche Unterstützung für Greengrass OpenWRT.• Zusätzliche SSH-Benutzername/Passwort-Gerätanmeldung.

471

https://d232ctwt5kahio.cloudfront.net/greengrass/AWS%20IoT%20Device%20Tester%20License%20Agreement.pdf

https://d232ctwt5kahio.cloudfront.net/greengrass/devicetester_greengrass_linux_1.3.3.zip

https://d232ctwt5kahio.cloudfront.net/greengrass/devicetester_greengrass_mac_1.3.3.zip

https://d232ctwt5kahio.cloudfront.net/greengrass/devicetester_greengrass_win_1.3.3.zip




AWS IoT Greengrass EntwicklerhandbuchFrühere IDT-Versionen für AWS IoT Greengrass

IDT v1.3.1 für AWS IoT Greengrassv1.9.1, v1.9.0 und v1.8.2


Versionshinweise:

• Unterstützung für AWS IoT Greengrass v1.9.1 hinzugefügt.

IDT v1.2 für AWS IoT Greengrass v1.8.1


Versionshinweise:

• Ein konfigurierbarer Timeout-Multiplikator wurde hinzugefügt, um Timeout-Probleme (z.B. beiVerbindungen mit niedriger Bandbreite) zu beheben.



Versionshinweise:

• Zusätzliche Unterstützung für AWS IoT Greengrass-Hardware Security Integration (HSI) hinzugefügt.• Zusätzliche Unterstützung für AWS IoT Greengrass-Container und keine Container hinzugefügt.• Automatisierte AWS IoT Greengrass-Servicerollenerstellung hinzugefügt.• Test-Ressourcenbereinigung verbessert.• Zusammenfassungsbericht für die Testausführung hinzugefügt.



Versionshinweise:

• Zusätzliche Unterstützung für AWS IoT Greengrass-Hardware Security Integration (HSI) hinzugefügt.• Zusätzliche Unterstützung für AWS IoT Greengrass-Container und keine Container hinzugefügt.• Automatisierte AWS IoT Greengrass-Servicerollenerstellung hinzugefügt.• Test-Ressourcenbereinigung verbessert.• Zusammenfassungsbericht für die Testausführung hinzugefügt.

472














IDT 1.0 (am 11.03.19 aktualisiert) für AWS IoT Greengrass v1.6.1


Versionshinweise:

• Umfasst die OTA-Test Fehlerkorrektur für zukünftige AWS IoT Greengrass-Versionskompatibilität.

VoraussetzungenIn diesem Abschnitt werden die Voraussetzungen für die Verwendung von IDT für AWS IoT Greengrassbeschrieben.

Laden Sie die neueste Version von AWS IoT DeviceTester für AWS IoT Greengrass herunter.Laden Sie die neueste Version von IDT von AWS IoT Device Tester für AWS IoT Greengrass-Versionen (p. 471) herunter. Extrahieren Sie die Software an einem Speicherort auf Ihrem Dateisystem,an dem Sie über Lese- und Schreibrechte verfügen. Windows hat eine Pfadlängenbegrenzung von260 Zeichen. Wenn Sie Windows verwenden, extrahieren Sie IDT für AWS IoT Greengrass in einemStammverzeichnis wie C:\ oder D:\, um Ihre Pfade unter der Grenze von 260 Zeichen zu halten.

Erstellen und Konfigurieren eines AWS-KontosFühren Sie die folgenden Schritte aus, um ein AWS-Konto zu erstellen und zu konfigurieren, einenIAM-Benutzer zu erstellen und eine IAM-Richtlinie zu erstellen, die IDT für AWS IoT Greengrass dieBerechtigung erteilt, während der Durchführung von Tests in Ihrem Namen auf Ressourcen zuzugreifen.

1. Erstellen eines AWS-Kontos.2. Erstellen Sie eine IAM-Richtlinie, die IDT für AWS IoT Greengrass die Berechtigungen erteilt, die zum

Ausführen der Tests erforderlich sind. Verwenden Sie die Richtlinienvorlagen, die in Vorlage einerBerechtigungsrichtlinie (p. 473) beschrieben sind.

3. Legen Sie einen IAM-Benutzer in Ihrem AWS-Konto an und fügen Sie die Richtlinie hinzu, die Siegerade erstellt haben.

Vorlage einer BerechtigungsrichtlinieIm Folgenden finden Sie eine Richtlinienvorlage, die die Berechtigungen erteilt, die IDT für AWS IoTGreengrass für die Ausführung von Tests benötigt.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "iam:CreateRole",

473




https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html

AWS IoT Greengrass EntwicklerhandbuchErstellen und Konfigurieren eines AWS-Kontos

"iam:DeleteRole", "iam:AttachRolePolicy", "iam:PassRole", "iam:DetachRolePolicy" ], "Resource": [ "arn:aws:iam::*:role/idt-*", "arn:aws:iam::*:role/GreengrassServiceRole" ] }, { "Sid": "VisualEditor1", "Effect": "Allow", "Action": [ "lambda:DeleteFunction", "lambda:CreateFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:idt-*" ] }, { "Sid": "VisualEditor2", "Effect": "Allow", "Action": [ "iot:DeleteCertificate", "iot:AttachPolicy", "iot:DetachPolicy", "iot:DeletePolicy", "iot:CreateJob", "iot:AttachThingPrincipal", "iot:DeleteThing", "iot:DescribeJob", "iot:UpdateCertificate", "iot:DescribeJobExecution", "iot:DetachThingPrincipal", "iot:CreateThing", "iot:DeleteJob" ], "Resource": [ "arn:aws:iot:*:*:thing/idt-*", "arn:aws:iot:*:*:policy/idt-*", "arn:aws:iot:*:*:cert/*", "arn:aws:iot:*:*:job/*" ] }, { "Sid": "VisualEditor3", "Effect": "Allow", "Action": [ "iot:CreatePolicy", "iot:CreateKeysAndCertificate", "iot:UpdateThingShadow", "iot:GetThingShadow", "iot:DescribeEndpoint", "greengrass:*", "iam:ListAttachedRolePolicies" ], "Resource": "*" } ] }

Wenn Sie AWS IoT Greengrass 1.6.1 oder früher verwenden, finden Sie Informationen unter Verwendenvon IDT für Greengrass 1.6.1 und frühere Versionen (p. 475).

474

AWS IoT Greengrass EntwicklerhandbuchVerwenden von IDT für Greengrass

1.6.1 und frühere Versionen

Verwenden von IDT für Greengrass 1.6.1 und frühereVersionenWenn Sie eine frühere Version von IDT für AWS IoT Greengrass als 1.7.0 verwenden, müssen Sie dieAWS-Befehlszeilenschnittstelle (CLI) installieren und eine AWS IoT Greengrass-Servicerolle erstellen. InVersionen 1.7.1 oder höher erstellt IDT die Servicerolle für Sie.

Installieren der AWS-Befehlszeilenschnittstelle (CLI, CommandLine Interface)Sie müssen die CLI verwenden, um bestimmte Operationen ausführen zu können. Falls die CLI nichtinstalliert ist, befolgen Sie die Anleitungen unter Installieren der AWS CLI.

Konfigurieren Sie die CLI für die AWS-Region, die Sie verwenden möchten, indem Sie aws configure voneiner Befehlszeile aus ausführen. Weitere Informationen zu den AWS-Regionen, die IDT für AWS IoTGreengrass unterstützen, finden Sie unter AWS-Regionen und .Endpunkte.

Konfigurieren der AWS IoT Greengrass-ServicerolleFür die erfolgreiche Bereitstellung einer AWS IoT Greengrass-Gruppe benötigt AWS IoT GreengrassBerechtigungen zum Ausführen von Aktionen in Ihrem Namen. Wenn Sie IDT Version 1.1 für AWS IoTGreengrass oder neuer verwenden, erstellt IDT die Servicerolle für Sie und ordnet sie Ihrem AWS-Kontozu. Wenn Sie IDT v1.0 für AWS IoT Greengrass verwenden, führen Sie die folgenden Anweisungen aus,um eine Servicerolle zu erstellen und Sie Ihrem AWS-Konto zuzuordnen.

So erstellen Sie die AWS IoT Greengrass-Servicerolle

1. Verwenden Sie den folgenden AWS CLI-Befehl auf Ihrem Host-Computer, um eine Servicerolle zuerstellen.

aws iam create-role --role-name GreengrassServiceRole --assume-role-policy-document '{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Service": "greengrass.amazonaws.com" }, "Action": "sts:AssumeRole" }]}'

Dieser Befehl generiert den ARN einer Servicerolle, die Sie verwenden, wenn Sie Ihre AWS IoTGreengrass-Servicerolle mit Ihrem AWS-Konto verknüpfen.

2. Geben Sie den folgenden AWS CLI-Befehl aus, um dieAWSGreengrassResourceAccessRolePolicy Ihrer AWS IoT Greengrass-Servicerolle zuzuordnen.

aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy --role-name GreengrassServiceRole

3. Verwenden Sie den folgenden AWS CLI-Befehl, um Ihre AWS IoT Greengrass-Servicerolle mit IhremAWS-Konto zu verknüpfen.

aws greengrass associate-service-role-to-account --role-arn <your-greengrass-service-role-arn>

475


https://docs.aws.amazon.com/general/latest/gr/rande.html#amazon-freertos-ota-control

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren Ihres Geräts

Konfigurieren Ihres GerätsUm Ihr Gerät zu konfigurieren, müssen Sie die AWS IoT Greengrass-Abhängigkeiten installieren, dieAWS IoT Greengrass Core-Software konfigurieren, Ihren Host-Computer für den Zugriff auf Ihr Gerätkonfigurieren und Benutzerrechte auf Ihrem Gerät erstellen.

Überprüfen von AWS IoT Greengrass-Abhängigkeiten auf dem zutestenden GerätBevor Sie Ihre Geräte mit dem IDT für AWS IoT Greengrass testen können, stellen Sie sicher, dass SieIhr Gerät so eingerichtet haben, wie in Erste Schritte mit AWS IoT Greengrass beschrieben. WeitereInformationen zu unterstützten Plattformen finden Sie unter Unterstützte Plattformen.

Konfigurieren der AWS IoT Greengrass-SoftwareIDT für AWS IoT Greengrass testet Ihr Gerät auf Kompatibilität mit einer bestimmten Version von AWS IoTGreengrass. IDT bietet zwei Optionen zum Testen von AWS IoT Greengrass auf Ihren Geräten:

• Laden Sie eine Version der AWS IoT Greengrass-Core-Software (p. 15) herunter und verwenden Sie sie.IDT installiert die Software für Sie.

• Verwenden Sie eine Version der bereits auf Ihrem Gerät installierten AWS IoT Greengrass Core-Software.

Note

Jede Version von AWS IoT Greengrass verfügt über eine entsprechende IDT-Version. Sie müssendie Version von IDT herunterladen, die der von Ihnen verwendeten AWS IoT Greengrass-Versionentspricht.

Es gibt zwei Optionen für das Installieren von AWS IoT Greengrass auf Ihrem Gerät:

• Laden Sie die AWS IoT Greengrass Core-Software herunter und konfigurieren Sie IDT für AWS IoTGreengrass für die Verwendung.

• Verwenden Sie eine vorhandene Installation der AWS IoT Greengrass Core-Software.

In den folgenden Abschnitten werden diese Optionen beschrieben. Sie müssen nur eine der Optionenausführen.

Option 1: Herunterladen der AWS IoT Greengrass Core-Software undKonfigurieren von AWS IoT Device Tester für die Verwendung

Sie können die AWS IoT Greengrass-Core-Software von der Seite AWS IoT Greengrass-Core-Software (p. 15)-Downloads herunterladen.

1. Suchen Sie die richtige Architektur und Linux-Verteilung und wählen Sie dann Herunterladen aus.2. Kopieren Sie die tar.gz-Datei in das Verzeichnis <device-tester-extract-location>/

products/greengrass/ggc.

Note

Ändern Sie nicht den Namen der tar.gz-Datei von AWS IoT Greengrass. Legen Sie nicht mehrereDateien in diesem Verzeichnis für das gleiche Betriebssystem und die gleiche Architektur ab.Wenn Sie beispielsweise sowohl greengrass-linux-armv7l-1.7.1.tar.gz- als auch

476

https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-gs.html

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#gg-platforms

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren Ihres Geräts

greengrass-linux-armv7l-1.8.1.tar.gz-Dateien in diesem Verzeichnis haben, werdendie Tests fehlschlagen.

Option 2: Verwenden einer vorhandenen Installation von AWS IoT Greengrass mitAWS IoT Device TesterKonfigurieren Sie IDT zum Testen der auf Ihrem Gerät installierten AWS IoT GreengrassCore-Software indem Sie das Attribut greengrassLocation zu der Datei device.json im<device_tester_extract_location>/configs-Ordner hinzufügen. zum Beispiel:

"greengrassLocation" : "<path-to-greengrass-on-device>"

Weitere Informationen zur Datei device.json finden Sie unter Gerätekonfiguration (p. 480).

Auf Linux-Geräten ist der Standardspeicherort der AWS IoT Greengrass Core-Software /greengrass.Note

Auf Ihrem Gerät sollte eine Installation der AWS IoT Greengrass Core-Software vorhanden sein,die aber nicht gestartet wurde.Stellen Sie sicher, dass Sie den Benutzer ggc_user und die ggc_group auf Ihrem Geräthinzugefügt haben. Weitere Informationen finden Sie unter Umgebungseinstellungen für AWS IoTGreengrass.

Konfigurieren des Host-Computers für den Zugriff auf die zutestenden GeräteIDT wird auf Ihrem Host-Computer ausgeführt und muss mit SSH eine Verbindung mit Ihrem Gerätherstellen können. Sie müssen ein SSH-Schlüsselpaar erstellen und Ihren Schlüssel autorisieren, sich aufdem zu testenden Gerät anzumelden, ohne ein Passwort angeben zu müssen.

Die folgenden Anweisungen zum Erstellen eines SSH-Schlüssels gelten unter der Annahme, dass SieSSH-KEYGEN verwenden. Wenn Sie eine andere SSL-Implementierung verwenden, lesen Sie dieDokumentation zu dieser Implementierung.

1. Erstellen eines SSH-Schlüssels. IDT verwendet SSH-Schlüssel, um sich bei Ihrem zu testendenGerät zu authentifizieren. Sie können mit dem Open SSH-Befehl ssh-keygen ein SSH-Schlüsselpaarerstellen. Wenn Sie bereits ein SSH-Schlüsselpaar auf Ihrem Host-Computer haben, ist es einebewährte Methode, ein SSH-Schlüsselpaar speziell für IDT zu erstellen. Dadurch können Sie dieMöglichkeit Ihres Host-Computers, sich mit Ihrem Gerät (ohne Eingabe eines Passworts) zu verbinden,wieder entfernen, wenn Sie die Tests abgeschlossen haben. Außerdem können Sie den Zugriff auf dasRemote-Gerät auf jene Personen beschränken, die es benötigen.

Note

Windows wird nicht mit einem installierten SSH-Client geliefert. Weitere Informationen zurInstallation eines SSH-Clients unter Windows finden Sie unter Herunterladen der SSH ClientSoftware.

Der Befehl ssh-keygen fordert Sie auf, einen Namen und Pfad zum Speichern des Schlüsselpaarseinzugeben. Standardmäßig werden die Schlüsselpaardateien id_rsa (privater Schlüssel) undid_rsa.pub (öffentlicher Schlüssel) genannt. Unter macOS und Linux ist der Standard-Speicherortdieser Dateien ~/.ssh/. Unter Windows ist der Standard-Speicherort C:\Users\<user-name>\.ssh.

Wenn Sie dazu aufgefordert werden, geben Sie eine Schlüsselphrase zum Schutz Ihres SSH-Schlüssels ein. Weitere Informationen finden Sie unter Generieren eines neuen SSH-Schlüssels.

477



https://www.ssh.com/ssh/keygen/

https://www.ssh.com/ssh/#sec-Download-client-software

https://www.ssh.com/ssh/#sec-Download-client-software

https://www.ssh.com/ssh/keygen/

AWS IoT Greengrass EntwicklerhandbuchFestlegen der Konfiguration zum Ausführender AWS IoT Greengrass Qualification Suite

2. Hinzufügen von autorisierten SSH-Schlüsseln zu Ihrem zu testenden Gerät. IDT muss Ihren privatenSSH-Schlüssel für die Anmeldung bei Ihrem zu testenden Gerät verwenden. Um Ihren privaten SSH-Schlüssel für die Anmeldung bei Ihrem zu testenden Gerät zu autorisieren, verwenden Sie den Befehlssh-copy-id von Ihrem Host-Computer. Dieser Befehl fügt Ihren öffentlichen Schlüssel zur Datei~/.ssh/authorized_keys auf dem zu testenden Gerät hinzu. zum Beispiel:

$ ssh-copy-id <remote-ssh-user>@<remote-device-ip>

Dabei ist remote-ssh-user der Benutzername für die Anmeldung bei dem zu testenden Gerät undremote-device-ip ist die IP-Adresse des zu testenden Geräts für die Ausführung der Tests. zumBeispiel:

ssh-copy-id [email protected]

Wenn Sie dazu aufgefordert werden, geben Sie das Passwort für den im Befehl ssh-copy-idangegebenen Benutzernamen ein.

ssh-copy-id geht davon aus, dass der öffentliche Schlüssel id_rsa.pub heißt und am Standard-Speicherort gespeichert ist (~/.ssh/ in macOS und Linux und C:\Users\<user-name>\.ssh inWindows). Wenn Sie dem öffentlichen Schlüssel einen anderen Namen gegeben oder ihn an einemanderen Ort gespeichert haben, müssen Sie den voll qualifizierten Pfad zu Ihrem öffentlichen SSH-Schlüssel angeben, mit der Option -i zu ssh-copy-id (z. B. ssh-copy-id -i ~/my/path/myKey.pub).Weitere Informationen zum Erstellen von SSH-Schlüsseln und Kopieren von öffentlichen Schlüsselnfinden Sie unter SSH-COPY-ID.

Konfigurieren von Benutzerberechtigungen für Ihr GerätIDT führt Operationen für verschiedene Verzeichnisse und Dateien auf einem zu testenden Gerätaus. Einige dieser Operationen erfordern höhere Berechtigungen (mit sudo). Zum Autorisieren dieserOperationen muss IDT für AWS IoT Greengrass Befehle mit sudo ausführen können, ohne zur Eingabeeines Passworts aufgefordert zu werden.

Führen Sie die folgenden Schritte auf dem zu testenden Gerät aus, um sudo den Zugriff ohne Aufforderungzur Eingabe eines Passworts zu erlauben.

Note

username bezieht sich auf den SSH-Benutzer, der von IDT für den Zugriff auf das zu testendeGerät verwendet wird.

So fügen Sie den Benutzer der sudo-Gruppe hinzu

1. Führen Sie auf dem zu testenden Gerät sudo usermod -aG sudo <username> aus2. Melden Sie sich ab und melden Sie sich dann wieder an, damit die Änderungen wirksam werden.3. Überprüfen Sie, ob Ihr Benutzername erfolgreich hinzugefügt wurde, indem Sie sudo echo test

ausführen. Wenn Sie nicht zur Eingabe eines Passworts aufgefordert werden, ist Ihr Benutzer korrektkonfiguriert.

Festlegen der Konfiguration zum Ausführen derAWS IoT Greengrass Qualification Suite

Bevor Sie Tests durchführen, müssen Sie die Einstellungen für die AWS-Anmeldeinformationen und -Geräte auf Ihrem Host-Computer konfigurieren.

478

https://www.ssh.com/ssh/copy-id

AWS IoT Greengrass EntwicklerhandbuchKonfigurieren Ihrer AWS-Anmeldeinformationen

Konfigurieren Ihrer AWS-AnmeldeinformationenSie müssen Ihre IAM-Benutzeranmeldeinformationen in der Datei<device_tester_extract_location> /configs/config.json konfigurieren. Verwenden Sie dieAnmeldeinformationen für den IDT für AWS IoT Greengrass für die spezifischen Benutzer, die in Erstellenund Konfigurieren eines AWS-Kontos (p. 473) erstellt wurden. Sie können Ihre Anmeldeinformationen aufzwei Arten angeben:

• Anmeldeinformationen-Datei• Umgebungsvariablen

Konfigurieren der AWS-Anmeldeinformationen mit einerAnmeldeinformationsdateiIDT verwendet die gleiche Anmeldeinformationsdatei wie das AWS CLI. Weitere Informationen finden Sieunter Konfigurations- und Anmeldeinformationsdateien.

Der Speicherort der Datei mit den Anmeldeinformationen variiert je nach Betriebssystem, das Sieverwenden:

• macOS Linux: ~/.aws/credentials• Windows: C:\Users\UserName\.aws\credentials

Fügen Sie Ihre AWS-Anmeldeinformationen in die Datei credentials im folgenden Format hinzu:

[default]aws_access_key_id = <your_access_key_id>aws_secret_access_key = <your_secret_access_key>

Um IDT für AWS IoT Greengrass so zu konfigurieren, dass die AWS-Anmeldeinformationen aus Ihrercredentials-Datei verwendet werden, bearbeiten Sie Ihre config.json -Datei wie folgt:

{ "awsRegion": "us-west-2", "auth": { "method": "file", "credentials": { "profile": "default" } }}

Note

Wenn Sie das default AWS-Profil nicht verwenden,ändern Sie unbedingt den Profilnamen inIhrer config.json-Datei. Weitere Informationen hierzu finden Sie unter Benannte Profile.

Konfigurieren der AWS-Anmeldeinformationen mitUmgebungsvariablenUmgebungsvariablen sind Variablen, die vom Betriebssystem gepflegt und von Systembefehlen verwendetwerden. Sie werden nicht gespeichert, wenn Sie die SSH-Sitzung schließen. Der IDT für AWS IoT

479

https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

AWS IoT Greengrass EntwicklerhandbuchGerätekonfiguration

Greengrass kann die Umgebungsvariablen AWS_ACCESS_KEY_ID und AWS_SECRET_ACCESS_KEYverwenden, um Ihre AWS-Anmeldeinformationen zu speichern.

Um diese Variablen auf Linux, macOS oder Unix festzulegen, verwenden Sie export:

export AWS_ACCESS_KEY_ID=<your_access_key_id>export AWS_SECRET_ACCESS_KEY=<your_secret_access_key>

In Windows können Sie die Variablen mit set festlegen:

set AWS_ACCESS_KEY_ID=<your_access_key_id>set AWS_SECRET_ACCESS_KEY=<your_secret_access_key>

Um den IDT so zu konfigurieren, dass er die Umgebungsvariablen verwendet, bearbeiten Sie den Abschnittauth in Ihrer config.json-Datei. Nachfolgend finden Sie ein Beispiel für eine config.json-Datei:

{ "awsRegion": "us-west-2", "auth": { "method": "environment" }}

GerätekonfigurationZusätzlich zu den AWS-Anmeldeinformationen benötigt IDT für AWS IoT Greengrass Informationen zu denGeräten, auf denen Tests ausgeführt werden (z. B. IP-Adresse, Anmeldeinformationen, Betriebssystem undCPU-Architektur).

Sie müssen diese Informationen mittels der Vorlage device.json in <device_tester_extract_location>/configs/device.json angeben:

[ { "id": "<pool-id>", "sku": "<sku>", "features": [ { "name": "os", "value": "linux | ubuntu | openwrt" }, { "name": "arch", "value": "x86_64 | armv7l | aarch64" } ], "hsm": { "p11Provider": "</path/to/pkcs11ProviderLibrary>", "slotLabel": "<slot-label>", "slotUserPin": "<pin>", "privateKeyLabel": "<key-label>", "openSSLEngine": "</path/to/openssl/engine>" }, "kernelConfigLocation": "", "greengrassLocation": "", "devices": [ { "id": "<device-id>", "connectivity": {

480


"protocol": "ssh", "ip": "<ip-address>", "auth": { "method": "pki" | "password", "credentials": { "user": "<user>", "privKeyPath": "</path/to/private/key>", "password": "<your-password> } } } } ] }]

Note

Geben Sie privKeyPath nur an, wenn method auf pki gesetzt ist.Geben Sie password nur an, wenn method auf password gesetzt ist.

Nachfolgend sind alle Pflichtfelder beschrieben:

id

Eine benutzerdefinierte alphanumerische ID, die eine Sammlung von Geräten, den sogenanntenGerätepool, eindeutig identifiziert. Geräte, die zu einem Pool gehören, müssen über identischeHardware verfügen. Bei der Ausführung einer Reihe von Tests werden Geräte im Pool verwendet, umdie Workload zu parallelisieren, während mehrere Geräte verwendet werden, um verschiedene Testsauszuführen.

sku

Ein alphanumerischer Wert, durch den das zu testende Gerät eindeutig identifiziert wird. Die SKU wirdverwendet, um qualifizierte Boards nachzuverfolgen.

Note

Wenn Sie Ihr Board im AWS Partner Device Catalog listen möchten, muss die hierangegebene SKU mit der SKU übereinstimmen, die Sie während des Einreichungsprozessesverwenden.

features

Ein Array, das die Funktionen enthält, die das Gerät unterstützt.• Erforderliche Funktionen: os, arch.• Unterstützte Betriebssystem/Architektur-Kombinationen:

• Linux, x86_64• Linux, ARMv7l• Linux, AArch64• Ubuntu, x86_64• OpenWRT, ARMv7l• OpenWRT, AArch64

hsm (optional)

Enthält Konfigurationsinformationen für den Test mit einem AWS IoT Greengrass-Hardware-Sicherheitsmodul (HSM), ansonsten sollte das Element <hsm> weggelassen werden. WeitereInformationen finden Sie unter Integration von Hardware-Sicherheit (p. 435).

481


hsm.p11Provider

Der absolute Pfad zur libdl-ladbaren Bibliothek der PKCS#11-Implementierung.hsm.slotLabel

Das Slot-Label zur Identifizierung des Hardwaremodulshsm.slotUserPin

Der Benutzer-Pin, mit dem AWS IoT Greengrass-Core gegenüber dem Modul authentifiziert wirdhsm.privateKeyLabel

Das Label zur Identifizierung des Schlüssels im Hardwaremodul.hsm.openSSLEngine

Der absolute Pfad zur OpenSSL-Engine .so-Datei, um die PKCS#11-Unterstützung unterOpenSSL zu aktivieren Dies wird vom AWS IoT Greengrass-OTA-Aktualisierungsagentverwendet.

devices.id

Eine benutzerdefinierte eindeutige Kennung für das zu testende Gerät.connectivity.protocol

Das Kommunikationsprotokoll, das für die Kommunikation mit diesem Gerät verwendet wird. Derzeitwird als einziger Wert ssh unterstützt

connectivity.ip

Die IP-Adresse des zu testenden Geräts.connectivity.auth.method

Die Autorisierungsmethode, die verwendet wird, um über das angegebene Verbindungsprotokoll aufein Gerät zuzugreifen. Unterstützte Werte sind:• pki

• password

connectivity.auth.credentials.password

Das Passwort für die Anmeldung am Gerät wird überprüft. Geben Sie diesen Wert nur an, wennconnectivity.auth.method auf password gesetzt ist.

connectivity.auth.credentials.privKeyPath

Der vollständige Pfad zum privaten Schlüssel, der für die Anmeldung beim zu testenden Gerätverwendet wird. Geben Sie diesen Wert nur an, wenn connectivity.auth.method auf pki gesetztist.

connectivity.auth.credentials.user

Der Benutzername für die Anmeldung bei dem zu testenden Gerät.connectivity.auth.credentials.privKeyPath

Der vollständige Pfad zum privaten Schlüssel, der für die Anmeldung beim zu testenden Gerätverwendet wird.

greengrassLocation

Dieser Wert wird nur verwendet, wenn Sie eine bestehende Installation von AWS IoT Greengrassverwenden. Der Speicherort der AWS IoT Greengrass Core-Software auf Ihren Geräten. VerwendenSie dieses Attribut, um IDT anzuweisen, die Version der auf Ihren Geräten installierten AWS IoTGreengrass Core-Software zu verwenden.

482

AWS IoT Greengrass EntwicklerhandbuchAusführen von Tests

kernelConfigLocation

(Optional) Der Pfad zur Kernel-Konfigurationsdatei. AWS IoT Device Tester überprüft anhand dieserDatei, ob für die Geräte die erforderlichen Kernel-Funktionen aktiviert sind. Wenn nicht angeben,verwendet IDT die folgenden Pfade: /proc/config.gz und /boot/config-<kernel-version>,um nach der Kernel-Konfigurationsdatei zu suchen. Er verwendet die erste, die gefunden wird.

Ausführen von TestsNachdem Sie die gewünschte Konfiguration festgelegt haben, können Sie die Tests starten. Die Laufzeitder gesamten Testsuite hängt von Ihrer Hardware ab. Als Referenz, ein Raspberry Pi 3B benötigt ca.30 Minuten.

In der folgenden Beispielbefehlszeile wird veranschaulicht, wie Sie die Qualifizierungsprüfungen füreinen Gerätepool (ein Satz identischer Geräte) durchführen. Diese Befehle befinden sich im Verzeichnis<devicetester-extract-location>/bin.

Verwenden Sie den folgenden Befehl zum Ausführen aller Testgruppen in einer angegebenen Suite:

devicetester_[linux | mac | win_x86-64] run-suite --suite-id GGQ_1 --pool-id <pool-id>

Verwenden Sie den folgenden Befehl zum Ausführen einer bestimmten Testgruppe:

devicetester_[linux | mac | win_x86-64] run-suite --suite-id GGQ_1 --group-id <group-id> --pool-id <pool-id>

suite-id und pool-id sind optional, wenn Sie eine einzige Testsuite in einem einzigen Gerätepoolausführen (d. h. Sie haben nur einen Gerätepool in Ihrer device.json-Datei definiert).

Befehle für AWS IoT Device Tester für AWS IoTGreengrassDie IDT-Befehle können für die folgenden Operationen verwendet werden:

help

Listet Informationen über den angegebenen Befehl auf.list-groups

Listet die Gruppen in der jeweiligen Testsuite auf.list-suites

Listet die verfügbaren Testsuites auf.run-suite

Führt eine Reihe von Tests in einem Pool von Geräten aus.

Verstehen der Ergebnisse und ProtokolleIn diesem Abschnitt wird beschrieben, wie Sie IDT-Ergebnisberichte und -Protokolle anzeigen undinterpretieren können.

483

AWS IoT Greengrass EntwicklerhandbuchAnzeigen der Ergebnisse

Anzeigen der ErgebnisseWährend der Ausführung schreibt IDT Fehler in die Konsole, Protokolldateien und Testberichte. NachdemIDT die Qualifikations-Testsuite abgeschlossen hat, erstellt er zwei Testberichte. Diese Berichte befindensich in <devicetester-extract-location> /results/<execution-id>/. Beide Berichteerfassen die Ergebnisse von der Ausführung der Qualifikations-Testsuite.

Der awsiotdevicetester_report.xml ist der Qualifizierungstestbericht, den Sie zum Auflisten IhrerGeräte im AWS Partner Device Catalog an AWS senden. Die Bericht enthält die folgenden Elemente:

• Die IDT-Version.• Die AWS IoT Greengrass-Version, die getestet wurde.• Die SKU- und der Gerätename, die in der device.json-Datei angegeben wurden.• Die Funktionen des Gerätepools, der in der device.json-Datei angegeben wurde.• Die aggregierte Zusammenfassung der Testergebnisse.• Eine Aufschlüsselung der Testergebnisse nach Bibliotheken, die basierend auf den Geräteeigenschaften

getestet wurden (z.B. lokaler Ressourcenzugriff, Shadow, MQTT etc.).

Der GGQ_Result.xml-Bericht wird im JUnit-XML-Format erstellt. Sie können ihn in nachgeschalteteIntegrations- und Bereitstellungsplattformen wie Jenkins, Bamboo usw. integrieren. Die Bericht enthält diefolgenden Elemente:

• Eine aggregierte Zusammenfassung der Testergebnisse.• Eine Aufschlüsselung der Testergebnisse nach der getesteten AWS IoT Greengrass-Funktionalität.

Interpretieren von AWS IoT Device Tester-ErgebnissenDer Bericht im Abschnitt awsiotdevicetester_report.xml oderawsiotdevicetester_report.xml listet die Tests und die Ergebnisse auf, die ausgeführt wurden.

Im ersten XML-Tag <testsuites> ist die Zusammenfassung der Testausführung enthalten. zum Beispiel:

<testsuites name="GGQ results" time="2299" tests="28" failures="0" errors="0" disabled="0">

Im <testsuites>-Tag verwendete Attribute

name

Name der Testsuitetime

Zeit (in Sekunden), die zur Ausführung der Qualifikations-Suite erforderlich wartests

Die Anzahl der ausgeführten Tests.failures

Die Anzahl der ausgeführten Tests, die den Test nicht bestanden habenerrors

Die Anzahl der Tests, die IDT nicht ausführen konnte.disabled

Dieses Attribut wird nicht verwendet und kann ignoriert werden.

484

https://llg.cubic.org/docs/junit/

https://jenkins.io/

https://www.atlassian.com/software/bamboo

AWS IoT Greengrass EntwicklerhandbuchAnzeigen der Ergebnisse

Die Datei awsiotdevicetester_report.xml enthält ein <awsproduct>-Tag mit Informationen zumgetesteten Produkt und den Produktfunktionen, die nach einer Reihe von Tests validiert wurden.

Im <awsproduct>-Tag verwendete Attribute

name

Der Name des getesteten Produkts.version

Die Version des getesteten Produkts.features

Die validierten Funktionen Als required gekennzeichnete Funktionen sind für die Einreichung IhresBoards für die Qualifizierung erforderlich. Der folgende Ausschnitt zeigt, wie diese Informationen in derDatei awsiotdevicetester_report.xml angezeigt werden.

<feature name="aws-iot-greengrass-no-container" value="supported" type="required"></feature>

Als optional gekennzeichnete Funktionen sind für die Qualifizierung nicht erforderlich. Die folgendenCodeausschnitte zeigen optionale Funktionen.

<feature name="aws-iot-greengrass-container" value="supported" type="optional"></feature>

<feature name="aws-iot-greengrass-hsi" value="not-supported" type="optional"></feature>

Wenn in Tests bei den erforderlichen Funktionen keine Fehler auftreten, entspricht Ihr Gerät dentechnischen Anforderungen zur Ausführung von AWS IoT Greengrass und kann mit AWS IoT-Servicesinteragieren. Wenn Sie Ihr Gerät im AWS Partner Device Catalog auflisten wollen, können Sie diesenBericht als Qualifizierungsnachweis verwenden.

Falls bei Tests Fehler auftreten, können Sie den fehlgeschlagenen Test identifizieren, indem Sie die XML-Tags von <testsuites> überprüfen. Die XML-Tags von <testsuite> im <testsuites>-Tag zeigendie Ergebniszusammenfassung eines Tests für eine Testgruppe. zum Beispiel:

<testsuite name="combination" package="" tests="1" failures="0" time="161" disabled="0" errors="0" skipped="0">

Das Format ähnelt dem <testsuites>-Tag, weist aber das Attribut skipped auf, das nicht verwendetwird und ignoriert werden kann. Innerhalb der einzelnen <testsuite>-XML-Tags befinden sich<testcase>-Tags für alle ausgeführten Tests einer Testgruppe. zum Beispiel:

<testcase classname="Security Combination (IPD + DCM) Test Context" name="Security Combination IP Change Tests sec4_test_1: Should rotate server cert when IPD disabled and following changes are made:Add CIS conn info and Add another CIS conn info" attempts="1"></testcase>>

Im <testcase>-Tag verwendete Attribute

name

Der Name des Tests

485

AWS IoT Greengrass EntwicklerhandbuchBeschreibung der Testgruppen

attempts

Gibt an, wie oft IDT den Testfall ausgeführt hat.

Wenn ein Test fehlschlägt oder ein Fehler auftritt, werden <failure>- oder <error>-Tags hinzugefügt,um das <testcase>-Tag mit Informationen für die Fehlerbehebung zu versehen. zum Beispiel:

<testcase classname="mcu.Full_MQTT" name="AFQP_MQTT_Connect_HappyCase" attempts="1"> <failure type="Failure">Reason for the test failure</failure> <error>Reason for the test execution error</error></testcase>

Anzeigen von ProtokollenIDT generiert die Protokolle über die Testausführung in <devicetester-extract-location>/results/<execution-id>/logs. Es werden zwei Protokollgruppen generiert:

test_manager.log

Protokolle, die aus der Komponente Test Manager des AWS IoT Device Tester generiert wurden (z .B.Protokolle zur Konfiguration, Testsequenzierung und Berichtserstellung).

<test_case_id>.log (for example, ota.log)

Protokolle der Testgruppe, einschließlich Protokolle vom zu testenden Gerät. Wenn ein Testfehlschlägt, wird eine tar.gz-Datei mit den Protokollen des zu testenden Geräts für den Test erstellt(z. B. ota_prod_test_1_ggc_logs.tar.gz).

Weitere Informationen finden Sie unter Fehlerbehebung in IDT für AWS IoT Greengrass (p. 488).

Beschreibung der TestgruppenAbhängigkeiten

Die Testgruppe der Abhängigkeiten prüft, ob das Gerät die erforderlichen technischen Abhängigkeitenfür AWS IoT Greengrass erfüllt.

Bereitstellung

Die Bereitstellungs-Testgruppe wird verwendet, um festzustellen, ob AWS IoT Greengrass-Coresnach dem Fehlschlagen einer langlebigen Python-Lambda-Bereitstellung erneut bereitgestellt werdenkönnen. Weitere Informationen finden Sie unter Lebenszykluskonfiguration für Greengrass Lambda-Funktionen (p. 189).

Integration von Hardware-Sicherheit (Hardware Security Integration, HSI)

Die HSI-Testgruppe wird verwendet, um zu prüfen, ob die bereitgestellte freigegebene Bibliothekeine Schnittstelle mit HSM herstellen kann, und implementiert die erforderliche PKCS#11-APIordnungsgemäß. Die HSM/Shared-Bibliothek sollte eine Certificate Signing Request (CSR) signieren,Transport Layer Security (TLS)-Operationen durchführen und die richtigen Schlüssellängen und denAlgorithmus für den öffentlichen Schlüssel bereitstellen.

Device Certificate Manager (DCM)

Die DCM-Testgruppe wird verwendet, um zu überprüfen, ob der AWS IoT Greengrass DeviceCertificate Manager beim Start-up ein Serverzertifikat generieren und Zertifikate, die in Kürze ablaufen,rotieren kann.

486

AWS IoT Greengrass EntwicklerhandbuchBeschreibung der Testgruppen

IP-Erkennung (IPD)

Die IPD-Testgruppe wird verwendet, um zu prüfen, ob Informationen zur Core-Verbindung aktualisiertwerden, wenn in einem AWS IoT Greengrass Core-Gerät Änderungen der IP-Adresse auftreten.Weitere Informationen finden Sie unter Aktivieren der automatischen IP-Erkennung (p. 63).

Zugriff auf lokale Ressourcen

Die LRA-Testgruppe wird verwendet, um die Local Resource Access (LRA)-Funktion von AWS IoTGreengrass zu prüfen, indem sie containerisierten Lambda-Funktionen über AWS IoT GreengrassLRA-APIs den Zugriff auf lokale Dateien und Verzeichnisse im Besitz von verschiedenen Linux-Benutzern und -Gruppen ermöglicht. Lambda-Funktionen sollte Zugriff auf lokale Ressourcenbasierend auf der LRA-Konfiguration erteilt oder verweigert werden.

Kombination (Gerätesicherheitsinteraktion)

Die Kombinations-Testgruppe prüft die Funktionalität von DCM und IPD auf dem AWS IoT GreengrassCore-Gerät, indem sie die Verbindungsinformationen für die AWS IoT Greengrass-Gruppe in derCloud ändert. Die Testgruppe rotiert das AWS IoT Greengrass Serverzertifikat und prüft, ob AWS IoTGreengrass Verbindungen zulässt.

Protokollierung

Die Protokollierungs-Testgruppe wird verwendet, um zu prüfen, ob der AWS IoT Greengrass-Protokollierungsservice mit einer in Python geschriebenen Lambda-Benutzerfunktion in eineProtokolldatei schreiben kann.

MQTT

Die MQTT-Testgruppe wird verwendet, um die Funktionalität des AWS IoT Greengrass-Nachrichtenrouters zu überprüfen durch Senden von Nachrichten zu einem Thema, das an zweiLambda-Funktionen weitergeleitet wird.

Nativ

Die native Testgruppe wird verwendet, um zu prüfen, ob AWS IoT Greengrass native (kompilierte)Lambda-Funktionen ausführen kann.

Netzwerk

Die Netzwerk-Testgruppe wird verwendet, um zu prüfen, ob innerhalb einer Lambda-Funktion Socket-Verbindungen eingerichtet werden können. Diese Socket-Verbindungen sollten je nach AWS IoTGreengrass-Core-Konfiguration zugelassen oder abgelehnt werden.

Over-the-Air (OTA)

Die OTA-Testgruppe wird verwendet, um zu prüfen, ob OTA eine OTA-Aktualisierung aus der Cloudverarbeiten kann.

Penetration

Die Penetration-Testgruppe prüft, ob das Starten der AWS IoT Greengrass Core-Software fehlschlägt,wenn Hard-Link-/Soft-Link-Schutz und seccomp deaktiviert sind. Sie wird außerdem verwendet, umweitere sicherheitsrelevante Funktionen zu überprüfen.

Shadow

Der Shadow-Testgruppe wird verwendet, um die lokale Shadow- und Shadow-Cloud-Synchronisierungsfunktionalität zu prüfen.

Spooler

Der Spooler-Testgruppe wird verwendet, um zu prüfen, ob die MQTT-Nachrichten mit der Standard-Spooler-Konfiguration in die Warteschlange gestellt werden.

Token Exchange Service (TES)

Die TES-Testgruppe wird verwendet, um zu prüfen, ob AWS IoT Greengrass sein Core-Zertifikatgegen gültige AWS-Anmeldeinformationen austauschen kann.

487

https://www.kernel.org/doc/Documentation/prctl/seccomp_filter.txt

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung in IDT für AWS IoT Greengrass

Version

Die Versions-Testgruppe wird verwendet, um zu überprüfen, ob die angegebene Version der AWS IoTGreengrass Software korrekt ist.

Fehlerbehebung in IDT für AWS IoT GreengrassIDT für AWS IoT Greengrass schreibt diese Fehler je nach Art der Fehler an verschiedene Stellen. Fehlerwerden in die Konsole, in Protokolldateien und Testberichte geschrieben.

FehlercodesIn der folgenden Tabelle finden Sie die von IDT für AWS IoT Greengrass generierten Fehlercodes.

Fehlercode Name des Fehlercodes Mögliche Ursache Fehlersuche

101 InternalError Es ist ein interner Fehleraufgetreten.

Wenden Sie sich anden AWS DeveloperSupport.

102 TimeoutError Der Test kann in einembegrenzten Zeitraumnicht abgeschlossenwerden. Dies kannin folgenden Fällenvorkommen:

• Es bestehteine langsameNetzwerkverbindungzwischen Testgerätund Gerät (z. B. beiVerwendung einesVPN-Netzwerks).

• Ein langsamesNetzwerkbeeinträchtigt dieKommunikationzwischen Gerät undCloud.

• Das Feld timeout inTestkonfigurationsdateien(test.json)wurde versehentlichgeändert.

• Überprüfen Sie dieNetzwerkverbindungund -geschwindigkeit.

• Stellen Sie sicher,dass Sie keine Dateiim Verzeichnis /testgeändert haben.

• Versuchen Sie,die fehlerhafteTestgruppe mit demFlag "--group-id"manuell auszuführen.

• Versuchen Sie,die Testsuiteauszuführen, indemSie die Timeoutsfür die Testserhöhen. WeitereInformationen findenSie unter Timeout-Fehler (p. 498).

103 PlatformNotSupportError Eine falscheKombination ausBetriebssystemund Architektur istin device.jsonangegeben.

Ändern Sie IhreKonfiguration in eineder unterstütztenKombinationen:

• Linux, x86_64• Linux, ARMv7l• Linux, AArch64

488

https://aws.amazon.com/premiumsupport/plans/developers/

https://aws.amazon.com/premiumsupport/plans/developers/

AWS IoT Greengrass EntwicklerhandbuchFehlercodes

Fehlercode Name des Fehlercodes Mögliche Ursache Fehlersuche• Ubuntu, x86_64• OpenWRT, ARMv7l• OpenWRT, AArch64

Weitere Informationenfinden Sie unterGerätekonfiguration (p. 480).

104 VersionNotSupportError Die AWS IoTGreengrass Core-Softwareversion wirdvon der verwendetenVersion von IDT nichtunterstützt.

Verwenden Sie denBefehl device_tester_binversion, um dieunterstützte Version derAWS IoT GreengrassCore-Software zusuchen. Wenn SiebeispielsweisemacOS nutzen,verwenden Sie: ./devicetester_mac_x86_64version.

So suchen Sie dieVersion der AWS IoTGreengrass Core-Software, die Sieverwenden:

• Wenn Sie Tests mitvorinstallierter AWSIoT Greengrass Core-Software ausführen,stellen Sie mithilfe vonSSH eine Verbindungzu Ihrem AWS IoTGreengrass-Core-Gerät her und führenSie den folgendenBefehl aus: <path-to-preinstalled-greengrass-location>;/greengrass/ggc/core/greengrassd --version

• Wenn Sie Testsmit einer anderenVersion der AWS IoTGreengrass Core-Software ausführen,navigieren Siezum Verzeichnisdevicetester_greengrass_<os>products/greengrass/gcc. Die AWS IoT

489


Fehlercode Name des Fehlercodes Mögliche Ursache FehlersucheGreengrass Core-Softwareversion istim ZIP-Dateinamenenthalten.

Sie können eineandere Version derAWS IoT GreengrassCore-Software testen.Weitere Informationenfinden Sie unter ErsteSchritte mit AWS IoTGreengrass (p. 69).

105 LanguageNotSupportError IDT unterstützt nurPython für AWSIoT Greengrass-Bibliotheken und SDKs.

Stellen Sie Folgendessicher:

• Beim SDK-Paket unterdevicetester_greengrass_<os>/products/greengrass/ggsdkhandelt es sich umdas Python SDK.

• Der Inhalt desOrdners bin unterdevicetester_greengrass_<os>/tests/GGQ_1/suite/resources/run.runtimefarm/bin wurde nichtgeändert.

490



106 ValidationError Manche Felder indevice.json oderconfig.json sindungültig.

Überprüfen Sie dieFehlermeldung aufder rechten Seite desFehlercodes im Bericht.

• Ungültiger Pfad zumprivaten Schlüssel:Geben Sie denrichtigen Pfad zuIhrem privatenSchlüssel an. WeitereInformationenfinden Sie unterGerätekonfiguration (p. 480).

• Ungültige AWS-Region: GebenSie eine gültigeAWS-Region inconfig.json an.Weitere Informationenzu AWS-Regionenerhalten Sie unterRegionen undEndpunkte.

• AWS-Anmeldeinformationen:Legen Siegültige AWS-Anmeldeinformationenauf Ihrem Testgerätfest (durchUmgebungsvariablenoder die Dateicredentials).Überprüfen Sie,ob das Feld authkorrekt konfiguriert ist.Weitere Informationenfinden Sie unterErstellen undKonfiguriereneines AWS-Kontos (p. 473)

491

https://docs.aws.amazon.com/general/latest/gr/rande.html

https://docs.aws.amazon.com/general/latest/gr/rande.html



107 SSHConnectionFailed Das Testgerät kannkeine Verbindung mitdem konfiguriertenGerät herstellen.

Überprüfen Sie, ob diefolgenden Felder in IhrerDatei device.jsonkorrekt sind:

• ip

• user

• privKeyPath

Weitere Informationenfinden Sie unterGerätekonfiguration (p. 480).

108 RunCommandError In einem Test konnteein Befehl auf demgetesteten Gerät nichtausgeführt werden.

Überprüfen Sie, obRoot-Zugriff für denkonfigurierten Benutzerin device.jsonzulässig ist.

Einige Geräte erfordernein Passwort, wennBefehle mit Root-Zugriff ausgeführtwerden. Stellen Siesicher, dass Root-Zugriff ohne Passwortzulässig ist. WeitereInformationen finden Siein der Dokumentation zuIhrem Gerät.

Versuchen Sie, denfehlgeschlagenen Befehlmanuell auf IhremGerät auszuführen, undüberprüfen Sie, ob einFehler auftritt.

109 PermissionDeniedError Kein Root-Zugriff. Richten Sie Root-Zugrifffür den konfiguriertenBenutzer auf IhremGerät ein.

110 CreateFileError Datei kann nicht erstelltwerden.

Überprüfen Sie dieSpeicherplatz- undVerzeichnisberechtigungenIhres Geräts.

111 CreateDirError Verzeichnisses kannnicht erstellt werden.

Überprüfen Sie dieSpeicherplatz- undVerzeichnisberechtigungenIhres Geräts.

492



112 InvalidPathError Der Pfad zu der AWSIoT Greengrass Core-Software ist falsch.

Überprüfen Sie,ob der Pfad in derFehlermeldung gültigist. Bearbeiten Sie keineDateien im Verzeichnisdevicetester_greengrass_<os>.

113 InvalidFileError Eine Datei ist ungültig. Überprüfen Sie,ob die Datei in derFehlermeldung gültig ist.

114 ReadFileError Die angegebene Dateikann nicht gelesenwerden.

Überprüfen SieFolgendes:

• Dateiberechtigungensind korrekt.

• limits.configerlaubt das Öffnenvon genügendDateien.

• Die angegebene Dateiin der Fehlermeldungist vorhanden undgültig.

Wenn Sie auf einemmacOS testen, erhöhenSie das Limit fürgeöffnete Dateien.Das Standardlimitbeträgt 256. Dies istausreichend für Tests.

115 FileNotFoundError Eine erforderliche Dateiwurde nicht gefunden.


• Das SDK-Paket ist unterdevicetester_greengrass_<os>/products/greengrass/ggsdkvorhanden.

• Die Dateien unterdevicetester_greengrass_<os>/tests wurden nichtgeändert.

493



116 OpenFileFailed Die angegebene Dateikonnte nicht geöffnetwerden.


• Die angegebene Dateiin der Fehlermeldungist vorhanden undgültig.

• limits.configerlaubt das Öffnenvon genügendDateien.

Wenn Sie auf einemmacOS testen, erhöhenSie das Limit fürgeöffnete Dateien.Das Standardlimitbeträgt 256. Dies istausreichend für Tests.

117 WriteFileFailed Datei konnte nichtgeschrieben werden(DUT oder Testsystem).

Versuchen Sie, manuelleine Datei im inder FehlermeldungangegebenenVerzeichnis zu erstellen.

118 FileCleanUpError Ein Test konnte dieangegebene Dateioder das angegebeneVerzeichnis nichtentfernen oder derBefehl „umount“ wurdefür die angegebeneDatei auf dem Remote-Gerät nicht ausgeführt.

Wenn die Binärdateinoch ausgeführtwird, ist die Dateimöglicherweisegesperrt. BeendenSie den Prozessund löschen Sie dieangegebene Datei.

119 InvalidInputError Ungültige Konfiguration. Überprüfen Sie, ob IhreDatei suite.jsongültig ist.

120 InvalidCredentialError Ungültige AWS-Anmeldeinformationen.

ÜberprüfenSie Ihre AWS-Anmeldeinformationen.Da dieser Fehler auchvon Netzwerkproblemenverursacht werdenkann, sollten Sie IhreNetzwerkverbindungüberprüfen und den Testerneut ausführen.

494



121 AWSSessionError Eine AWS-Sitzungkonnte nicht erstelltwerden.

Dieser Fehlerkann aufgrund vonungültigen AWS-Anmeldeinformationenoder einer instabilenInternetverbindungauftreten. VersuchenSie, zum Aufrufen einerAWS API-OperationAWS CLI zu verwenden.

122 AWSApiCallError Ein AWS API-Fehler istaufgetreten.

Der Grund dafür kannein Netzwerkfehlersein. Überprüfen SieIhr Netzwerk, bevor Siedie Testgruppe erneutausführen.

123 IpNotExistError IP-Adresse ist nicht inVerbindungsinformationenenthalten.

Überprüfen Sie dieInternetverbindung. Siekönnen die AWS IoTGreengrass-Konsoleverwenden, um dieVerbindungsinformationenfür das vom Testverwendete AWS IoTGreengrass-Core-Objekt zu überprüfen.Wenn in denVerbindungsinformationen10 Endpunkte enthaltensind, können sieeinige oder alleentfernen und denTest erneut ausführen.Weitere Informationenfinden Sie unterVerbindungsinformationen.

124 OTAJobNotCompleteError Ein OTA-Auftrag wurdenicht abgeschlossen.

Überprüfen Sie IhreNetzwerkverbindungund führen Sie die OTA-Testgruppe erneut aus.

495

https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-connectivity-info.html

AWS IoT Greengrass EntwicklerhandbuchBeseitigen von Fehlern in IDT für AWS IoT Greengrass


125 CreateGreengrassServiceRoleErrorEiner der folgendenPunkte ist aufgetreten:

• Beim Erstellen einerRolle ist ein Fehleraufgetreten.

• Beim Anfügen einerRichtlinie an die AWSIoT Greengrass-Servicerolle ist einFehler aufgetreten.

• Die mit derServicerolleverknüpfte Richtlinieist ungültig.

• Beim Verknüpfeneiner Rolle mit einemAWS-Konto ist einFehler aufgetreten.

Konfigurieren Sie dieAWS IoT Greengrass-Servicerolle. WeitereInformationen finden Sieunter Konfigurieren derAWS IoT Greengrass-Servicerolle (p. 475).

126 DependenciesNotPresentErrorEine oder mehrerefür den spezifischenTest erforderlicheAbhängigkeiten sindauf dem Gerät nichtvorhanden.

Überprüfen Siedas Testprotokoll(<device-tester-extract-location>/results/ <execution-id>>/logs/<test-case-name>.log>),um festzustellen, welcheAbhängigkeiten aufIhrem Gerät fehlen.

127 InvalidHSMConfiguration Die bereitgestellte HSM/PKCS-Konfiguration istnicht korrekt.

Geben Sie in Ihrerdevice.json-Datei dierichtige Konfigurationan, die erforderlich ist,um mithilfe von PKCS#11 mit dem HSM zuinteragieren.

Beseitigen von Fehlern in IDT für AWS IoTGreengrassWenn Sie IDT verwenden, müssen Sie die richtigen Konfigurationsdateien bereitstellen, bevor Sie IDT fürAWS IoT Greengrass ausführen. Wenn Sie Parsing- und Konfigurationsfehler erhalten, müssen Sie alsErstes eine für Ihre Umgebung geeignete Konfigurationsvorlage suchen und anwenden.

Wenn weiterhin Probleme auftreten, beachten Sie den folgenden Debugging-Vorgang.

Wo suche ich?High-Level-Fehler werden während der Ausführung auf der Konsole angezeigt, und eineZusammenfassung der fehlgeschlagenen Tests wird mit dem Fehler angezeigt, wenn alle Tests

496


abgeschlossen sind. awsiotdevicetester_report.xml enthält eine Zusammenfassung aller Fehler,die zum Scheitern eines Tests geführt haben. Die Protokolldateien für jeden Testlauf werden in einemVerzeichnis mit einer UUID für die Testausführung gespeichert, die während des Testlaufs auf der Konsoleangezeigt wurde.

Der Test Protokolle befindet sich im Verzeichnis <device-tester-extract-location>/results /<uuidexecution-id>/logs/. Dieses Verzeichnis enthält die folgenden Dateien, die für dasDebugging nützlich sind.

Datei Beschreibung

test_manager.log Enthält alle Protokolle, die während derTestausführung in die Konsole geschriebenwurden. Eine Zusammenfassung der Ergebnissefinden Sie am Ende dieser Datei, die eine Liste derfehlgeschlagenen Tests enthält.

Die Warn- und Fehlerprotokolle in dieser Dateikönnen Ihnen Informationen über den/die Fehlerliefern. Wenn Sie weitere Details benötigen, lesenSie die spezifischeren Protokolle unten.

<test-name>.log Enthält detaillierte Protokolle darüber, was beimjeweiligen Test abgelaufen ist.

<test-name>_ggc_logs.tar.gz Eine komprimierte Sammlung aller Protokolle, dieder AWS IoT Greengrass-Core-Daemon währenddes Tests erzeugt hat. Weitere Informationenfinden Sie unter Fehlerbehebung in AWS IoTGreengrass.

<test-name>_ota_logs.tar.gz Diese Datei ist nur für OTA-Tests gedacht. Eshandelt sich um eine komprimierte Sammlung vonProtokollen, die vom AWS IoT Greengrass OTA-Agenten während des Tests erstellt wurden.

Parsing-FehlerEs kann vorkommen, dass ein Tippfehler in einer JSON-Konfiguration zu Parsing-Fehlern führt. In denmeisten Fällen ist die Ursache des Problems eine fehlende Klammer oder ein fehlendes Komma oderAnführungszeichen in Ihrer JSON-Datei. IDT führt eine JSON-Validierung durch und druckt Debugging-Informationen. Gedruckt werden die Zeile, in der der Fehler aufgetreten ist, sowie Zeilennummer undSpaltennummer des Syntaxfehlers. Diese Informationen sollten für die Fehlerbehebung ausreichen. SolltenSie den Fehler weiterhin nicht finden, können Sie eine Validierung manuell in Ihrer IDE, in einem Text-Editor wie Atom oder Sublime oder über ein Online-Tool wie JSONLint durchführen.

Fehler aufgrund fehlender erforderlicher ParameterDa dem IDT neue Funktionen hinzugefügt werden, kann es zu Änderungen an den Konfigurationsdateienkommen. Bei Verwendung einer alten Konfigurationsdatei kann Ihre Konfiguration beschädigt werden. Indiesem Fall listet die Datei <test_case_id>.log unter /results/<uuid>/logs explizit alle fehlendenParameter auf. IDT überprüft zudem Ihre JSON-Konfigurationsdateischemata, um sicherzustellen, dass Siedie neueste unterstützte Version verwenden.

497

https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-troubleshooting.html

https://docs.aws.amazon.com/greengrass/latest/developerguide/gg-troubleshooting.html


Fehler "Test konnte nicht gestartet werden"Möglicherweise finden Sie Hinweise auf Fehler beim Teststart. Es gibt mehrere mögliche Ursachen. GehenSie daher wie folgt vor:

• Stellen Sie sicher, dass der in Ihrem Ausführungsbefehl enthaltene Poolname tatsächlich vorhanden ist.Auf den Poolnamen wird direkt über Ihre device.json-Datei verwiesen.

• Stellen Sie sicher, dass die Geräte in Ihrem Pool über die richtigen Konfigurationsparameter verfügen.

Fehler bei abgelehnter BerechtigungIDT führt Operationen für verschiedene Verzeichnisse und Dateien auf einem zu testenden Gerät aus.Einige dieser Operationen erfordern Stammzugriff. Zum Automatisieren dieser Operationen muss IDTBefehle mit sudo ausführen können, ohne ein Passwort einzugeben.

Führen Sie die folgenden Schritte aus, um Sudo-Zugriff zu erteilen, ohne ein Passwort eingeben zumüssen.

Note

user und username beziehen sich auf den SSH-Benutzer, der von IDT für den Zugriff auf das zutestende Gerät verwendet wird.

1. Verwenden Sie sudo usermod -aG sudo <ssh-username>, um Ihren SSH-Benutzer zur sudo-Gruppehinzuzufügen.

2. Melden Sie sich ab und melden Sie sich dann wieder an, damit die Änderungen wirksam werden.3. Öffnen Sie die Datei /etc/sudoers und fügen Sie dann am Ende der Datei die folgende Zeile hinzu:

<ssh-username> ALL=(ALL) NOPASSWD: ALL

Note

Als bewährte Methode empfehlen wir, dass Sie, sudo visudo verwenden, wenn Sie /etc/sudoers bearbeiten.

SSH-VerbindungsfehlerWenn IDT keine Verbindung mit einem zu testenden Gerät herstellen kann, werden in /results/<uuid>/logs/<test-case-id>.log Verbindungsfehler protokolliert. SSH-Fehlermeldungenbefindet sich am Anfang dieser Protokolldatei, da IDT als eine der ersten Operationen eine Verbindung miteinem Gerät herstellt.

Die meisten Windows-Einrichtungen verwenden die PuTTy Terminal-Anwendung, um eine Verbindung mitLinux-Hosts herzustellen. Diese Anwendung erfordert, dass private PEM-Standardschlüsseldateien in einproprietäres Windows-Format mit dem Namen PPK konvertiert werden. Wenn IDT in Ihrer device.json-Datei konfiguriert ist, verwenden Sie nur PEM-Dateien. Wenn Sie eine PPK-Datei verwenden, kann IDTkeine SSH-Verbindung mit dem AWS IoT Greengrass-Gerät herstellen und keine Tests ausführen.

Timeout-FehlerSie können den Timeout für jeden Test erhöhen, indem Sie einen Timeout-Multiplikator angeben, der aufden Standardwert des Timeout jedes Tests angewendet wird. Jeder Wert für dieses Kennzeichen mussgrößer als oder gleich 1,0 sein.

Um den Timeout-Multiplikator zu verwenden, verwenden Sie das Flag --timeout-multiplier beimAusführen der Tests. zum Beispiel:

498


./devicetester_linux run-suite --suite-id GGQ_1 --pool-id DevicePool1 --timeout-multiplier 2.5

Führen Sie run-suite --help aus, um weitere Informationen zu erhalten.

Fehler bei OTA-Tests aufgrund eines fehlenden BefehlsSie benötigen zum Ausführen von OTA-Tests auf AWS IoT Greengrass-Geräten eine ältere Version derOpenSSL-Bibliothek (libssl1.0.0). Die meisten gängigen Linux-Verteilungen verwenden libssl Version 1.0.2oder höher (v1.1.0). Diese Versionen sind mit OTA nicht kompatibel.

Beispiel: Führen Sie auf einem Raspberry Pi die folgenden Befehle aus, um die erforderliche Version vonlibssl zu installieren:

1. wget http://ftp.us.debian.org/debian/pool/main/o/openssl/libssl1.0.0_1.0.2l-1~bpo8+1_armhf.deb2. sudo dpkg -i libssl1.0.0_1.0.2l-1~bpo8+1_armhf.deb

499

AWS IoT Greengrass EntwicklerhandbuchProbleme mit AWS IoT Greengrass Core

Fehlersuche bei AWS IoTGreengrass

Dieser Abschnitt enthält Informationen zur Fehlerbehebung und zu möglichen Lösungen für Probleme mitAWS IoT Greengrass.

Informationen zu AWS IoT Greengrass-Limits finden Sie unter AWS IoT Greengrass-Limits im AllgemeineAmazon Web Services-Referenz.

Probleme mit AWS IoT Greengrass CoreWenn die AWS IoT Greengrass Core-Software nicht gestartet wird, versuchen Sie die folgendenallgemeinen Schritte zur Fehlerbehebung:

• Stellen Sie sicher, dass Sie die Binärdateien installieren, die für Ihre Architektur geeignet sind. WeitereInformationen finden Sie unter AWS IoT Greengrass Core-Software (p. 15).

• Stellen Sie sicher, dass Ihr Core-Gerät über lokalen Speicherplatz verfügt. Weitere Informationen findenSie unter the section called “Fehlerbehebung bei Speicherproblemen” (p. 515).

• Überprüfen Sie runtime.log und crash.log auf Fehlermeldungen. Weitere Informationen finden Sieunter the section called “Fehlerbehebung mit Protokollen” (p. 514).

Durchsuchen Sie die folgenden Symptome und Fehler, um Informationen für die Behebung von Problemenmit einem AWS IoT Greengrass-Core zu finden.

Themen• Fehler: In der Konfigurationsdatei fehlt CaPath, CertPath oder KeyPath. Der Greengrass-Daemon-

Prozess mit [pid = <pid>] ist abgestürzt. (p. 501)• Fehler: Fehler beim Analysieren von /<greengrass-root>/config/config.json. (p. 501)• Fehler: Laufzeit konnte nicht gestartet werden: Es konnten keine Worker gestartet werden:

Zeitüberschreitung für den Container-Test. (p. 502)• Fehler: Aufruf von PutLogEvents in lokaler Cloudwatch-Installation nicht möglich, logGroup: /

GreengrassSystem/connection_manager, error: RequestError: send request failed caused by:Post http://<path>/cloudwatch/logs/: dial tcp <address>: getsockopt: connection refused, response:{ }. (p. 502)

• Fehler: Server konnte nicht erstellt werden: Folgende Gruppe konnte nicht geladen werden: chmod /<greengrass-root>/ggc/deployment/lambda/arn:aws:lambda:<region>:<account-id>:function:<function-name>:<version>/<file-name>: no such file or directory. (p. 503)

• Die AWS IoT Greengrass Core-Software wird nicht gestartet, nachdem Sie von der Ausführung ohneContainerisierung zur Ausführung in einem Greengrass-Container gewechselt sind. (p. 503)

• Fehler: Spulengröße sollte mindestens 262144 Bytes betragen. (p. 503)• Fehler: container_linux.go:344: Start des Container-Prozesses verursachte „process_linux.go:424:

container init caused \"rootfs_linux.go:64: mounting \\\"/greengrass/ggc/socket/greengrass_ipc.sock\\\"to rootfs \\\"/greengrass/ggc/packages/<version>/rootfs/merged\\\" at \\\"/greengrass_ipc.sock\\\" caused\\\"stat /greengrass/ggc/socket/greengrass_ipc.sock: permission denied\\\"\"“. (p. 504)

• Fehler: Greengrass-Daemon wird mit folgender PID ausgeführt: <process-id>. EinigeSystemkomponenten konnten nicht gestartet werden. Überprüfen Sie die Datei „'runtime.log“ aufFehler. (p. 504)

• Der Geräteschatten wird nicht mit der Cloud synchronisiert. (p. 504)

500


AWS IoT Greengrass EntwicklerhandbuchFehler: In der Konfigurationsdatei fehlt CaPath,

CertPath oder KeyPath. Der Greengrass-Daemon-Prozess mit [pid = <pid>] ist abgestürzt.

• Die AWS IoT Greengrass Core-Software wird auf Raspberry Pi nicht ausgeführt, da der Benutzer-Namespace nicht aktiviert ist. (p. 505)

• FEHLER: TCP-Verbindung kann nicht angenommen werden. accept tcp [::]:8000: accept4: zu vielegeöffnete Dateien. (p. 505)

• Fehler: Laufzeit-Ausführungsfehler: Lambda-Container kann nicht gestartet werden.container_linux.go:259: starting container process caused "process_linux.go:345: container init caused\"rootfs_linux.go:50: preparing rootfs caused \\\"permission denied\\\"\"". (p. 505)

• Warnung: [WARN]-[5]GK Remote: Fehler beim Abrufen von Daten zu öffentlichen Schlüsseln.ErrPrincipalNotConfigured: Kein privater Schlüssel für MqttCertificate festgelegt. (p. 506)

• Fehler: Berechtigung abgelehnt für Verwendung der Rolle arn:aws:iam::<account-id>:role/<role-name> to access s3 url https://<region>-greengrass-updates.s3.<region>.amazonaws.com/core/<architecture>/greengrass-core-<distribution-version>.tar.gz. (p. 506)

• Das AWS IoT Greengrass-Core ist so konfiguriert, dass ein Netzwerk-Proxy verwendet wird und IhreLambda-Funktion kann keine ausgehenden Verbindungen herstellen. (p. 506)

• Der Core befindet sich in einer unendlichen Verbinden-Trennen-Schleife. Die Datei „runtime.log“ enthälteine fortlaufende Reihe von Verbinden- und Trennen-Einträgen. (p. 507)

Fehler: In der Konfigurationsdatei fehlt CaPath,CertPath oder KeyPath. Der Greengrass-Daemon-Prozess mit [pid = <pid>] ist abgestürzt.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung in crash.log angezeigt, wenn die AWS IoTGreengrass Core-Software nicht gestartet wird. Dies kann der Fall sein, wenn Sie Version 1.6 oder früherausführen. Führen Sie einen der folgenden Schritte aus:

• Aktualisieren Sie auf v1.7 or later. Sie sollten stets die neueste Version der AWS IoT GreengrassCore-Software ausführen. Informationen zum Download finden Sie unter AWS IoT Greengrass Core-Software (p. 15).

• Verwenden Sie das richtige config.json-Format für Ihre AWS IoT Greengrass Core-Softwareversion. Weitere Informationen finden Sie unter the section called “AWS IoT Greengrass-Core-Konfigurationsdatei” (p. 23).

Note

Um festzustellen, welche Version der AWS IoT Greengrass Core-Software auf dem Core-Gerätinstalliert ist, führen Sie in Ihrem Geräteterminal die folgenden Befehle aus.

cd /greengrass-root/ggc/core/sudo ./greengrassd --version

Fehler: Fehler beim Analysieren von /<greengrass-root>/config/config.json.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT Greengrass Core-Software nicht gestartet wird. Stellen Sie sicher, dass die Greengrass-Konfigurationsdatei (p. 23) eingültiges JSON-Format verwendet.

501

AWS IoT Greengrass EntwicklerhandbuchFehler: Laufzeit konnte nicht gestartet werden:

Es konnten keine Worker gestartet werden:Zeitüberschreitung für den Container-Test.

Öffnen Sie config.json (im Verzeichnis /greengrass-root/config) und validieren Sie das JSON-Format. Stellen Sie z. B. sicher, dass Kommas korrekt verwendet werden.

Fehler: Laufzeit konnte nicht gestartet werden:Es konnten keine Worker gestartet werden:Zeitüberschreitung für den Container-Test.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT GreengrassCore-Software nicht gestartet wird. Legen Sie die Eigenschaft postStartHealthCheckTimeout in derGreengrass-Konfigurationsdatei (p. 23) fest. Diese optionale Eigenschaft konfiguriert die Zeitspanne (inMillisekunden), die der Greengrass-Daemon auf das Ende der Zustandsprüfung nach dem Start wartet. DerStandardwert ist 30 Sekunden (30.000 ms).

Öffnen Sie config.json (im Verzeichnis /greengrass-root/config). Fügen Sie im Objekt runtimedie Eigenschaft postStartHealthCheckTimeout hinzu und stellen Sie den Wert auf eine Zahl größerals 30000 ein. Fügen Sie gegebenenfalls ein Komma ein, um eine gültige JSON-Datei zu erstellen. ZumBeispiel:

... "runtime" : { "cgroup" : { "useSystemd" : "yes" }, "postStartHealthCheckTimeout" : 40000 }, ...

Fehler: Aufruf von PutLogEvents in lokalerCloudwatch-Installation nicht möglich, logGroup: /GreengrassSystem/connection_manager, error:RequestError: send request failed caused by: Posthttp://<path>/cloudwatch/logs/: dial tcp <address>:getsockopt: connection refused, response: { }.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT Greengrass Core-Software nicht gestartet wird. Dies kann der Fall sein, wenn Sie AWS IoT Greengrass auf einem RaspberryPi mit dem Betriebssystem Raspbian Stretch ausführen und die erforderliche Speichereinrichtung nichtabgeschlossen wurde. Weitere Informationen finden Sie in diesem Schritt (p. 74).

502

AWS IoT Greengrass EntwicklerhandbuchFehler: Server konnte nicht erstellt werden: Folgende

Gruppe konnte nicht geladen werden: chmod /<greengrass-root>/ggc/deployment/lambda/

arn:aws:lambda:<region>:<account-id>:function:<function-name>:<version>/<file-name>: no such file or directory.Fehler: Server konnte nicht erstellt werden:

Folgende Gruppe konnte nicht geladen werden:chmod /<greengrass-root>/ggc/deployment/lambda/arn:aws:lambda:<region>:<account-id>:function:<function-name>:<version>/<file-name>:no such file or directory.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT Greengrass Core-Software nicht gestartet wird. Wenn Sie eine Ausführbare Lambda-Datei (p. 190) im Core bereitgestellthaben, prüfen Sie die Eigenschaft Handler der Funktion in der Datei group.json (in /greengrass-root/ggc/deployment/group). Wenn der Handler nicht genau dem Namen Ihrer kompilierten ausführbarenDatei entspricht, ersetzen Sie den Inhalt der Datei group.json durch ein leeres JSON-Objekt ({}) undführen Sie die folgenden Befehle zum Starten von AWS IoT Greengrass aus:


Verwenden Sie dann die AWS Lambda-API, um den handler-Parameter der Funktionskonfigurationzu aktualisieren, eine neue Funktionsversion zu veröffentlichen und den Alias zu aktualisieren. WeitereInformationen finden Sie unter AWS Lambda Funktion-Versioning und Aliasse.

Vorausgesetzt, Sie haben die Funktion Ihrer Greengrass-Gruppe per Alias hinzugefügt (empfohlen),können Sie Ihre Gruppe jetzt erneut bereitstellen. (Ist dies nicht der Fall, müssen Sie auf die neue Versionoder den Alias der Funktion in Ihrer Gruppendefinition und Ihren Abonnements verweisen, bevor Sie dieGruppe bereitstellen).

Die AWS IoT Greengrass Core-Software wirdnicht gestartet, nachdem Sie von der Ausführungohne Containerisierung zur Ausführung in einemGreengrass-Container gewechselt sind.Lösung: Prüfen Sie, ob Container-Abhängigkeiten fehlen.

Fehler: Spulengröße sollte mindestens 262144 Bytesbetragen.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT Greengrass Core-Software nicht gestartet wird. Öffnen Sie die Datei group.json (im Verzeichnis /greengrass-root/ggc/deployment/group), ersetzen Sie den Inhalt der Datei mit einem leeren JSON-Objekt ({}) undführen Sie die folgenden Befehle aus, um AWS IoT Greengrass zu starten:


503

https://docs.aws.amazon.com/cli/latest/reference/lambda/


AWS IoT Greengrass EntwicklerhandbuchFehler: container_linux.go:344: Start des Container-

Prozesses verursachte „process_linux.go:424: containerinit caused \"rootfs_linux.go:64: mounting \\\"/greengrass/

ggc/socket/greengrass_ipc.sock\\\" to rootfs \\\"/greengrass/ggc/packages/<version>/rootfs/merged\\\" at \\\"/

greengrass_ipc.sock\\\" caused \\\"stat /greengrass/ggc/socket/greengrass_ipc.sock: permission denied\\\"\"“.

Anschließend befolgen Sie die Schritte im Verfahren the section called “So speichern Sie Nachrichtenim lokalen Speicher” (p. 59). Stellen Sie für die GGCloudSpooler-Funktion sicher, dass Sie einenGG_CONFIG_MAX_SIZE_BYTES-Wert angeben, der größer als oder gleich 262144.

Fehler: container_linux.go:344: Start des Container-Prozesses verursachte „process_linux.go:424:container init caused \"rootfs_linux.go:64: mounting \\\"/greengrass/ggc/socket/greengrass_ipc.sock\\\" torootfs \\\"/greengrass/ggc/packages/<version>/rootfs/merged\\\" at \\\"/greengrass_ipc.sock\\\" caused \\\"stat /greengrass/ggc/socket/greengrass_ipc.sock:permission denied\\\"\"“.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung in runtime.log angezeigt, wenn die AWSIoT Greengrass Core-Software nicht gestartet wird. Dies tritt auf, wenn Ihr umask höher ist als 0022.Sie müssen umask auf 0022 oder niedriger festlegen, um das Problem zu beheben. Ein Wert von 0022gewährt standardmäßig jeder Person Leseberechtigung für neue Dateien.

Fehler: Greengrass-Daemon wird mit folgender PIDausgeführt: <process-id>. Einige Systemkomponentenkonnten nicht gestartet werden. Überprüfen Sie dieDatei „'runtime.log“ auf Fehler.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung angezeigt, wenn die AWS IoT GreengrassCore-Software nicht gestartet wird. Überprüfen Sie runtime.log und crash.log auf spezifischeFehlerinformationen. Weitere Informationen finden Sie unter the section called “Fehlerbehebung mitProtokollen” (p. 514).

Der Geräteschatten wird nicht mit der Cloudsynchronisiert.Lösung: Stellen Sie sicher, dass AWS IoT Greengrass Berechtigungen für die Aktioneniot:UpdateThingShadow und iot:GetThingShadow in der Greengrass-Servicerolle (p. 432)besitzen. Wenn die Servicerolle die verwaltete Richtlinie AWSGreengrassResourceAccessRolePolicyverwendet, sind diese Berechtigungen standardmäßig enthalten.

Siehe Beheben von Timeout-Problemen während der Schattensynchronisierung (p. 515).

504

AWS IoT Greengrass EntwicklerhandbuchDie AWS IoT Greengrass Core-Software

wird auf Raspberry Pi nicht ausgeführt, dader Benutzer-Namespace nicht aktiviert ist.

Die AWS IoT Greengrass Core-Software wird aufRaspberry Pi nicht ausgeführt, da der Benutzer-Namespace nicht aktiviert ist.Lösung: Diese Lösung gilt nur für Jessie Raspbian-Distributionen. Führen Sie diesen Befehl nicht inStretch-Distributionen aus. Benutzer-Namespaces sind in Stretch-Distributionen standardmäßig aktiviert.

Führen Sie auf dem Jessie-Gerät BRANCH=stable rpi-update aus, um auf die neuesten stabilenVersionen von Firmware und Kernel zu aktualisieren.

Note

Support für Benutzer-Namespace ist erforderlich für die Ausführung von AWS IoT Greengrass imStandard-Greengrass container-Modus. Es ist nicht erforderlich, dass es im No container-Modus ausgeführt wird. Weitere Informationen finden Sie unter the section called “Überlegungenbei der Auswahl der Containerisierung von Lambda-Funktionen” (p. 182).

FEHLER: TCP-Verbindung kann nicht angenommenwerden. accept tcp [::]:8000: accept4: zu vielegeöffnete Dateien.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung in der greengrassd-Skriptausgabe angezeigt.Dies kann auftreten, wenn das Dateideskriptor-Limit für die AWS IoT Greengrass Core-Software denSchwellenwert erreicht hat und erhöht werden muss.

Verwenden Sie den folgenden Befehl und starten Sie anschließend die AWS IoT Greengrass Core-Software neu.

ulimit -n 2048

Note

In diesem Beispiel wird das Limit auf 2048 erhöht. Wählen Sie einen für Ihren Anwendungsfallgeeigneten Wert.

Fehler: Laufzeit-Ausführungsfehler: Lambda-Container kann nicht gestartet werden.container_linux.go:259: starting container processcaused "process_linux.go:345: container init caused\"rootfs_linux.go:50: preparing rootfs caused \\\"permission denied\\\"\"".Lösung: Installieren Sie AWS IoT Greengrass direkt im Stammverzeichnis oder stellen Sie sicher, dassdas Verzeichnis, in dem die AWS IoT Greengrass Core-Software und ihre übergeordneten Verzeichnisseinstalliert sind, allen Benutzern execute-Berechtigungen erteilen.

505

AWS IoT Greengrass EntwicklerhandbuchWarnung: [WARN]-[5]GK Remote: Fehler beim Abrufen von

Daten zu öffentlichen Schlüsseln. ErrPrincipalNotConfigured:Kein privater Schlüssel für MqttCertificate festgelegt.

Warnung: [WARN]-[5]GK Remote: Fehler beimAbrufen von Daten zu öffentlichen Schlüsseln.ErrPrincipalNotConfigured: Kein privater Schlüssel fürMqttCertificate festgelegt.Lösung: AWS IoT Greengrass verwendet einen gemeinsamen Handler zum Validieren der Eigenschaftenaller Sicherheitsprinzipale. Diese Warnmeldung in runtime.log wird erwartet, es sei denn, Siehaben einen benutzerdefinierten privaten Schlüssel für den lokalen MQTT-Server angegeben. WeitereInformationen finden Sie unter the section called “Sicherheitsprinzipale” (p. 428).

Fehler: Berechtigung abgelehnt für Verwendungder Rolle arn:aws:iam::<account-id>:role/<role-name> to access s3 url https://<region>-greengrass-updates.s3.<region>.amazonaws.com/core/<architecture>/greengrass-core-<distribution-version>.tar.gz.Lösung: Möglicherweise wird Ihnen dieser Fehler angezeigt, wenn eine Over-the-Air (OTA)-Aktualisierungfehlschlägt. Fügen Sie in der Signer-Rollenrichtlinie die AWS Region als Resource hinzu. Diese Signer-Rolle wird zum Vorsignieren der S3-URL zur Aktualisierung der AWS IoT Greengrass-Software verwendet.Weitere Informationen finden Sie unter S3-URL-Signer-Rolle (p. 160).

Das AWS IoT Greengrass-Core ist so konfiguriert,dass ein Netzwerk-Proxy (p. 49) verwendet wird undIhre Lambda-Funktion kann keine ausgehendenVerbindungen herstellen.Lösung: Abhängig von Ihrer Laufzeit und den ausführbaren Dateien, die von der Lambda-Funktion zumErstellen von Verbindungen verwendet werden, erhalten Sie möglicherweise Verbindungs-Timeout-Fehler.Stellen Sie sicher, dass Ihre Lambda-Funktionen die entsprechende Proxy-Konfiguration verwenden,um eine Verbindung über den Netzwerk-Proxy herzustellen. AWS IoT Greengrass übergibt die Proxy-Konfiguration an benutzerdefinierte Lambda-Funktionen durch die Umgebungsvariablen http_proxy,https_proxy und no_proxy. Sie können, wie im folgenden Python-Ausschnitt gezeigt, aufgerufenwerden.

import osprint(os.environ['HTTP_PROXY'])

506

AWS IoT Greengrass EntwicklerhandbuchDer Core befindet sich in einer unendlichen Verbinden-Trennen-Schleife. Die Datei „runtime.log“ enthält eine

fortlaufende Reihe von Verbinden- und Trennen-Einträgen.Note

Die meisten gängigen Bibliotheken, die verwendet werden, um Verbindungen (z. B. boto3 odercURL und Python-requests-Pakete) herzustellen, verwenden diese Umgebungsvariablenstandardmäßig.

Der Core befindet sich in einer unendlichenVerbinden-Trennen-Schleife. Die Datei „runtime.log“enthält eine fortlaufende Reihe von Verbinden- undTrennen-Einträgen.Lösung: Dies kann auftreten, wenn ein anderes Gerät für die Verwendung des Core-Dingnamens alsClient-ID für MQTT-Verbindungen mit AWS IoT hartkodiert ist. Gleichzeitige Verbindungen in derselbenAWS-Region und im selben AWS-Konto müssen eindeutige Client-IDs verwenden. Standardmäßigverwendet der Kern den Core-Objektnamen als Client-ID für diese Verbindungen.

Zur Behebung dieses Problems können Sie die Client-ID ändern, die vom anderen Gerät für dieVerbindung verwendet wird (empfohlen) oder den Standardwert für den Core überschreiben.

So überschreiben Sie die standardmäßige Client-ID für das Core-Gerät



2. Öffnen Sie greengrass-root/config/config.json zur Bearbeitung als su-Benutzer.3. Fügen Sie im coreThing-Objekt die coreClientId-Eigenschaft hinzu und legen Sie für den Wert

Ihre benutzerdefinierte Client-ID fest. Der Wert muss zwischen 1 und 128 Zeichen enthalten. Er mussin der aktuellen AWS-Region für das AWS-Konto eindeutig sein.

"coreClientId": "MyCustomClientId"



BereitstellungsproblemeIm Folgenden finden Sie Informationen zur Behebung von Problemen mit der Bereitstellung.

Themen• Für die Bereitstellung wird der Fehler „403 Forbidden” in den Protokollen angezeigt. (p. 508)• Der Fehler „ConcurrentDeployment“ tritt auf, wenn Sie den Befehl create-deployment zum ersten Mal

ausführen. (p. 508)

507

AWS IoT Greengrass EntwicklerhandbuchFür die Bereitstellung wird der Fehler „403Forbidden” in den Protokollen angezeigt.

• Fehler: Greengrass ist nicht zur Übernahme der Servicerolle berechtigt, die mit diesem Konto verknüpftist; oder derFehler: Fehlgeschlagen: TES-Servicerolle ist nicht mit diesem Konto verknüpft. (p. 508)

• Die Bereitstellung wird nicht abgeschlossen. (p. 509)• Die Bereitstellung wird nicht fertiggestellt und „runtime.log“ enthält mehrere Einträge für „1 Sekunde auf

Anhalten des Containers gewartet“. (p. 509)• Fehler: Bereitstellung <guid> of type NewDeployment for group <guid> fehlgeschlagen; Fehler: Fehler

beim Verarbeiten. Gruppenkonfiguration ist ungültig: 112 oder [119 0] besitzen keine Lese- undSchreibberechtigungen für die Datei: <path>. (p. 509)

• Fehler: <list-of-function-arns> ist für die Ausführung als Stamm konfiguriert; Greengrass ist jedoch nichtfür die Ausführung von Lambda-Funktionen mit Root-Berechtigungen konfiguriert. (p. 510)

• Fehler: Bereitstellung <deployment-id> des Typs NewDeployment für Gruppe <group-id>fehlgeschlagen; Fehler: Verarbeitungsstart fehlgeschlagen: container_linux.go:259: Start desContainer-Prozesses verursachte „process_linux.go:250: running exec setns process for init caused\"wait: no child processes\"“. (p. 510)

Für die Bereitstellung wird der Fehler „403 Forbidden”in den Protokollen angezeigt.Lösung: Stellen Sie sicher, dass die Richtlinie des AWS IoT Greengrass-Core in der Cloud"greengrass:*" als zulässige Aktion enthält.

Der Fehler „ConcurrentDeployment“ tritt auf, wennSie den Befehl create-deployment zum ersten Malausführen.Lösung: Möglicherweise wird eine Bereitstellung verarbeitet. Sie können get-deployment-status ausführen,um zu prüfen, ob eine Bereitstellung erstellt wurde. Falls nicht, versuchen Sie erneut, die Bereitstellung zuerstellen.

Fehler: Greengrass ist nicht zur Übernahme derServicerolle berechtigt, die mit diesem Konto verknüpftist; oder derFehler: Fehlgeschlagen: TES-Servicerolleist nicht mit diesem Konto verknüpft.Lösung: Möglicherweise wird Ihnen dieser Fehler angezeigt, wenn die Bereitstellung fehlschlägt.Verwenden Sie den Befehl get-service-role-for-account in der AWS CLI, um zu prüfen, ob mit IhremAWS-Konto in der aktuellen AWS-Region eine geeignete Servicerolle verknüpft ist. Um eine Greengrass-Servicerolle mit Ihrem AWS-Konto in der AWS-Zielregion zu verknüpfen, verwenden Sie associate-service-role-to-account. Weitere Informationen finden Sie unter the section called “Greengrass-Servicerolle” (p. 432).

508

https://docs.aws.amazon.com/greengrass/latest/apireference/getdeploymentstatus-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/getserviceroleforaccount-get.html

https://docs.aws.amazon.com/greengrass/latest/apireference/associateserviceroletoaccount-put.html

https://docs.aws.amazon.com/greengrass/latest/apireference/associateserviceroletoaccount-put.html

AWS IoT Greengrass EntwicklerhandbuchDie Bereitstellung wird nicht abgeschlossen.

Die Bereitstellung wird nicht abgeschlossen.Lösung: Führen Sie die folgenden Schritte aus:

• Stellen Sie sicher, dass der AWS IoT Greengrass-Daemon auf Ihrem Code-Gerät ausgeführt wird.Führen Sie die folgenden Befehle auf Ihrem Core-Geräteterminal aus, um zu prüfen, ob der Daemonausgeführt wird, und starten Sie ihn gegebenenfalls.

1. So prüfen Sie, ob der Daemon ausgeführt wird:


Wenn die Ausgabe einen root-Eintrag für /greengrass/ggc/packages/1.9.3/bin/daemonenthält, dann wird der Daemon ausgeführt.

Die Version in dem Pfad hängt von der AWS IoT Greengrass-Core-Softwareversion ab, die aufIhrem Core-Gerät installiert ist.

2. So starten Sie den Daemon:


• Stellen Sie sicher, dass Ihr Core-Gerät verbunden ist und die Core-Verbindungsendpunkteordnungsgemäß konfiguriert sind.

Die Bereitstellung wird nicht fertiggestellt und„runtime.log“ enthält mehrere Einträge für „1 Sekundeauf Anhalten des Containers gewartet“.Lösung: Führen Sie folgende Befehle in Ihrem Core-Geräteterminal aus, um den AWS IoT Greengrass-Daemon neu zu starten.

cd /greengrass/ggc/core/sudo ./greengrassd stopsudo ./greengrassd start

Fehler: Bereitstellung <guid> of type NewDeploymentfor group <guid> fehlgeschlagen; Fehler: Fehlerbeim Verarbeiten. Gruppenkonfiguration istungültig: 112 oder [119 0] besitzen keine Lese- undSchreibberechtigungen für die Datei: <path>.Lösung: Stellen Sie sicher, dass die Besitzergruppe des Verzeichnisses <path> über Lese- undSchreibberechtigungen für das Verzeichnis verfügt.

509

AWS IoT Greengrass EntwicklerhandbuchFehler: <list-of-function-arns> ist für die

Ausführung als Stamm konfiguriert; Greengrassist jedoch nicht für die Ausführung von Lambda-Funktionen mit Root-Berechtigungen konfiguriert.

Fehler: <list-of-function-arns> ist für die Ausführungals Stamm konfiguriert; Greengrass ist jedoch nichtfür die Ausführung von Lambda-Funktionen mit Root-Berechtigungen konfiguriert.Lösung: Möglicherweise wird Ihnen diese Fehlermeldung in runtime.log angezeigt, wenn dieBereitstellung fehlschlägt. Stellen Sie sicher, dass Sie AWS IoT Greengrass so konfiguriert haben,dass Lambda-Funktionen mit Root-Berechtigungen ausgeführt werden können. Ändern Sie den WertallowFunctionsToRunAsRoot in greengrass_root/config/config.json auf yes oder ändernSie die Lambda-Funktion zur Ausführung als anderer Benutzer/Gruppe. Weitere Informationen finden Sieunter the section called “Ausführen einer Lambda-Funktion als Root” (p. 181).

Fehler: Bereitstellung <deployment-id> desTyps NewDeployment für Gruppe <group-id>fehlgeschlagen; Fehler: Verarbeitungsstartfehlgeschlagen: container_linux.go:259:Start des Container-Prozesses verursachte„process_linux.go:250: running exec setns process forinit caused \"wait: no child processes\"“.Lösung: Möglicherweise wird Ihnen dieser Fehler angezeigt, wenn die Bereitstellung fehlschlägt.Wiederholen Sie die Bereitstellung.

Probleme beim Erstellen der Gruppe oder FunktionVerwenden Sie die folgenden Informationen für die Behandlung von Problemen beim Erstellen einer AWSIoT Greengrass-Gruppe- oder Greengrass Lambda-Funktion.

Themen• Fehler: Die „IsolationMode“-Konfiguration für die Gruppe ist ungültig. (p. 511)• Fehler: Die „IsolationMode“-Konfiguration für die Funktion mit dem ARN <function-arn> ist

ungültig. (p. 511)• Fehler: MemorySize-Konfiguration für die Funktion mit dem ARN <function-arn> ist in

IsolationMode=NoContainer nicht zulässig. (p. 511)• Fehler: Der Zugriff auf die Sysfs-Konfiguration ist für die Funktion mit dem ARN <function-arn> in

IsolationMode=NoContainer nicht zulässig. (p. 511)• Fehler: Die MemorySize-Konfiguration für die Funktion mit dem ARN <function-arn> ist in

IsolationMode=GreengrassContainer erforderlich. (p. 512)

510

AWS IoT Greengrass EntwicklerhandbuchFehler: Die „IsolationMode“-

Konfiguration für die Gruppe ist ungültig.

• Fehler: Funktion <function-arn> bezieht sich auf eine Ressource des Typs <resource-type>, die inIsolationMode=NoContainer nicht zulässig ist. (p. 512)

• Fehler: Die Ausführungskonfiguration für die Funktion mit dem ARN <function-arn> ist nichtzulässig. (p. 512)

Fehler: Die „IsolationMode“-Konfiguration für dieGruppe ist ungültig.Lösung: Dieser Fehler tritt auf, wenn der Wert IsolationMode in der DefaultConfig von function-definition-version nicht unterstützt wird. Unterstützte Werte sind GreengrassContainer undNoContainer.

Fehler: Die „IsolationMode“-Konfiguration für dieFunktion mit dem ARN <function-arn> ist ungültig.Lösung: Dieser Fehler tritt auf, wenn der Wert IsolationMode in <function-arn> der function-definition-version nicht unterstützt wird. Unterstützte Werte sind GreengrassContainer undNoContainer.

Fehler: MemorySize-Konfiguration für dieFunktion mit dem ARN <function-arn> ist inIsolationMode=NoContainer nicht zulässig.Lösung: Dieser Fehler tritt auf, wenn Sie einen Wert für MemorySize angeben und die Ausführung ohneContainerisierung wählen. Für Lambda-Funktionen, die ohne Containerisierung ausgeführt werden, könnenkeine Arbeitsspeicher-Limits festgelegt werden. Sie können entweder das Limit aufheben oder die Lambda-Funktion zur Ausführung in einem AWS IoT Greengrass-Container ändern.

Fehler: Der Zugriff auf die Sysfs-Konfiguration istfür die Funktion mit dem ARN <function-arn> inIsolationMode=NoContainer nicht zulässig.Lösung: Dieser Fehler tritt auf, wenn Sie true in AccessSysfs angeben und die Ausführung ohneContainerisierung wählen. Der Code von Lambda-Funktionen, die ohne Containerisierung ausgeführtwerden, muss aktualisiert werden, um einen direkten Zugriff auf das Dateisystem zuzulassen und darfAccessSysfs nicht verwenden. Sie können entweder für AccessSysfs den Wert false angeben oderdie Lambda-Funktion zur Ausführung in einem AWS IoT Greengrass-Container ändern.

511

AWS IoT Greengrass EntwicklerhandbuchFehler: Die MemorySize-Konfiguration für dieFunktion mit dem ARN <function-arn> ist in

IsolationMode=GreengrassContainer erforderlich.

Fehler: Die MemorySize-Konfiguration für dieFunktion mit dem ARN <function-arn> ist inIsolationMode=GreengrassContainer erforderlich.Lösung: Dieser Fehler tritt auf, da Sie für eine Lambda-Funktion, die Sie in einem AWS IoT Greengrass-Container ausführen, kein MemorySize-Limit angegeben haben. Geben Sie einen MemorySize-Wert an,um den Fehler zu beheben.

Fehler: Funktion <function-arn> bezieht sich aufeine Ressource des Typs <resource-type>, die inIsolationMode=NoContainer nicht zulässig ist.Lösung: Sie können auf die Ressourcentypen Local.Device, Local.Volume,ML_Model.SageMaker.Job, ML_Model.S3_Object oder S3_Object.Generic_Archivenicht zgureifen, wenn Sie eine Lambda-Funktion ohne Containerisierung ausführen. Wenn Sie dieseRessourcentypen benötigen, müssen Sie die Funktion in einem AWS IoT Greengrass-Container ausführen.Sie können bei der Ausführung ohne Containerisierung auch direkt auf lokale Geräte zugreifen, indem Sieden Code in Ihrer Lambda-Funktion entsprechend ändern.

Fehler: Die Ausführungskonfiguration für die Funktionmit dem ARN <function-arn> ist nicht zulässig.Lösung: Dieser Fehler tritt auf, wenn Sie eine Lambda-Systemfunktion mit GGIPDetector oderGGCloudSpooler erstellen und die Konfiguration IsolationMode oder RunAs angegeben haben. Siemüssen die Ausführungsparameter Execution für diese Lambda-Systemfunktion weglassen.

AWS IoT Greengrass Probleme mit Core in DockerVerwenden Sie die folgenden Informationen zur Behebung von Problemen beim Ausführen eines AWS IoTGreengrass-Core in einem Docker-Container.

Themen• Fehler: Unbekannte Optionen: -no-include-email (p. 201)• Warnung: IPv4 ist deaktiviert. Das Netzwerk wird nicht funktionieren. (p. 201)• Fehler: Eine Firewall blockiert die Freigabe von Dateien zwischen Fenstern und den

Containern. (p. 202)• Fehler: Container kann für den Greengrass-Service nicht erstellt werden: Konflikt. Der Containername

„/ aws-iot-greengrass“ wird bereits verwendet. (p. 513)• Fehler: [FATAL] -Fehler beim Zurücksetzen des Mount-Namespace des Threads aufgrund eines

unerwarteten Fehlers: „Vorgang nicht zulässig“. Zur Sicherstellung der Konsistenz wird GGC abstürzenund manuell neu gestartet werden. (p. 514)

512

AWS IoT Greengrass EntwicklerhandbuchFehler: Unbekannte Optionen: -no-include-email

Fehler: Unbekannte Optionen: -no-include-emailLösung: Dieser Fehler kann auftreten, wenn Sie den Befehl aws ecr get-login ausführen. StellenSie sicher, dass die neueste AWS CLI-Version (z. B. run: pip install awscli --upgrade --user) installiert ist. Wenn Sie Windows verwenden und die CLI mit dem MSI-Installationsprogramminstalliert haben, müssen Sie den Installationsvorgang wiederholen. Weitere Informationen finden Sie unterInstallieren der AWS Command Line Interface unter Microsoft Windows im Benutzerhandbuch für AWSCommand Line Interface.

Warnung: IPv4 ist deaktiviert. Das Netzwerk wird nichtfunktionieren.Lösung: Sie können diese Warnung oder eine ähnliche Nachricht erhalten, wenn Sie AWS IoT Greengrassauf einem Linux-Computer ausführen. Aktivieren Sie die IPv4-Netzwerkweiterleitung wie in diesemSchritt (p. 194) beschrieben. Die AWS IoT Greengrass-Cloud Bereitstellung und MQTT-Kommunikationsind nicht funktionsfähig, wenn die IPv4-Weiterleitung nicht aktiviert ist. Weitere Informationen finden Sieunter Configure namespaced kernel parameters (sysctls) at runtime in der Docker-Dokumentation.

Fehler: Eine Firewall blockiert die Freigabe vonDateien zwischen Fenstern und den Containern.Lösung: Sie können diese Fehlermeldung oder eine Firewall Detected-Nachricht erhalten, wenn SieDocker auf einem Windows-Computer ausführen. Siehe Docker-Support-Fall Error: A firewall is blocking filesharing between Windows and the containers. Dies kann auch auftreten, wenn Sie an einem Virtual PrivateNetwork (VPN) angemeldet sind und Ihre Netzwerkeinstellungen die Bereitstellung des freigegebenenLaufwerks verhindern. Deaktivieren Sie in diesem Fall das VPN und führen Sie den Docker-Containererneut aus.

Fehler: Container kann für den Greengrass-Servicenicht erstellt werden: Konflikt. Der Containername „/aws-iot-greengrass“ wird bereits verwendet.Lösung: Dies kann auftreten, wenn der Containername von einem älteren Container verwendet wird. Umdieses Problem zu beheben, führen Sie den folgenden Befehl aus, um den alten Docker-Container zuentfernen:

docker rm -f $(docker ps -a -q -f "name=aws-iot-greengrass")

513

https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html

https://docs.docker.com/engine/reference/commandline/run/#configure-namespaced-kernel-parameters-sysctls-at-runtime



AWS IoT Greengrass EntwicklerhandbuchFehler: [FATAL] -Fehler beim Zurücksetzen desMount-Namespace des Threads aufgrund einesunerwarteten Fehlers: „Vorgang nicht zulässig“.

Zur Sicherstellung der Konsistenz wird GGCabstürzen und manuell neu gestartet werden.Fehler: [FATAL] -Fehler beim Zurücksetzen des

Mount-Namespace des Threads aufgrund einesunerwarteten Fehlers: „Vorgang nicht zulässig“. ZurSicherstellung der Konsistenz wird GGC abstürzenund manuell neu gestartet werden.Lösung: Dieser Fehler in runtime.log kann beim Versuch auftreten, eine GreengrassContainerLambda-Funktion zu einem in einem Docker-Container ausgeführten AWS IoT Greengrass-Corebereitzustellen. Derzeit können nur NoContainer Lambda-Funktionen auf einen Greengrass-Docker-Container bereitgestellt werden.

Um dieses Problem zu lösen, stellen Sie sicher, dass alle Lambda-Funktionen im ModusNoContainer (p. 184) sind und starten Sie eine neue Bereitstellung. Wenn Sie dann den Containerstarten, erstellen Sie für das vorhandene deployment-Verzeichnis keinen Bind-Mount auf den AWS IoTGreengrass-Core-Docker-Container. Erstellen Sie stattdessen ein leeres deployment-Verzeichnis anseiner Stelle und fügen Sie es über Bind-Mount im Docker-Container ein. Auf diese Weise kann der neueDocker-Container die neueste Bereitstellung mit Lambda-Funktionen im NoContainer-Modus empfangen.

Weitere Informationen finden Sie unter the section called “Ausführen von AWS IoT Greengrass in einemDocker-Container” (p. 192).

Fehlerbehebung mit ProtokollenWenn Protokolle so konfiguriert sind, dass sie auf dem lokalen Dateisystem gespeichert werden, beginnenSie in den folgenden Speicherorten mit der Suche. Das Lesen der Protokolle auf dem Dateisystem erfordertRoot-Berechtigungen.

greengrass-root/ggc/var/log/crash.log

Zeigt Nachrichten an, die bei einem Absturz einer AWS IoT Greengrass-Core generiert wurden.greengrass-root/ggc/var/log/system/runtime.log

Zeigt Nachrichten zu den fehlgeschlagenen Komponenten an.greengrass-root/ggc/var/log/system/

Enthält alle Protokolle von AWS IoT Greengrass-Systemkomponenten, wie zum Beispiel vomCertificate Manager und vom Connection Manager. Mit den Meldungen in ggc/var/log/system/und ggc/var/log/system/runtime.log, sollten Sie ermitteln können, welcher Fehler in AWS IoTGreengrass-Systemkomponenten aufgetreten ist.

greengrass-root/ggc/var/log/user/

Enthält alle Protokolle aus benutzerdefinierten Lambda-Funktionen. Überprüfen Sie diesen Ordner, umFehlermeldungen von Ihren lokalen Lambda-Funktionen zu finden.

Note

Das Standardverzeichnis von /greengrass ist greengrass-root. Wenn einSchreibverzeichnis (p. 55) konfiguriert wurde, finden Sie auch die Protokolle dort.

Wenn die Protokolle für die Speicherung in der Cloud konfiguriert sind, verwenden Sie CloudWatch Logs,um die Protokollmeldungen anzuzeigen. Die Datei crash.log ist nur in Dateisystemprotokollen auf demAWS IoT Greengrass-Core-Gerät zu finden.

514

AWS IoT Greengrass EntwicklerhandbuchFehlerbehebung bei Speicherproblemen

Wenn AWS IoT so konfiguriert ist, dass Protokolle in CloudWatch geschrieben werden, prüfen Sie dieseProtokolle, falls Verbindungsfehler auftreten, wenn Systemkomponenten versuchen, eine Verbindung zuAWS IoT aufzubauen.

Weitere Informationen zur AWS IoT Greengrass-Protokollierung finden Sie unter Überwachung (p. 444).Note

Protokolle für die AWS IoT Greengrass Core-Software v1.0 werden im Verzeichnis greengrass-root/var/log gespeichert.

Fehlerbehebung bei SpeicherproblemenWenn der lokale Dateispeicher voll ist, schlagen einige Komponenten möglicherweise fehl:

• Es werden keine Updates von lokalen Schatten ausgeführt.• Neue AWS IoT Greengrass-Core-MQTT-Serverzertifikate können nicht lokal heruntergeladen werden.• Die Bereitstellung schlägt fehl.

Sie sollten immer wissen, wie viel lokaler Speicherplatz verfügbar ist. Sie können den freien Speicherplatzbasierend auf der Größe der bereitgestellten Lambda-Funktionen, der Protokollierungskonfiguration (sieheFehlerbehebung mit Protokollen (p. 514)) und der Anzahl der lokal gespeicherten Schatten berechnen.

Fehlerbehebung für NachrichtenAlle in AWS IoT Greengrass versandten Nachrichten werden mit QoS 0 gesendet. Standardmäßigspeichert AWS IoT Greengrass Nachrichten in einer speicherinternen Warteschlange. Daher gehen nichtverarbeitete Nachrichten verloren, wenn der AWS IoT Greengrass-Core neu gestartet wird (z. B. nacheiner Gruppenbereitstellung oder einem Geräteneustart). Sie können AWS IoT Greengrass (v1.6 or later)allerdings so konfigurieren, dass Nachrichten im Dateisystem zwischengespeichert werden und einen Core-Neustart überdauern. Sie können auch die Größe der Warteschlange konfigurieren. Weitere Informationenfinden Sie unter the section called “MQTT-Nachrichtenwarteschlange” (p. 58).

Note

Wenn Sie die standardmäßige speicherinterne Warteschlange verwenden, sollten Sie Gruppenbereitstellen oder das Gerät neu starten, wenn die Serviceunterbrechung möglichst gering ist.

Falls Sie eine Warteschlangengröße konfigurieren, stellen Sie sicher, dass sie größer als oder gleich262144 Byte (256 KB) ist. Andernfalls wird AWS IoT Greengrass möglicherweise nicht ordnungsgemäßgestartet.

Beheben von Timeout-Problemen während derSchattensynchronisierung

Erhebliche Verzögerungen bei der Kommunikation zwischen einem Greengrass Core-Gerät und der Cloudkönnen dazu führen, dass die Schattensynchronisierung wegen einer Zeitüberschreitung fehlschlägt. Indiesem Fall sollten Protokolleinträge angezeigt werden, die etwa wie folgt aussehen:

[2017-07-20T10:01:58.006Z][ERROR]-cloud_shadow_client.go:57,Cloud shadow client error: unable to get cloud shadow what_the_thing_is_named for synchronization. Get

515

AWS IoT Greengrass EntwicklerhandbuchSehen Sie im AWS IoT Greengrass-Forum nach

https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)[2017-07-20T10:01:58.006Z][WARN]-sync_manager.go:263,Failed to get cloud copy: Get https://1234567890abcd.iot.us-west-2.amazonaws.com:8443/things/what_the_thing_is_named/shadow: net/http: request canceled (Client.Timeout exceeded while awaiting headers)[2017-07-20T10:01:58.006Z][ERROR]-sync_manager.go:375,Failed to execute sync operation {what_the_thing_is_named VersionDiscontinued []}"

Eine mögliche Lösung besteht darin, die Zeitspanne festzulegen, die das Core-Gerät auf eine Antwort desHosts wartet. Öffnen Sie die Datei config.json (p. 23) in greengrass-root/config und fügen Siedas Feld system.shadowSyncTimeout mit einem Zeitüberschreitungswert in Sekunden hinzu. ZumBeispiel:

{ "system": { "shadowSyncTimeout": 10 }, "coreThing": { "caPath": "root-ca.pem", "certPath": "cloud.pem.crt", "keyPath": "cloud.pem.key", ... }, ...}

Wenn in config.json kein shadowSyncTimeout-Wert angegeben ist, lautet der Standardwert5 Sekunden.

Note

Für AWS IoT Greengrass Core Software bis Version 1.6 beträgt der shadowSyncTimeout-Standardwert 1 Sekunde.

Sehen Sie im AWS IoT Greengrass-Forum nachWenn sich das Problem mit den Informationen zur Fehlerbehebung in diesem Thema nicht lösen lässt,können Sie das AWS IoT Greengrass-Forum nach verwandten Probleme durchsuchen oder einen neuenForum-Thread veröffentlichen. Das Forum wird aktiv von Mitgliedern des AWS IoT Greengrass-Teamsüberwacht.

516



Dokumentverlauf für AWS IoTGreengrass

In der folgenden Tabelle werden die wichtigen Änderungen am AWS IoT Greengrass-Entwicklerhandbuchnach Juni 2018 beschrieben. Um Benachrichtigungen über Aktualisierungen dieser Dokumentation zuerhalten, können Sie einen RSS-Feed abonnieren.

update-history-change update-history-description update-history-date

AWS IoT Greengrass-Version1.9.2 mit Unterstützung fürOpenWrt veröffentlicht

Version 1.9.2 der AWS IoTGreengrass Core-Software istverfügbar. Mit dieser Versionkönnen Sie die AWS IoTGreengrass Core-Softwareauf OpenWrt-Verteilungen mitARMv8- (AArch64-) und ARMv7l-Architekturen installieren.

June 20, 2019

Veröffentlichung von AWS IoTGreengrass-Version 1.9.1

Version 1.9.1 der AWS IoTGreengrass Core-Softwareist verfügbar. Diese Versionenthält eine Fehlerkorrektur fürNachrichten von AWS IoT, dieim Thema ein Platzhalterzeichenenthalten.

May 10, 2019


Version 1.8.2 der AWSIoT Greengrass Core-Software ist verfügbar. DieseVersion enthält allgemeineLeistungsverbesserungen undFehlerbehebungen. Wenn Siev1.8.x ausführen, empfehlen wir,dass Sie ein Upgrade auf v1.8.2oder v1.9.0 durchführen. Fürältere Versionen empfehlen wir,dass Sie ein Upgrade auf v1.9.0durchführen.

May 2, 2019


Neue Funktionen: Support fürPython 3.7 und Node.js 8.10Lambda-Laufzeiten, optimierteMQTT-Verbindungen undElliptic Curve (EC)-Schlüssel-Unterstützung für den lokalenMQTT-Server.

May 1, 2019


Version 1.8.1 der AWSIoT Greengrass Core-Software ist verfügbar. DieseVersion enthält allgemeineLeistungsverbesserungen undFehlerbehebungen. Als bewährte

April 18, 2019

517

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#ggc-versions












Methode empfehlen wir, dassSie immer die neueste Versionausführen.

AWS IoT Greengrass Snapverfügbar in Snapcraft

Verwenden Sie die AWS IoTGreengrass Snap-Store-App,um mit AWS IoT GreengrassSoftware auf Linux-Gerätenschnell zu entwickeln, zu testenund bereitzustellen.

April 1, 2019

Unterstützung für mehrZugriffssteuerung mit Tag-basierten Berechtigungen

Sie können Tags in Ihren AWSIdentity and Access Management(IAM)-Richtlinien zum Steuerndes AWS IoT Greengrass-Ressourcenzugriffs verwenden.

March 29, 2019

Stapelunterstützung im KinesisFirehose-Konnektor

Der Kinesis Firehose-Konnektorunterstützt das Senden vonStapeldatensätzen an AmazonKinesis Data Firehose zu einemangegebenen Intervall.

March 15, 2019

IoT Analytics-Konnektorveröffentlicht

Mit dem IoT Analytics-Konnektorkönnen Sie Daten des lokalenGeräts an AWS IoT Analytics-Kanäle senden.

March 15, 2019

AWS CloudFormation-Unterstützung für AWS IoTGreengrass-Ressourcen

Erstellen und verwalten Sie AWSIoT Greengrass-Ressourcen mitAWS CloudFormation-Vorlagen.

March 15, 2019


Neue Funktionen: konfigurierbareStandardzugriffsidentität fürLambda-Funktionen, Supportfür HTTPS-Datenverkehr überPort 443 und vorhersagbarbenannte Client-IDs für MQTT-Verbindungen mit AWS IoT.

March 7, 2019

Veröffentlichung der AWS IoTGreengrass-Versionen 1.7.1 und1.6.1

Die Versionen 1.7.1 und 1.6.1der AWS IoT Greengrass Core-Software sind verfügbar. DieseVersionen erfordern Linux-Kernel-Version 3.17 oder höher.Wir empfehlen Kunden, dieeine Version der GreengrassCore-Software nutzen, sofortein Upgrade auf Version 1.7.1auszuführen.

February 11, 2019

Amazon SageMaker Neo DeepLearning Runtime

Amazon SageMaker Neo DeepLearning Runtime unterstütztMachine-Learning-Modelle, dievon dem Amazon SageMakerNeo Deep Learning-Compileroptimiert wurden.

November 28, 2018

518

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#gg-snapstore-download

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#gg-snapstore-download

https://docs.aws.amazon.com/greengrass/latest/developerguide/tagging.html



https://docs.aws.amazon.com/greengrass/latest/developerguide//kinesis-firehose-connector.html

https://docs.aws.amazon.com/greengrass/latest/developerguide//kinesis-firehose-connector.html

https://docs.aws.amazon.com/greengrass/latest/developerguide//iot-analytics-connector.html

https://docs.aws.amazon.com/greengrass/latest/developerguide//iot-analytics-connector.html

https://docs.aws.amazon.com/greengrass/latest/developerguide//cloudformation-support.html








https://docs.aws.amazon.com/greengrass/latest/developerguide/ml-inference.html#precompiled-ml-libraries




Neue Funktionen: Greengrass-Konnektoren, Managerlokaler Secrets, Isolation undBerechtigungseinstellungenfür Lambda-Funktionen,Hardware-Root of TrustSicherheit, Verbindung mitALPN oder Netzwerk-Proxyund Unterstützung für RaspbianStretch.

November 26, 2018

Ausführen von AWS IoTGreengrass in einem Docker-Container

Sie können AWS IoT Greengrassin einem Docker-Containerausführen, indem SieIhre Greengrass-Gruppefür die Ausführung ohneContainerisierung konfigurieren.

November 26, 2018

AWS IoT Greengrass Software-Downloads

Die AWS IoT Greengrass Core-Software sowie die AWS IoTGreengrassCore-SDK- undAWS IoT Greengrass MachineLearning SDK-Pakete sind zumHerunterladen über AmazonCloudFront verfügbar.

November 26, 2018

AWS IoT Device Tester für AWSIoT Greengrass

Mit AWS IoT Device Tester fürAWS IoT Greengrass könnenSie überprüfen, ob Ihre CPU-Architektur, Kernel-Konfigurationund Treiber mit AWS IoTGreengrass funktionieren.

November 26, 2018

AWS CloudTrail-Protokollierungfür AWS IoT Greengrass API-Aufrufe

AWS IoT Greengrass ist inAWS CloudTrail integriert, einenService, der die Aktionen einesBenutzers, einer Rolle odereines AWS-Service in AWS IoTGreengrass protokolliert.

October 29, 2018

Unterstützung für TensorFlowv1.10.1 auf NVIDIA Jetson TX2

Die vorkompilierte TensorFlow-Bibliothek für NVIDIA JetsonTX2, die AWS IoT Greengrassbereitstellt, unterstützt nunTensorFlow v1.10.1. Dadurchwerden Jetpack 3.3 und CUDAToolkit 9.0 unterstützt.

October 18, 2018

Support für MXNet v1.2.1Machine Learning-Ressourcen

AWS IoT Greengrass unterstütztMachine Learning-Modelle,die mithilfe von MXNet v1.2.1geschult werden.

August 29, 2018

519



https://docs.aws.amazon.com/greengrass/latest/developerguide/run-gg-in-docker-container.html



https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#gg-downloads

https://docs.aws.amazon.com/greengrass/latest/developerguide/what-is-gg.html#gg-downloads

https://docs.aws.amazon.com/greengrass/latest/developerguide/device-tester-for-greengrass-ug.html

https://docs.aws.amazon.com/greengrass/latest/developerguide/device-tester-for-greengrass-ug.html

https://docs.aws.amazon.com/greengrass/latest/developerguide/logging-using-cloudtrail.html



https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html#setup-filter.other

https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html#setup-filter.other



AWS IoT Greengrass EntwicklerhandbuchFrühere Aktualisierungen


Neue Funktionen: AusführbareLambda-Dateien, konfigurierbareNachrichtenwarteschlange,konfigurierbaresVerbindungswiederholungsintervall,Volume-Ressourcen unter/proc und konfigurierbaresSchreibverzeichnis.

July 26, 2018

Frühere AktualisierungenIn der folgenden Tabelle werden die wichtigen Änderungen am AWS IoT Greengrass-Entwicklerhandbuchvor Juli 2018 beschrieben.

Änderung Beschreibung Datum

Veröffentlichungvon AWS IoTGreengrass-Version 1.5.0

Neue Funktionen:

• Lokale Machine Learning-Inferenz mit Cloud-geschulten Modellendurchführen. Weitere Informationen finden Sie unter Durchführen vonMachine Learning-Inferenzen (p. 227).

• Greengrass-Lambda-Funktionen unterstützen binäre Eingabedatenzusätzlich zu JSON.

Weitere Informationen finden Sie unter AWS IoT Greengrass Core-Versionen (p. 2).

29.März2018


Neue Funktionen:

• Der Over-The-Air (OTA)-Update-Agent kann in der Cloudbereitgestellte Greengrass-Aktualisierungsaufträge verarbeiten.Weitere Informationen finden Sie unter OTA-Updates der AWS IoTGreengrass Core-Software (p. 158).

• Zugriff auf lokale Peripheriegeräte und Ressourcen von Greengrass-Lambda-Funktionen aus. Weitere Informationen finden Sieunter Zugriff auf lokale Ressourcen mit Lambda-Funktionen undKonnektoren (p. 204).

27.November2017


Neue Funktionen:

• Zurücksetzen bereitgestellter AWS IoT Greengrass-Gruppen.Weitere Informationen finden Sie unter Zurücksetzen vonBereitstellungen (p. 164).

• Unterstützung von Node.js 6.10 und Java 8 Lambda-Laufzeitumgebungen zusätzlich zu Python 2.7.

20. September2017


AWS IoT Greengrass ist allgemein verfügbar. 7. Juni2017

520



AWS IoT Greengrass - Entwicklerhandbuch · AWS IoT Greengrass Entwicklerhandbuch Was ist AWS IoT...

Documents

Transcript of AWS IoT Greengrass - Entwicklerhandbuch · AWS IoT Greengrass Entwicklerhandbuch Was ist AWS IoT...