Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Tutorial: Entwickeln Sie eine Greengrass-Komponente, die Komponenten-Updates verzögert
<a name="defer-component-updates-tutorial"></a>

Sie können dieses Tutorial abschließen, um eine Komponente zu entwickeln, die over-the-air Bereitstellungsupdates verzögert. Wenn Sie Updates auf Ihren Geräten bereitstellen, sollten Sie Updates möglicherweise aufgrund von Bedingungen wie den folgenden verzögern:
+ Das Gerät hat einen niedrigen Akkuladestand.
+ Auf dem Gerät wird ein Prozess oder Auftrag ausgeführt, der nicht unterbrochen werden kann.
+ Das Gerät hat eine eingeschränkte oder teure Internetverbindung.

**Anmerkung**  
Eine *Komponente* ist ein Softwaremodul, das auf AWS IoT Greengrass Kerngeräten ausgeführt wird. Komponenten ermöglichen es Ihnen, komplexe Anwendungen als separate Bausteine zu erstellen und zu verwalten, die Sie von einem Greengrass-Core-Gerät auf ein anderes wiederverwenden können.

In diesem Tutorial führen Sie folgende Aufgaben aus:

1. Installieren Sie das Greengrass Development Kit CLI (GDK CLI) auf Ihrem Entwicklungscomputer. Die GDK CLI bietet Funktionen, mit denen Sie benutzerdefinierte Greengrass-Komponenten entwickeln können.

1. Entwickeln Sie eine Hello World-Komponente, die Komponenten-Updates verzögert, wenn der Akkuladestand des Kerngeräts unter einem Schwellenwert liegt. Diese Komponente abonniert Aktualisierungsbenachrichtigungen mithilfe der [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC-Operation. Wenn sie die Benachrichtigung erhält, prüft sie, ob der Akkuladestand unter einem einstellbaren Schwellenwert liegt. Wenn der Akkuladestand unter dem Schwellenwert liegt, wird die Aktualisierung mithilfe des [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC-Vorgangs für 30 Sekunden verschoben. Sie entwickeln diese Komponente auf Ihrem Entwicklungscomputer mit der GDK-CLI.
**Anmerkung**  
Diese Komponente liest den Akkustand aus einer Datei, die Sie auf dem Kerngerät erstellen, um eine echte Batterie nachzuahmen, sodass Sie dieses Tutorial auf einem Kerngerät ohne Batterie durchführen können.

1. Veröffentlichen Sie diese Komponente im AWS IoT Greengrass Service.

1. Stellen Sie diese Komponente AWS Cloud auf einem Greengrass-Core-Gerät bereit, um sie zu testen. Anschließend ändern Sie den virtuellen Akkuladestand auf dem Kerngerät und erstellen zusätzliche Bereitstellungen, um zu sehen, wie das Kerngerät Updates verzögert, wenn der Akkuladestand niedrig ist.

Sie können damit rechnen, 20—30 Minuten für dieses Tutorial aufzuwenden.

# Voraussetzungen
<a name="defer-component-updates-tutorial-prerequisites"></a>

Zum Durcharbeiten dieses Tutorials ist Folgendes erforderlich:
+ Ein AWS-Konto. Falls Sie noch keines haben, beachten Sie die Informationen unter [Richten Sie eine ein AWS-Konto](setting-up.md#set-up-aws-account).
+ Ein AWS Identity and Access Management (IAM-) Benutzer mit Administratorrechten.
+ Ein Greengrass-Core-Gerät mit einer Internetverbindung. Weitere Informationen zur Einrichtung eines Core-Geräts finden Sie unter[Einrichtung von AWS IoT Greengrass Kerngeräten](setting-up.md).
  + [Python](https://www.python.org/downloads/) 3.6 oder höher wurde für alle Benutzer auf dem Core-Gerät installiert und der `PATH` Umgebungsvariablen hinzugefügt. Unter Windows muss außerdem der Python Launcher für Windows für alle Benutzer installiert sein.
**Wichtig**  <a name="windows-core-device-python-installation"></a>
In Windows wird Python standardmäßig nicht für alle Benutzer installiert. Wenn Sie Python installieren, müssen Sie die Installation anpassen, um sie so zu konfigurieren, dass die AWS IoT Greengrass Core-Software Python-Skripts ausführt. Wenn Sie beispielsweise den grafischen Python-Installer verwenden, gehen Sie wie folgt vor:  
Wählen Sie **Launcher für alle Benutzer installieren (empfohlen)** aus.
Wählen Sie ** aus.Customize installation**.
Wählen Sie ** aus.Next**.
Select **Install for all users**.
Select **Add Python to environment variables**.
Wählen Sie **Installieren** aus.
Weitere Informationen finden Sie unter [Using Python on Windows](https://docs.python.org/3/using/windows.html) in der *Python 3-Dokumentation*.
+ Ein Windows-, macOS- oder UNIX-ähnlicher Entwicklungscomputer mit einer Internetverbindung.
  + [Python](https://www.python.org/downloads/) 3.6 oder höher ist auf Ihrem Entwicklungscomputer installiert.
  + [Git](https://git-scm.com/) ist auf Ihrem Entwicklungscomputer installiert.
  + <a name="development-component-aws-cli-prerequisite"></a>AWS Command Line Interface (AWS CLI) wurde mit Anmeldeinformationen auf Ihrem Entwicklungscomputer installiert und konfiguriert. Weitere Informationen finden Sie unter [Installation, Aktualisierung und Deinstallation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) [von AWS CLI und Konfiguration von AWS CLI im AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *Benutzerhandbuch*.
**Anmerkung**  
Wenn Sie einen Raspberry Pi oder ein anderes 32-Bit-ARM-Gerät verwenden, installieren Sie AWS CLI V1. AWS CLI V2 ist für 32-Bit-ARM-Geräte nicht verfügbar. Weitere Informationen finden Sie unter [Installation, Aktualisierung und Deinstallation von AWS CLI Version 1.](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html)

# Schritt 1: Installieren Sie das Greengrass Development Kit CLI
<a name="install-gdk-cli-defer-updates"></a>

Das [Greengrass Development Kit CLI (GDK CLI)](greengrass-development-kit-cli.md) bietet Funktionen, mit denen Sie benutzerdefinierte Greengrass-Komponenten entwickeln können. Sie können die GDK-CLI verwenden, um benutzerdefinierte Komponenten zu erstellen, zu erstellen und zu veröffentlichen.

Wenn Sie die GDK-CLI nicht auf Ihrem Entwicklungscomputer installiert haben, führen Sie die folgenden Schritte aus, um sie zu installieren.

**Um die neueste Version der GDK CLI zu installieren**

1. Führen Sie auf Ihrem Entwicklungscomputer den folgenden Befehl aus, um die neueste Version der GDK-CLI aus dem [GitHubRepository](https://github.com/aws-greengrass/aws-greengrass-gdk-cli) zu installieren.

   ```
   python3 -m pip install -U git+https://github.com/aws-greengrass/aws-greengrass-gdk-cli.git@v1.6.2
   ```

1. <a name="gdk-cli-verify-installation"></a>Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die GDK-CLI erfolgreich installiert wurde.

   ```
   gdk --help
   ```

   Wenn der `gdk` Befehl nicht gefunden wird, fügen Sie seinen Ordner zu PATH hinzu.
   + Auf Linux-Geräten fügen Sie `/home/MyUser/.local/bin` es zu PATH hinzu und *MyUser* ersetzen Sie es durch den Namen Ihres Benutzers.
   + Fügen Sie auf Windows-Geräten PATH `PythonPath\\Scripts` hinzu und *PythonPath* ersetzen Sie es durch den Pfad zum Python-Ordner auf Ihrem Gerät.

# Schritt 2: Entwickeln Sie eine Komponente, die Updates verzögert
<a name="develop-component-defer-updates"></a>

In diesem Abschnitt entwickeln Sie eine Hello World-Komponente in Python, die Komponenten-Updates verzögert, wenn der Akkuladestand des Kerngeräts unter einem Schwellenwert liegt, den Sie bei der Bereitstellung der Komponente konfigurieren. In dieser Komponente verwenden Sie die [IPC-Schnittstelle (Interprocess Communication)](interprocess-communication.md) in der AWS IoT Device SDK Version 2 für Python. Sie verwenden den [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC-Vorgang, um Benachrichtigungen zu erhalten, wenn das Kerngerät eine Bereitstellung empfängt. Anschließend verwenden Sie den [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC-Vorgang, um das Update je nach Akkuladestand des Geräts zu verzögern oder zu bestätigen.

**Um eine Hello World-Komponente zu entwickeln, die Updates verzögert**

1. Erstellen Sie auf Ihrem Entwicklungscomputer einen Ordner für den Quellcode der Komponente.

   ```
   mkdir com.example.BatteryAwareHelloWorld
   cd com.example.BatteryAwareHelloWorld
   ```

1. Verwenden Sie einen Texteditor, um eine Datei mit dem Namen zu erstellen`gdk-config.json`. Die GDK-CLI liest aus der benannten [GDK-CLI-Konfigurationsdatei](gdk-cli-configuration-file.md), um `gdk-config.json` Komponenten zu erstellen und zu veröffentlichen. Diese Konfigurationsdatei befindet sich im Stammverzeichnis des Komponentenordners.

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   nano gdk-config.json
   ```

   Kopieren Sie den folgenden JSON-Code in die Datei.
   + Ersetze es *Amazon* durch deinen Namen.
   + *us-west-2*Ersetzen Sie durch den AWS-Region Ort, an dem Ihr Kerngerät betrieben wird. Die GDK-CLI veröffentlicht die Komponente darin AWS-Region.
   + Ersetzen Sie es *greengrass-component-artifacts* durch das zu verwendende S3-Bucket-Präfix. Wenn Sie die GDK-CLI verwenden, um die Komponente zu veröffentlichen, lädt die GDK-CLI die Artefakte der Komponente in den S3-Bucket hoch, dessen Name aus diesem Wert AWS-Region, dem und Ihrer AWS-Konto ID im folgenden Format gebildet wird:. `bucketPrefix-region-accountId`

     Wenn Sie beispielsweise **greengrass-component-artifacts** und angeben und Ihre AWS-Konto ID lautet **us-west-2****123456789012**, verwendet die GDK-CLI den S3-Bucket mit dem Namen`greengrass-component-artifacts-us-west-2-123456789012`.

   ```
   {
     "component": {
       "com.example.BatteryAwareHelloWorld": {
         "author": "Amazon",
         "version": "NEXT_PATCH",
         "build": {
           "build_system" : "zip"
         },
         "publish": {
           "region": "us-west-2",
           "bucket": "greengrass-component-artifacts"
         }
       }
     },
     "gdk_version": "1.0.0"
   }
   ```

   Die Konfigurationsdatei spezifiziert Folgendes:
   + Die Version, die verwendet werden soll, wenn die GDK-CLI die Greengrass-Komponente im AWS IoT Greengrass Cloud-Dienst veröffentlicht. `NEXT_PATCH`gibt an, dass die nächste Patch-Version nach der neuesten im AWS IoT Greengrass Cloud-Dienst verfügbaren Version ausgewählt werden soll. Wenn die Komponente noch keine Version im AWS IoT Greengrass Cloud-Dienst hat, verwendet `1.0.0` die GDK-CLI.
   + Das Build-System für die Komponente. Wenn Sie das `zip` Build-System verwenden, packt die GDK-CLI die Quelle der Komponente in eine ZIP-Datei, die zum einzigen Artefakt der Komponente wird.
   + Der AWS-Region Ort, an dem die GDK-CLI die Greengrass-Komponente veröffentlicht.
   + Das Präfix für den S3-Bucket, in den die GDK-CLI die Artefakte der Komponente hochlädt.

1. Verwenden Sie einen Texteditor, um den Quellcode der Komponente in einer Datei mit dem Namen zu erstellen. `main.py`

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   nano main.py
   ```

   Kopieren Sie den folgenden Python-Code in die Datei.

   ```
   import json
   import os
   import sys
   import time
   import traceback
   
   from pathlib import Path
   
   from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
   
   HELLO_WORLD_PRINT_INTERVAL = 15  # Seconds
   DEFER_COMPONENT_UPDATE_INTERVAL = 30 * 1000  # Milliseconds
   
   
   class BatteryAwareHelloWorldPrinter():
       def __init__(self, ipc_client: GreengrassCoreIPCClientV2, battery_file_path: Path, battery_threshold: float):
           self.battery_file_path = battery_file_path
           self.battery_threshold = battery_threshold
           self.ipc_client = ipc_client
           self.subscription_operation = None
   
       def on_component_update_event(self, event):
           try:
               if event.pre_update_event is not None:
                   if self.is_battery_below_threshold():
                       self.defer_update(event.pre_update_event.deployment_id)
                       print('Deferred update for deployment %s' %
                             event.pre_update_event.deployment_id)
                   else:
                       self.acknowledge_update(
                           event.pre_update_event.deployment_id)
                       print('Acknowledged update for deployment %s' %
                             event.pre_update_event.deployment_id)
               elif event.post_update_event is not None:
                   print('Applied update for deployment')
           except:
               traceback.print_exc()
   
       def subscribe_to_component_updates(self):
           if self.subscription_operation == None:
               # SubscribeToComponentUpdates returns a tuple with the response and the operation.
               _, self.subscription_operation = self.ipc_client.subscribe_to_component_updates(
                   on_stream_event=self.on_component_update_event)
   
       def close_subscription(self):
           if self.subscription_operation is not None:
               self.subscription_operation.close()
               self.subscription_operation = None
   
       def defer_update(self, deployment_id):
           self.ipc_client.defer_component_update(
               deployment_id=deployment_id, recheck_after_ms=DEFER_COMPONENT_UPDATE_INTERVAL)
   
       def acknowledge_update(self, deployment_id):
           # Specify recheck_after_ms=0 to acknowledge a component update.
           self.ipc_client.defer_component_update(
               deployment_id=deployment_id, recheck_after_ms=0)
   
       def is_battery_below_threshold(self):
           return self.get_battery_level() < self.battery_threshold
   
       def get_battery_level(self):
           # Read the battery level from the virtual battery level file.
           with self.battery_file_path.open('r') as f:
               data = json.load(f)
               return float(data['battery_level'])
   
       def print_message(self):
           message = 'Hello, World!'
           if self.is_battery_below_threshold():
               message += ' Battery level (%d) is below threshold (%d), so the component will defer updates' % (
                   self.get_battery_level(), self.battery_threshold)
           else:
               message += ' Battery level (%d) is above threshold (%d), so the component will acknowledge updates' % (
                   self.get_battery_level(), self.battery_threshold)
           print(message)
   
   
   def main():
       # Read the battery threshold and virtual battery file path from command-line args.
       args = sys.argv[1:]
       battery_threshold = float(args[0])
       battery_file_path = Path(args[1])
       print('Reading battery level from %s and deferring updates when below %d' % (
           str(battery_file_path), battery_threshold))
   
       try:
           # Create an IPC client and a Hello World printer that defers component updates.
           ipc_client = GreengrassCoreIPCClientV2()
           hello_world_printer = BatteryAwareHelloWorldPrinter(
               ipc_client, battery_file_path, battery_threshold)
           hello_world_printer.subscribe_to_component_updates()
           try:
               # Keep the main thread alive, or the process will exit.
               while True:
                   hello_world_printer.print_message()
                   time.sleep(HELLO_WORLD_PRINT_INTERVAL)
           except InterruptedError:
               print('Subscription interrupted')
           hello_world_printer.close_subscription()
       except Exception:
           print('Exception occurred', file=sys.stderr)
           traceback.print_exc()
           exit(1)
   
   
   if __name__ == '__main__':
       main()
   ```

   Diese Python-Anwendung macht Folgendes:
   + Liest den Akkustand des Kerngeräts aus einer virtuellen Batteriestanddatei, die Sie später auf dem Kerngerät erstellen werden. Diese virtuelle Batteriestanddatei ahmt einen echten Akku nach, sodass Sie dieses Tutorial auf Kerngeräten ohne Batterie durchführen können.
   + Liest Befehlszeilenargumente für den Akkugrenzwert und den Pfad zur virtuellen Batteriestanddatei. Das Komponentenrezept legt diese Befehlszeilenargumente auf der Grundlage von Konfigurationsparametern fest, sodass Sie diese Werte bei der Bereitstellung der Komponente anpassen können.
   + Verwendet den IPC-Client V2 in der Version [AWS IoT Device SDK 2 für Python](https://github.com/aws/aws-iot-device-sdk-python-v2), um mit der AWS IoT Greengrass Core-Software zu kommunizieren. Im Vergleich zum ursprünglichen IPC-Client reduziert der IPC-Client V2 die Menge an Code, die Sie schreiben müssen, um IPC in benutzerdefinierten Komponenten zu verwenden.
   + Abonniert Aktualisierungsbenachrichtigungen mithilfe der IPC-Operation. [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates) Die AWS IoT Greengrass Core-Software sendet vor und nach jeder Bereitstellung Benachrichtigungen. Die Komponente ruft bei jedem Empfang einer Benachrichtigung die folgende Funktion auf. Wenn sich die Benachrichtigung auf eine bevorstehende Bereitstellung bezieht, prüft die Komponente, ob der Akkuladestand unter einem Schwellenwert liegt. Wenn der Akkuladestand unter dem Schwellenwert liegt, verschiebt die Komponente das Update mithilfe des [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC-Vorgangs für 30 Sekunden. Andernfalls bestätigt die Komponente das Update, wenn der Akkuladestand nicht unter dem Schwellenwert liegt, sodass das Update fortgesetzt werden kann.

     ```
     def on_component_update_event(self, event):
         try:
             if event.pre_update_event is not None:
                 if self.is_battery_below_threshold():
                     self.defer_update(event.pre_update_event.deployment_id)
                     print('Deferred update for deployment %s' %
                           event.pre_update_event.deployment_id)
                 else:
                     self.acknowledge_update(
                         event.pre_update_event.deployment_id)
                     print('Acknowledged update for deployment %s' %
                           event.pre_update_event.deployment_id)
             elif event.post_update_event is not None:
                 print('Applied update for deployment')
         except:
             traceback.print_exc()
     ```
**Anmerkung**  
Die AWS IoT Greengrass Core-Software sendet keine Aktualisierungsbenachrichtigungen für lokale Bereitstellungen. Sie stellen diese Komponente daher mithilfe des AWS IoT Greengrass Cloud-Dienstes bereit, um sie zu testen.

1. Verwenden Sie einen Texteditor, um das Komponentenrezept in einer Datei mit dem Namen `recipe.json` oder `recipe.yaml` zu erstellen. Das *Komponentenrezept* definiert die Metadaten der Komponente, die Standardkonfigurationsparameter und die plattformspezifischen Lebenszyklusskripts.

------
#### [ JSON ]

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   nano recipe.json
   ```

   Kopieren Sie den folgenden JSON-Code in die Datei.

   ```
   {
     "RecipeFormatVersion": "2020-01-25",
     "ComponentName": "COMPONENT_NAME",
     "ComponentVersion": "COMPONENT_VERSION",
     "ComponentDescription": "This Hello World component defers updates when the battery level is below a threshold.",
     "ComponentPublisher": "COMPONENT_AUTHOR",
     "ComponentConfiguration": {
       "DefaultConfiguration": {
         "BatteryThreshold": 50,
         "LinuxBatteryFilePath": "/home/ggc_user/virtual_battery.json",
         "WindowsBatteryFilePath": "C:\\Users\\ggc_user\\virtual_battery.json"
       }
     },
     "Manifests": [
       {
         "Platform": {
           "os": "linux"
         },
         "Lifecycle": {
           "install": "python3 -m pip install --user awsiotsdk --upgrade",
           "Run": "python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/LinuxBatteryFilePath}\""
         },
         "Artifacts": [
           {
             "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip",
             "Unarchive": "ZIP"
           }
         ]
       },
       {
         "Platform": {
           "os": "windows"
         },
         "Lifecycle": {
           "install": "py -3 -m pip install --user awsiotsdk --upgrade",
           "Run": "py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/WindowsBatteryFilePath}\""
         },
         "Artifacts": [
           {
             "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip",
             "Unarchive": "ZIP"
           }
         ]
       }
     ]
   }
   ```

------
#### [ YAML ]

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   nano recipe.yaml
   ```

   Kopieren Sie das folgende YAML in die Datei.

   ```
   ---
   RecipeFormatVersion: "2020-01-25"
   ComponentName: "COMPONENT_NAME"
   ComponentVersion: "COMPONENT_VERSION"
   ComponentDescription: "This Hello World component defers updates when the battery level is below a threshold."
   ComponentPublisher: "COMPONENT_AUTHOR"
   ComponentConfiguration:
     DefaultConfiguration:
       BatteryThreshold: 50
       LinuxBatteryFilePath: "/home/ggc_user/virtual_battery.json"
       WindowsBatteryFilePath: "C:\\Users\\ggc_user\\virtual_battery.json"
   Manifests:
     - Platform:
         os: linux
       Lifecycle:
         install: python3 -m pip install --user awsiotsdk --upgrade
         Run: python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/LinuxBatteryFilePath}"
       Artifacts:
         - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip"
           Unarchive: ZIP
     - Platform:
         os: windows
       Lifecycle:
         install: py -3 -m pip install --user awsiotsdk --upgrade
         Run: py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/WindowsBatteryFilePath}"
       Artifacts:
         - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip"
           Unarchive: ZIP
   ```

------

   Dieses Rezept spezifiziert Folgendes:
   + Standardkonfigurationsparameter für den Akkugrenzwert, den virtuellen Batteriedateipfad auf Linux-Kerngeräten und den virtuellen Batteriedateipfad auf Windows-Kerngeräten.
   + Ein `install` Lebenszyklus, der die neueste Version von AWS IoT Device SDK v2 für Python installiert.
   + Ein `run` Lebenszyklus, in dem die Python-Anwendung ausgeführt wird`main.py`.
   + Platzhalter wie `COMPONENT_NAME` und`COMPONENT_VERSION`, bei denen die GDK-CLI Informationen ersetzt, wenn sie das Komponentenrezept erstellt.

   Weitere Informationen zu Komponentenrezepten finden Sie unter. [AWS IoT Greengrass Referenz zum Komponenten-Rezept](component-recipe-reference.md)

# Schritt 3: Veröffentlichen Sie die Komponente im AWS IoT Greengrass Service
<a name="publish-component-defer-updates"></a>

In diesem Abschnitt veröffentlichen Sie die Hello World-Komponente im AWS IoT Greengrass Cloud-Dienst. Sobald eine Komponente im AWS IoT Greengrass Cloud-Dienst verfügbar ist, können Sie sie auf Kerngeräten bereitstellen. Sie verwenden die GDK-CLI, um die Komponente von Ihrem Entwicklungscomputer im AWS IoT Greengrass Cloud-Dienst zu veröffentlichen. Die GDK-CLI lädt das Rezept und die Artefakte der Komponente für Sie hoch.

**Um die Hello World-Komponente im Service zu veröffentlichen AWS IoT Greengrass**

1. Führen Sie den folgenden Befehl aus, um die Komponente mit der GDK-CLI zu erstellen. Der [Befehl component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) erstellt ein Rezept und Artefakte auf der Grundlage der GDK-CLI-Konfigurationsdatei. In diesem Prozess erstellt die GDK-CLI eine ZIP-Datei, die den Quellcode der Komponente enthält.

   ```
   gdk component build
   ```

   Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.

   ```
   [2022-04-28 11:20:16] INFO - Getting project configuration from gdk-config.json
   [2022-04-28 11:20:16] INFO - Found component recipe file 'recipe.yaml' in the  project directory.
   [2022-04-28 11:20:16] INFO - Building the component 'com.example.BatteryAwareHelloWorld' with the given project configuration.
   [2022-04-28 11:20:16] INFO - Using 'zip' build system to build the component.
   [2022-04-28 11:20:16] WARNING - This component is identified as using 'zip' build system. If this is incorrect, please exit and specify custom build command in the 'gdk-config.json'.
   [2022-04-28 11:20:16] INFO - Zipping source code files of the component.
   [2022-04-28 11:20:16] INFO - Copying over the build artifacts to the greengrass component artifacts build folder.
   [2022-04-28 11:20:16] INFO - Updating artifact URIs in the recipe.
   [2022-04-28 11:20:16] INFO - Creating component recipe in 'C:\Users\finthomp\greengrassv2\com.example.BatteryAwareHelloWorld\greengrass-build\recipes'.
   ```

1. Führen Sie den folgenden Befehl aus, um die Komponente im AWS IoT Greengrass Cloud-Dienst zu veröffentlichen. Mit dem [Befehl zum Veröffentlichen der Komponente](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) wird das ZIP-Dateiartefakt der Komponente in einen S3-Bucket hochgeladen. Anschließend aktualisiert er den S3-URI der ZIP-Datei im Komponentenrezept und lädt das Rezept in den Service hoch. AWS IoT Greengrass In diesem Prozess prüft die GDK-CLI, welche Version der Hello World-Komponente bereits im AWS IoT Greengrass Cloud-Dienst verfügbar ist, sodass sie die nächste Patch-Version nach dieser Version auswählen kann. Wenn die Komponente noch nicht existiert, verwendet die GDK-CLI die Version`1.0.0`.

   ```
   gdk component publish
   ```

   Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln. Die Ausgabe gibt Ihnen die Version der Komponente an, die die GDK-CLI erstellt hat.

   ```
   [2022-04-28 11:20:29] INFO - Getting project configuration from gdk-config.json
   [2022-04-28 11:20:29] INFO - Found component recipe file 'recipe.yaml' in the  project directory.
   [2022-04-28 11:20:29] INFO - Found credentials in shared credentials file: ~/.aws/credentials
   [2022-04-28 11:20:30] INFO - No private version of the component 'com.example.BatteryAwareHelloWorld' exist in the account. Using '1.0.0' as the next version to create.
   [2022-04-28 11:20:30] INFO - Publishing the component 'com.example.BatteryAwareHelloWorld' with the given project configuration.
   [2022-04-28 11:20:30] INFO - Uploading the component built artifacts to s3 bucket.
   [2022-04-28 11:20:30] INFO - Uploading component artifacts to S3 bucket: greengrass-component-artifacts-us-west-2-123456789012. If this is your first time using this bucket, add the 's3:GetObject' permission to each core device's token exchange role to allow it to download the component artifacts. For more information, see https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html.
   [2022-04-28 11:20:30] INFO - Not creating an artifacts bucket as it already exists.
   [2022-04-28 11:20:30] INFO - Updating the component recipe com.example.BatteryAwareHelloWorld-1.0.0.
   [2022-04-28 11:20:31] INFO - Creating a new greengrass component com.example.BatteryAwareHelloWorld-1.0.0
   [2022-04-28 11:20:31] INFO - Created private version '1.0.0' of the component in the account.'com.example.BatteryAwareHelloWorld'.
   ```

1. Kopieren Sie den S3-Bucket-Namen aus der Ausgabe. Sie verwenden den Bucket-Namen später, damit das Kerngerät Komponentenartefakte aus diesem Bucket herunterladen kann.

1. (Optional) Sehen Sie sich die Komponente in der AWS IoT Greengrass Konsole an, um zu überprüfen, ob sie erfolgreich hochgeladen wurde. Gehen Sie wie folgt vor:

   1. Wählen Sie im Navigationsmenü der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) die Option **Komponenten** aus.

   1. Wählen Sie auf der Seite „**Komponenten**“ die Registerkarte **Meine Komponenten** und dann aus **com.example.BatteryAwareHelloWorld**.

      Auf dieser Seite finden Sie die Rezeptur der Komponente und weitere Informationen zur Komponente.

1. <a name="core-device-allow-s3-bucket-access-console-intro-1"></a>Erlauben Sie dem Core-Gerät den Zugriff auf Komponentenartefakte im S3-Bucket.

   <a name="core-device-allow-s3-bucket-access-console-intro-2"></a>Jedes Kerngerät hat eine [IAM-Rolle für das Kerngerät](device-service-role.md), die es ihm ermöglicht, mit der Cloud zu interagieren AWS IoT und Logs an die AWS Cloud zu senden. Diese Geräterolle erlaubt standardmäßig keinen Zugriff auf S3-Buckets. Sie müssen also eine Richtlinie erstellen und anhängen, die es dem Kerngerät ermöglicht, Komponentenartefakte aus dem S3-Bucket abzurufen.

   <a name="core-device-allow-s3-bucket-access-console-intro-3"></a>Wenn die Rolle Ihres Geräts bereits den Zugriff auf den S3-Bucket ermöglicht, können Sie diesen Schritt überspringen. Andernfalls erstellen Sie eine IAM-Richtlinie, die den Zugriff ermöglicht, und hängen Sie sie wie folgt an die Rolle an:

   1. <a name="core-device-allow-s3-bucket-access-console-step-1"></a>Wählen Sie im Navigationsmenü der [IAM-Konsole](https://console.aws.amazon.com/iam) **Richtlinien** und dann Richtlinie **erstellen** aus.

   1. Ersetzen Sie auf der Registerkarte **JSON** den Platzhalterinhalt durch die folgende Richtlinie. *greengrass-component-artifacts-us-west-2-123456789012*Ersetzen Sie durch den Namen des S3-Buckets, in den die GDK-CLI die Artefakte der Komponente hochgeladen hat.

      Wenn Sie beispielsweise **greengrass-component-artifacts** und **us-west-2** in der GDK-CLI-Konfigurationsdatei angegeben haben und Ihre AWS-Konto ID lautet**123456789012**, verwendet die GDK-CLI den S3-Bucket mit dem Namen. `greengrass-component-artifacts-us-west-2-123456789012`

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Action": [
              "s3:GetObject"
            ],
            "Resource": "arn:aws:s3:::greengrass-component-artifacts-us-west-2-123456789012/*"
          }
        ]
      }
      ```

------

   1. <a name="core-device-allow-s3-bucket-access-console-step-3"></a>Wählen Sie **Weiter** aus.

   1. <a name="core-device-allow-s3-bucket-access-console-step-4"></a>Geben Sie im **Abschnitt Richtliniendetails** als **Namen den Wert ein**. **MyGreengrassV2ComponentArtifactPolicy**

   1. <a name="core-device-allow-s3-bucket-access-console-step-5"></a>Wählen Sie **Richtlinie erstellen** aus.

   1. <a name="core-device-allow-s3-bucket-access-console-step-6"></a>Wählen Sie im Navigationsmenü der [IAM-Konsole](https://console.aws.amazon.com/iam) die Option **Rolle** und dann den Namen der Rolle für das Kerngerät aus. Sie haben diesen Rollennamen bei der Installation der AWS IoT Greengrass Core-Software angegeben. Wenn Sie keinen Namen angegeben haben, lautet die Standardeinstellung`GreengrassV2TokenExchangeRole`.

   1. <a name="core-device-allow-s3-bucket-access-console-step-7"></a>Wählen Sie unter **Berechtigungen** die Option **Berechtigungen hinzufügen** und anschließend **Richtlinien anhängen** aus.

   1. <a name="core-device-allow-s3-bucket-access-console-step-8"></a>Aktivieren Sie auf der Seite „**Berechtigungen hinzufügen**“ das Kontrollkästchen neben der `MyGreengrassV2ComponentArtifactPolicy` Richtlinie, die Sie erstellt haben, und wählen Sie dann **Berechtigungen hinzufügen** aus.

# Schritt 4: Bereitstellen und Testen der Komponente auf einem Kerngerät
<a name="deploy-component-defer-updates"></a>

In diesem Abschnitt stellen Sie die Komponente auf dem Kerngerät bereit, um deren Funktionalität zu testen. Auf dem Kerngerät erstellen Sie die virtuelle Batteriestanddatei, um eine echte Batterie nachzuahmen. Anschließend erstellen Sie weitere Bereitstellungen und beobachten die Komponentenprotokolldateien auf dem Kerngerät, um zu sehen, ob die Komponenten Aktualisierungen zurückstellen und bestätigen.

**Um die Hello World-Komponente bereitzustellen und zu testen, die Updates verzögert**

1. Verwenden Sie einen Texteditor, um eine virtuelle Batteriestanddatei zu erstellen. Diese Datei ahmt eine echte Batterie nach.
   + Erstellen Sie auf Linux-Core-Geräten eine Datei mit dem Namen`/home/ggc_user/virtual_battery.json`. Führen Sie den Texteditor mit `sudo` Berechtigungen aus.
   + Erstellen Sie auf Windows Core-Geräten eine Datei mit dem Namen`C:\Users\ggc_user\virtual_battery.json`. Führen Sie den Texteditor als Administrator aus.

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   sudo nano /home/ggc_user/virtual_battery.json
   ```

   Kopieren Sie den folgenden JSON-Code in die Datei.

   ```
   {
     "battery_level": 50
   }
   ```

1. Stellen Sie die Hello World-Komponente auf dem Kerngerät bereit. Gehen Sie wie folgt vor:

   1. Wählen Sie im Navigationsmenü der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) die Option **Komponenten** aus.

   1. Wählen Sie auf der Seite **Komponenten** die Registerkarte **Meine Komponenten** und dann aus **com.example.BatteryAwareHelloWorld**.

   1. Wählen Sie auf der **com.example.BatteryAwareHelloWorld** Seite **Bereitstellen** aus.

   1. <a name="deploy-component-choose-deployment-step"></a>Wählen **Sie unter Zur Bereitstellung hinzufügen** eine vorhandene Bereitstellung aus, die Sie überarbeiten möchten, oder erstellen Sie eine neue Bereitstellung und klicken Sie dann auf **Weiter**.

   1. <a name="deploy-component-choose-target-step"></a>Wenn Sie eine neue Bereitstellung erstellen möchten, wählen Sie das Ziel-Core-Gerät oder die Dinggruppe für die Bereitstellung aus. Wählen Sie auf der Seite „**Ziel angeben**“ unter **Bereitstellungsziel** ein Kerngerät oder eine Dinggruppe aus, und klicken Sie dann auf **Weiter**.

   1. Vergewissern **Sie sich auf der Seite „Komponenten auswählen**“, dass die **com.example.BatteryAwareHelloWorld**Komponente ausgewählt ist, und klicken Sie auf **Weiter**.

   1. Wählen Sie auf der Seite **Komponenten konfigurieren** die Option aus **com.example.BatteryAwareHelloWorld**, und gehen Sie dann wie folgt vor:

      1. Wählen Sie **Komponente konfigurieren** aus.

      1. Geben **Sie im com.example.BatteryAwareHelloWorld Modal konfigurieren** unter **Konfigurationsupdate** unter **Konfiguration zum Zusammenführen** das folgende Konfigurationsupdate ein.

         ```
         {
           "BatteryThreshold": 70
         }
         ```

      1. Wählen Sie **Bestätigen**, um das Modal zu schließen, und klicken Sie dann auf **Weiter**.

   1. Vergewissern Sie sich, dass auf der Seite **Erweiterte Einstellungen bestätigen** im Abschnitt **Bereitstellungsrichtlinien** unter **Richtlinie für Komponenten-Updates** die Option **Komponenten benachrichtigen** ausgewählt ist. Die Option **Komponenten benachrichtigen** ist standardmäßig ausgewählt, wenn Sie eine neue Einrichtung erstellen.

   1. <a name="deploy-component-review-and-deploy-step"></a>Wählen Sie auf der Seite **Review (Prüfen)** die Option **Deploy (Bereitstellen)** aus.

      Es kann bis zu einer Minute dauern, bis die Bereitstellung abgeschlossen ist.

1. Die AWS IoT Greengrass Core-Software speichert Standarddaten von Komponentenprozessen in Protokolldateien im `logs` Ordner. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Hello World-Komponente ausgeführt wird und Statusmeldungen ausgibt.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.

   ```
   Hello, World! Battery level (50) is below threshold (70), so the component will defer updates.
   ```
**Anmerkung**  
Wenn die Datei nicht existiert, ist die Bereitstellung möglicherweise noch nicht abgeschlossen. Wenn die Datei nicht innerhalb von 30 Sekunden existiert, ist die Bereitstellung wahrscheinlich fehlgeschlagen. Dies kann beispielsweise der Fall sein, wenn das Kerngerät nicht berechtigt ist, die Artefakte der Komponente aus dem S3-Bucket herunterzuladen. Führen Sie den folgenden Befehl aus, um die Protokolldatei der AWS IoT Greengrass Core-Software anzuzeigen. Diese Datei enthält Protokolle vom Bereitstellungsdienst des Greengrass-Core-Geräts.  

   ```
   sudo tail -f /greengrass/v2/logs/greengrass.log
   ```

   ```
   type C:\greengrass\v2\logs\greengrass.log
   ```
<a name="windows-cmd-type-observe-logs"></a>Der `type` Befehl schreibt den Inhalt der Datei auf das Terminal. Führen Sie diesen Befehl mehrmals aus, um Änderungen in der Datei zu beobachten.

   ```
   gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
   ```

1. Erstellen Sie eine neue Bereitstellung auf dem Kerngerät, um sicherzustellen, dass die Komponente das Update verzögert. Gehen Sie wie folgt vor:

   1. Wählen Sie im Navigationsmenü der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) die Option **Deployments** aus.

   1. Wählen Sie die Bereitstellung aus, die Sie zuvor erstellt oder überarbeitet haben.

   1. Wählen Sie auf der Bereitstellungsseite die Option **Überarbeiten** aus.

   1. Wählen Sie im Modus **Bereitstellung überarbeiten die Option Bereitstellung** **überarbeiten** aus.

   1. **Wählen Sie bei jedem Schritt **Weiter** und anschließend Bereitstellen aus.**

1. Führen Sie den folgenden Befehl aus, um die Protokolle der Komponente erneut anzuzeigen und sicherzustellen, dass das Update verzögert wird.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln. Die Komponente verzögert das Update für 30 Sekunden, sodass die Komponente diese Meldung wiederholt ausgibt.

   ```
   Deferred update for deployment 50722a95-a05f-4e2a-9414-da80103269aa.
   ```

1. Verwenden Sie einen Texteditor, um die Datei mit dem virtuellen Akkuladestand zu bearbeiten und den Akkustand auf einen Wert über dem Schwellenwert zu ändern, damit die Bereitstellung fortgesetzt werden kann.
   + Bearbeiten Sie auf Linux-Core-Geräten die Datei mit dem Namen`/home/ggc_user/virtual_battery.json`. Führen Sie den Texteditor mit `sudo` Berechtigungen aus.
   + Bearbeiten Sie auf Windows Core-Geräten die Datei mit dem Namen`C:\Users\ggc_user\virtual_battery.json`. Führen Sie den Texteditor als Administrator aus.

   <a name="nano-command-intro"></a>Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.

   ```
   sudo nano /home/ggc_user/virtual_battery.json
   ```

   Ändern Sie den Akkuladestand auf. `80`

   ```
   {
     "battery_level": 80
   }
   ```

1. Führen Sie den folgenden Befehl aus, um die Protokolle der Komponente erneut einzusehen und zu überprüfen, ob das Update bestätigt wurde.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Sie sollten Meldungen sehen, die den folgenden Beispielen ähneln.

   ```
   Hello, World! Battery level (80) is above threshold (70), so the component will acknowledge updates.
   Acknowledged update for deployment f9499eb2-4a40-40a7-86c1-c89887d859f1.
   ```

Sie haben dieses Tutorial abgeschlossen. Die Hello World-Komponente verzögert oder bestätigt Updates je nach Akkuladestand des Kerngeräts. Weitere Informationen zu den Themen, die in diesem Tutorial behandelt werden, finden Sie im Folgenden:
+ [AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)
+ [Verwenden Sie den AWS IoT Device SDK , um mit dem Greengrass-Kern und anderen Komponenten zu kommunizieren und AWS IoT CoreKommunizieren Sie mit dem Greengrass-Kern, anderen Komponenten und AWS IoT Core](interprocess-communication.md)
+ [AWS IoT Greengrass Befehlszeilenschnittstelle für das Entwicklungskit](greengrass-development-kit-cli.md)