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: Erste Schritte mit AWS IoT Greengrass V2
Sie können dieses Tutorial für die ersten Schritte abschließen, um die grundlegenden Funktionen von zu erlernen AWS IoT Greengrass V2. In diesem Tutorial führen Sie folgende Aufgaben aus:
1. Installieren und konfigurieren Sie die AWS IoT Greengrass Core-Software auf einem Linux-Gerät, z. B. einem Raspberry Pi, oder einem Windows-Gerät. Dieses Gerät ist ein Greengrass-Core-Gerät.
1. Entwickeln Sie eine Hello World-Komponente auf Ihrem Greengrass-Core-Gerät. Komponenten sind Softwaremodule, die auf Greengrass-Kerngeräten ausgeführt werden.
1. Laden Sie diese Komponente AWS IoT Greengrass V2 in den AWS Cloud hoch.
1. Stellen Sie diese Komponente AWS Cloud auf Ihrem Greengrass-Core-Gerät bereit.
**Anmerkung**
In diesem Tutorial wird beschrieben, wie Sie eine Entwicklungsumgebung einrichten und die Funktionen von AWS IoT Greengrass kennenlernen. Weitere Informationen zum Einrichten und Konfigurieren von Produktionsgeräten finden Sie im Folgenden:
[Einrichtung von AWS IoT Greengrass Kerngeräten](setting-up.md)
[Installieren Sie die AWS IoT Greengrass Core-Software](install-greengrass-core-v2.md)
Sie können damit rechnen, 20 bis 30 Minuten für dieses Tutorial aufzuwenden.
**Topics**
+ [Voraussetzungen](getting-started-prerequisites.md)
+ [Schritt 1: Richten Sie ein AWS Konto ein](getting-started-set-up-aws-account.md)
+ [Schritt 2: Richten Sie Ihre Umgebung ein](getting-started-set-up-environment.md)
+ [Schritt 3: Installieren Sie die AWS IoT Greengrass Core-Software](install-greengrass-v2.md)
+ [Schritt 4: Entwickeln und testen Sie eine Komponente auf Ihrem Gerät](create-first-component.md)
+ [Schritt 5: Erstellen Sie Ihre Komponente im AWS IoT Greengrass Service](upload-first-component.md)
+ [Schritt 6: Stellen Sie Ihre Komponente bereit](deploy-first-component.md)
+ [Nächste Schritte](getting-started-next-steps.md)
# Voraussetzungen
Für dieses Tutorial benötigen Sie Folgendes:
+ Ein AWS-Konto. Falls Sie noch keines haben, beachten Sie die Informationen unter [Schritt 1: Richten Sie ein AWS Konto ein](getting-started-set-up-aws-account.md).
+ Die Verwendung einer [AWS-Region](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology), die unterstützt AWS IoT Greengrass V2. Eine vollständige Liste der unterstützten Regionen finden Sie unter [AWS IoT Greengrass V2 -Endpunkte und -Kontingente](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) in *Allgemeine AWS-Referenz*.
+ Ein AWS Identity and Access Management (IAM-) Benutzer mit Administratorrechten.
+ Ein Gerät, das als Greengrass-Core-Gerät eingerichtet werden kann, z. B. ein Raspberry Pi mit [Raspberry Pi OS](https://www.raspberrypi.org/downloads/) (früher Raspbian genannt) oder ein Windows 10-Gerät. Sie müssen über Administratorrechte für dieses Gerät verfügen oder Administratorrechte erwerben können, z. B. über. `sudo` Dieses Gerät muss über eine Internetverbindung verfügen.
Sie können sich auch dafür entscheiden, ein anderes Gerät zu verwenden, das die Anforderungen für die Installation und Ausführung der AWS IoT Greengrass Core-Software erfüllt.
Wenn Ihr Entwicklungscomputer diese Anforderungen erfüllt, können Sie ihn in diesem Tutorial als Ihr Greengrass-Core-Gerät einrichten.
+ [Python](https://www.python.org/downloads/) 3.5 oder höher wurde für alle Benutzer auf dem 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**
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*.
+ AWS Command Line Interface (AWS CLI) wurde auf Ihrem Entwicklungscomputer und auf Ihrem Gerät mit Anmeldeinformationen installiert und konfiguriert. Stellen Sie sicher, dass Sie dasselbe AWS-Region für die Konfiguration von AWS CLI auf Ihrem Entwicklungscomputer und auf Ihrem Gerät verwenden. Für die AWS CLI Verwendung AWS IoT Greengrass V2 mit benötigen Sie eine der folgenden Versionen oder höher:
+ Mindestversion AWS CLI V1: v1.18.197
+ Minimale AWS CLI V2-Version: v2.1.11
**Tipp**
Sie können den folgenden Befehl ausführen, um die Version von zu überprüfen AWS CLI , die Sie haben.
```
aws --version
```
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 ein 32-Bit-ARM-Gerät verwenden, z. B. einen Raspberry Pi mit einem 32-Bit-Betriebssystem, 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: Richten Sie ein AWS Konto ein
## Melde dich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Administratorbenutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Sie können Ihre aktuellen Kontoaktivitäten jederzeit einsehen und Ihr Konto verwalten, indem Sie zu [https://aws.amazon.com/](https://aws.amazon.com/)gehen und **Mein Konto** auswählen.
## Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center Benutzerhandbuch*.
# Schritt 2: Richten Sie Ihre Umgebung ein
**Anmerkung**
Diese Schritte gelten nicht für Nucleus Lite.
Folgen Sie den Schritten in diesem Abschnitt, um ein Linux- oder Windows-Gerät einzurichten, das als Ihr AWS IoT Greengrass Kerngerät verwendet werden soll.
## Richten Sie ein Linux-Gerät (Raspberry Pi) ein
Bei diesen Schritten wird davon ausgegangen, dass Sie einen Raspberry Pi mit Raspberry Pi OS verwenden. Wenn Sie ein anderes Gerät oder Betriebssystem verwenden, schlagen Sie in der entsprechenden Dokumentation für Ihr Gerät nach.
**Um einen Raspberry Pi einzurichten für AWS IoT Greengrass V2**
1. Aktivieren Sie SSH auf Ihrem Raspberry Pi, um eine Remoteverbindung herzustellen. Weitere Informationen finden Sie unter [SSH (Secure Shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) in der *Raspberry Pi-Dokumentation*.
1. Suchen Sie die IP-Adresse Ihres Raspberry Pi, um eine Verbindung mit ihm über SSH herzustellen. Dazu können Sie den folgenden Befehl auf Ihrem Raspberry Pi ausführen.
```
hostname -I
```
1. Stellen Sie mit SSH Connect zu Ihrem Raspberry Pi her.
Führen Sie auf Ihrem Entwicklungscomputer den folgenden Befehl aus. *username*Ersetzen Sie ihn durch den Namen des Benutzers, der sich anmelden soll, und *pi-ip-address* ersetzen Sie ihn durch die IP-Adresse, die Sie im vorherigen Schritt gefunden haben.
```
ssh username@pi-ip-address
```
**Wichtig**
Wenn Ihr Entwicklungscomputer eine frühere Version von Windows verwendet, verfügen Sie möglicherweise nicht über den `ssh` Befehl, oder Sie haben möglicherweise keine Verbindung zu Ihrem Raspberry Pi hergestellt, können `ssh` aber keine Verbindung herstellen. Um eine Verbindung zu Ihrem Raspberry Pi herzustellen, können Sie [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) installieren und konfigurieren, einen kostenlosen Open-Source-SSH-Client. Konsultieren Sie die [PuTTY-Dokumentation](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs), um eine Verbindung zu Ihrem Raspberry Pi herzustellen.
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Verwenden Sie auf Ihrem Raspberry Pi die folgenden Befehle, um Java 11 zu installieren.
```
sudo apt install default-jdk
```
Wenn die Installation abgeschlossen ist, führen Sie den folgenden Befehl aus, um zu überprüfen, ob Java auf Ihrem Raspberry Pi ausgeführt wird.
```
java -version
```
Der Befehl druckt die Version von Java, die auf dem Gerät ausgeführt wird. Die Ausgabe könnte dem folgenden Beispiel ähneln.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Tipp: Stellen Sie die Kernel-Parameter auf einem Raspberry Pi ein**
Wenn es sich bei Ihrem Gerät um einen Raspberry Pi handelt, können Sie die folgenden Schritte ausführen, um die Linux-Kernel-Parameter anzuzeigen und zu aktualisieren:
Öffnen Sie die `/boot/cmdline.txt` Datei. Diese Datei spezifiziert die Linux-Kernel-Parameter, die beim Booten des Raspberry Pi angewendet werden sollen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu öffnen.
```
sudo nano /boot/cmdline.txt
```
Stellen Sie sicher, dass die `/boot/cmdline.txt` Datei die folgenden Kernel-Parameter enthält. Der `systemd.unified_cgroup_hierarchy=0` Parameter gibt an, dass cgroups v1 statt cgroups v2 verwendet werden soll.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Wenn die `/boot/cmdline.txt` Datei diese Parameter nicht oder diese Parameter mit unterschiedlichen Werten enthält, aktualisieren Sie die Datei, sodass sie diese Parameter und Werte enthält.
Wenn Sie die `/boot/cmdline.txt` Datei aktualisiert haben, starten Sie den Raspberry Pi neu, um die Änderungen zu übernehmen.
```
sudo reboot
```
## Richten Sie ein Linux-Gerät ein (anderes)
**Um ein Linux-Gerät einzurichten für AWS IoT Greengrass V2**
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Wir empfehlen, dass Sie die [Langzeit-Support-Versionen von Amazon Corretto](https://aws.amazon.com/corretto/) oder [OpenJDK](https://openjdk.java.net/) verwenden. Version 8 oder höher ist erforderlich. Die folgenden Befehle zeigen Ihnen, wie Sie OpenJDK auf Ihrem Gerät installieren.
+ Für Debian- oder Ubuntu-basierte Distributionen:
```
sudo apt install default-jdk
```
+ Für Red Hat-basierte Distributionen:
```
sudo yum install java-11-openjdk-devel
```
+ Für Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Für Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Führen Sie nach Abschluss der Installation den folgenden Befehl aus, um zu überprüfen, ob Java auf Ihrem Linux-Gerät ausgeführt wird.
```
java -version
```
Der Befehl druckt die Version von Java, die auf dem Gerät ausgeführt wird. Bei einer Debian-basierten Distribution könnte die Ausgabe beispielsweise dem folgenden Beispiel ähneln.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Optional) Erstellen Sie den Standardsystembenutzer und die Standardgruppe, die Komponenten auf dem Gerät ausführen. Sie können auch festlegen, dass der AWS IoT Greengrass Core-Software-Installer diesen Benutzer und diese Gruppe während der Installation mit dem `--component-default-user` Installer-Argument erstellt. Weitere Informationen finden Sie unter [Argumente des Installers](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Stellen Sie sicher, dass der Benutzer, der die AWS IoT Greengrass Core-Software ausführt (normalerweise`root`), über die erforderlichen Rechte verfügt, die Software `sudo` mit jedem beliebigen Benutzer und jeder Gruppe auszuführen.
1. Führen Sie den folgenden Befehl aus, um die `/etc/sudoers` Datei zu öffnen.
```
sudo visudo
```
1. Stellen Sie sicher, dass die Berechtigung für den Benutzer wie im folgenden Beispiel aussieht.
```
root ALL=(ALL:ALL) ALL
```
1. *(Optional) Um [containerisierte Lambda-Funktionen auszuführen](run-lambda-functions.md), müssen Sie [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 aktivieren und Sie müssen die *Speicher* - und Geräte-Cgroups aktivieren und mounten.* Wenn Sie nicht vorhaben, containerisierte Lambda-Funktionen auszuführen, können Sie diesen Schritt überspringen.
Um diese Cgroups-Optionen zu aktivieren, starten Sie das Gerät mit den folgenden Linux-Kernelparametern.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Informationen zum Anzeigen und Einstellen der Kernel-Parameter für Ihr Gerät finden Sie in der Dokumentation zu Ihrem Betriebssystem und Bootloader. Folgen Sie den Anweisungen, um die Kernel-Parameter dauerhaft einzustellen.
1. Installieren Sie alle anderen erforderlichen Abhängigkeiten auf Ihrem Gerät, wie in der Liste der Anforderungen unter angegeben[Anforderungen an Speichergeräte](greengrass-nucleus-component.md#greengrass-v2-requirements).
## Richten Sie ein Windows-Gerät ein
**Um ein Windows-Gerät einzurichten für AWS IoT Greengrass V2**
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Wir empfehlen, dass Sie die [Langzeit-Support-Versionen von Amazon Corretto](https://aws.amazon.com/corretto/) oder [OpenJDK](https://openjdk.java.net/) verwenden. Version 8 oder höher ist erforderlich.
1. Prüfen Sie, ob Java in der Systemvariablen [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) verfügbar ist, und fügen Sie es hinzu, falls nicht. Auf dem LocalSystem Konto wird die AWS IoT Greengrass Core-Software ausgeführt, sodass Sie der Systemvariablen PATH statt der Benutzervariablen PATH für Ihren Benutzer Java hinzufügen müssen. Gehen Sie wie folgt vor:
1. Drücken Sie die Windows-Taste, um das Startmenü zu öffnen.
1. Geben Sie **environment variables** ein, um im Startmenü nach den Systemoptionen zu suchen.
1. Wählen Sie in den Suchergebnissen des Startmenüs **die Option Systemumgebungsvariablen bearbeiten** aus, um das Fenster mit den **Systemeigenschaften** zu öffnen.
1. Wählen Sie **Umgebungsvariablen...** um das Fenster **Umgebungsvariablen** zu öffnen.
1. Wählen Sie unter **Systemvariablen** die Option **Pfad** und dann **Bearbeiten** aus. Im Fenster **Umgebungsvariable bearbeiten** können Sie jeden Pfad in einer separaten Zeile anzeigen.
1. Überprüfen Sie, ob der Pfad zum `bin` Ordner der Java-Installation vorhanden ist. Der Pfad könnte dem folgenden Beispiel ähneln.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Wenn der `bin` Ordner der Java-Installation in **Path** fehlt, wählen Sie **Neu**, um ihn hinzuzufügen, und **klicken Sie dann auf OK**.
1. Öffnen Sie die Windows-Eingabeaufforderung (`cmd.exe`) als Administrator.
1. Erstellen Sie den Standardbenutzer für das LocalSystem Konto auf dem Windows-Gerät. *password*Durch ein sicheres Passwort ersetzen.
```
net user /add ggc_user password
```
**Tipp**
Abhängig von Ihrer Windows-Konfiguration ist das Benutzerkennwort möglicherweise so eingestellt, dass es an einem Datum in der future abläuft. Um sicherzustellen, dass Ihre Greengrass-Anwendungen weiterhin funktionieren, verfolgen Sie, wann das Passwort abläuft, und aktualisieren Sie es, bevor es abläuft. Sie können das Benutzerkennwort auch so einrichten, dass es niemals abläuft.
Führen Sie den folgenden Befehl aus, um zu überprüfen, wann ein Benutzer und sein Passwort ablaufen.
```
net user ggc_user | findstr /C:expires
```
Führen Sie den folgenden Befehl aus, um das Passwort eines Benutzers so einzustellen, dass es nie abläuft.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Wenn Sie Windows 10 oder höher verwenden und der [`wmic`Befehl veraltet ist](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), führen Sie den folgenden PowerShell Befehl aus.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Laden Sie das [PsExecProgramm](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) von Microsoft herunter und installieren Sie es auf dem Gerät.
1. Verwenden Sie das PsExec Hilfsprogramm, um den Benutzernamen und das Passwort für den Standardbenutzer in der Credential Manager-Instanz für das LocalSystem Konto zu speichern. *password*Ersetzen Sie es durch das zuvor festgelegte Benutzerkennwort.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Wenn das **PsExec License Agreement**geöffnet wird, stimmen Sie **Accept**der Lizenz zu und führen Sie den Befehl aus.
**Anmerkung**
Auf Windows-Geräten wird auf dem LocalSystem Konto der Greengrass-Nucleus ausgeführt, und Sie müssen das PsExec Hilfsprogramm verwenden, um die Standardbenutzerinformationen im LocalSystem Konto zu speichern. Wenn Sie die Credential Manager-Anwendung verwenden, werden diese Informationen nicht im Konto, sondern im Windows-Konto des aktuell angemeldeten Benutzers gespeichert. LocalSystem
# Schritt 3: Installieren Sie die AWS IoT Greengrass Core-Software
**Tipp**
Wir empfehlen Ihnen, das [AWS IoT Greengrass AI Agents Context Pack](https://github.com/aws-greengrass/greengrass-agent-context-pack) auszuprobieren, um AWS IoT Greengrass schnell einzurichten und damit zu experimentieren. Das Agent Context Pack ermöglicht es KI-Agenten, Greengrass Nucleus und Nucleus Lite einzurichten, Komponenten bereitzustellen und häufig auftretende Probleme zu beheben.
Folgen Sie den Schritten in diesem Abschnitt, um Ihren Raspberry Pi als AWS IoT Greengrass Kerngerät einzurichten, das Sie für die lokale Entwicklung verwenden können. In diesem Abschnitt laden Sie ein Installationsprogramm herunter und führen es aus, das wie folgt vorgeht, um die AWS IoT Greengrass Core-Software für Ihr Gerät zu konfigurieren:
+ Installiert die Greengrass Nucleus-Komponente. Der Nucleus ist eine obligatorische Komponente und die Mindestanforderung, um die AWS IoT Greengrass Core-Software auf einem Gerät auszuführen. Weitere Informationen finden Sie unter [Greengrass-Kernkomponente](greengrass-nucleus-component.md).
+ Registriert Ihr Gerät als Objekt AWS IoT und lädt ein digitales Zertifikat herunter, mit dem Ihr Gerät eine Verbindung herstellen AWS kann. Weitere Informationen finden Sie unter [Geräteauthentifizierung und Autorisierung für AWS IoT Greengrass](device-auth.md).
+ Fügt das AWS IoT Ding des Geräts einer Dinggruppe hinzu, bei der es sich um eine Gruppe oder eine Flotte von AWS IoT Dingen handelt. Mit Dinggruppen können Sie Flotten von Greengrass-Core-Geräten verwalten. Wenn Sie Softwarekomponenten auf Ihren Geräten bereitstellen, können Sie wählen, ob Sie sie auf einzelnen Geräten oder auf Gerätegruppen bereitstellen möchten. Weitere Informationen finden Sie AWS IoT im *AWS IoT Core Entwicklerhandbuch* unter [Geräte verwalten mit](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html).
+ Erstellt die IAM-Rolle, die es Ihrem Greengrass-Core-Gerät ermöglicht, mit AWS Diensten zu interagieren. Standardmäßig ermöglicht diese Rolle Ihrem Gerät, mit Amazon Logs zu interagieren AWS IoT und Protokolle an Amazon CloudWatch Logs zu senden. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
+ Installiert die AWS IoT Greengrass Befehlszeilenschnittstelle (`greengrass-cli`), mit der Sie benutzerdefinierte Komponenten testen können, die Sie auf dem Kerngerät entwickeln. Weitere Informationen finden Sie unter [Greengrass-Befehlszeilenschnittstelle](gg-cli.md).
# Installieren Sie die AWS IoT Greengrass Core-Software (Konsole)
1. Melden Sie sich an der [AWS IoT Greengrass -Konsole](https://console.aws.amazon.com/greengrass) an.
1. Wählen **Sie unter Erste Schritte mit Greengrass** die Option **Kerngerät einrichten** aus.
1. Geben Sie unter **Schritt 1: Ein Greengrass-Core-Gerät registrieren** unter **Core-Gerätename** den Namen des AWS IoT Geräts für Ihr Greengrass-Core-Gerät ein. Wenn das Ding nicht existiert, erstellt es das Installationsprogramm.
1. Wählen Sie unter **Schritt 2: Zu einer Dinggruppe hinzufügen, um eine kontinuierliche Bereitstellung anzuwenden**, **für Dinggruppe** die AWS IoT Dinggruppe aus, zu der Sie Ihr Kerngerät hinzufügen möchten.
+ Wenn Sie **Neuen Gruppennamen eingeben** auswählen, geben Sie im Feld **Name der Dinggruppe** den Namen der neuen Gruppe ein, die erstellt werden soll. Das Installationsprogramm erstellt die neue Gruppe für Sie.
+ Wenn Sie **Vorhandene Gruppe auswählen auswählen wählen**, wählen Sie im **Feld Name der Dinggruppe** die bestehende Gruppe aus, die Sie verwenden möchten.
+ Wenn Sie **Keine Gruppe** auswählen, fügt das Installationsprogramm das Kerngerät keiner Dinggruppe hinzu.
1. Führen Sie unter **Schritt 3: Installation der Greengrass Core-Software** die folgenden Schritte aus.
------
#### [ Nucleus classic ]
1. Wählen Sie **Nucleus classic** als Software-Runtime für Ihr Kerngerät.
1. Wählen Sie das Betriebssystem Ihres Kerngeräts: **Linux** oder **Windows**.
1. Geben Sie Ihre AWS Anmeldeinformationen für das Gerät ein, damit das Installationsprogramm die AWS IoT und IAM-Ressourcen für Ihr Kerngerät bereitstellen kann. Um die Sicherheit zu erhöhen, empfehlen wir Ihnen, temporäre Anmeldeinformationen für eine IAM-Rolle zu erwerben, die nur die für die Bereitstellung erforderlichen Mindestberechtigungen gewährt. Weitere Informationen finden Sie unter [Minimale IAM-Richtlinie für das Installationsprogramm zur Bereitstellung von Ressourcen](provision-minimal-iam-policy.md).
**Anmerkung**
Das Installationsprogramm speichert oder speichert Ihre Anmeldeinformationen nicht.
Führen Sie auf Ihrem Gerät einen der folgenden Schritte aus, um die Anmeldeinformationen abzurufen und sie dem AWS IoT Greengrass Core-Software-Installationsprogramm zur Verfügung zu stellen:
+ (Empfohlen) Verwenden Sie temporäre Anmeldeinformationen von AWS IAM Identity Center
1. Geben Sie die Zugriffsschlüssel-ID, den geheimen Zugriffsschlüssel und das Sitzungstoken aus dem IAM Identity Center ein. Weitere Informationen finden Sie unter **Manuelles Aktualisieren von Anmeldeinformationen im Abschnitt** [Temporäre Anmeldeinformationen abrufen und aktualisieren](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) im *IAM Identity Center-Benutzerhandbuch*.
1. Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen für die AWS IoT Greengrass Core-Software bereitzustellen.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Verwenden Sie temporäre Sicherheitsanmeldeinformationen aus einer IAM-Rolle:
1. Geben Sie die Zugriffsschlüssel-ID, den geheimen Zugriffsschlüssel und das Sitzungstoken aus einer IAM-Rolle an, die Sie annehmen. Weitere Informationen zum Abrufen dieser Anmeldeinformationen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen anfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) im *IAM-Benutzerhandbuch*.
1. Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen für die AWS IoT Greengrass Core-Software bereitzustellen.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Verwenden Sie langfristige Anmeldeinformationen von einem IAM-Benutzer:
1. Geben Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel für Ihren IAM-Benutzer an. Sie können einen IAM-Benutzer für die Bereitstellung erstellen, den Sie später löschen. Informationen zur IAM-Richtlinie, die dem Benutzer zur Verfügung gestellt werden soll, finden Sie unter. [Minimale IAM-Richtlinie für das Installationsprogramm zur Bereitstellung von Ressourcen](provision-minimal-iam-policy.md) Weitere Informationen zum Abrufen langfristiger Anmeldeinformationen finden Sie unter [Verwaltung von Zugriffsschlüsseln für IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) im *IAM-Benutzerhandbuch*.
1. Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen für die AWS IoT Greengrass Core-Software bereitzustellen.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (Optional) Wenn Sie einen IAM-Benutzer für die Bereitstellung Ihres Greengrass-Geräts erstellt haben, löschen Sie den Benutzer.
1. (Optional) Wenn Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel eines vorhandenen IAM-Benutzers verwendet haben, aktualisieren Sie die Schlüssel für den Benutzer, sodass sie nicht mehr gültig sind. Weitere Informationen finden Sie im *AWS Identity and Access Management Benutzerhandbuch* unter [Aktualisieren von Zugriffsschlüsseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
1. **Führen Sie unter Das Installationsprogramm** ausführen die folgenden Schritte aus.
1. Wählen **Sie unter Das Installationsprogramm herunterladen die** Option **Kopieren** aus und führen Sie den kopierten Befehl auf Ihrem Hauptgerät aus. Mit diesem Befehl wird die neueste Version der AWS IoT Greengrass Core-Software heruntergeladen und auf Ihrem Gerät entpackt.
1. Wählen **Sie unter Das Installationsprogramm ausführen die** Option **Kopieren** aus und führen Sie den kopierten Befehl auf Ihrem Core-Gerät aus. Dieser Befehl verwendet die Namen der AWS IoT Dinge und der Dinggruppen, die Sie zuvor angegeben haben, um das AWS IoT Greengrass Core-Softwareinstallationsprogramm auszuführen und AWS Ressourcen für Ihr Kerngerät einzurichten.
Dieser Befehl führt außerdem Folgendes aus:
+ Richten Sie die AWS IoT Greengrass Core-Software als Systemdienst ein, der beim Booten ausgeführt wird. Auf Linux-Geräten erfordert dies das [Systemd-Init-System](https://en.wikipedia.org/wiki/Systemd).
**Wichtig**
Auf Windows Core-Geräten müssen Sie die AWS IoT Greengrass Core-Software als Systemdienst einrichten.
+ Stellen Sie die [AWS IoT Greengrass CLI-Komponente](gg-cli.md) bereit, ein Befehlszeilentool, mit dem Sie benutzerdefinierte Greengrass-Komponenten auf dem Kerngerät entwickeln können.
+ Geben Sie an, dass der `ggc_user` Systembenutzer zur Ausführung von Softwarekomponenten auf dem Kerngerät verwendet werden soll. Auf Linux-Geräten gibt dieser Befehl auch an, dass die `ggc_group` Systemgruppe verwendet werden soll, und das Installationsprogramm erstellt den Systembenutzer und die Systemgruppe für Sie.
Wenn Sie diesen Befehl ausführen, sollten Sie die folgenden Meldungen sehen, die darauf hinweisen, dass die Installation erfolgreich war.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Anmerkung**
Wenn Sie ein Linux-Gerät haben und es nicht über [Systemd](https://en.wikipedia.org/wiki/Systemd) verfügt, richtet das Installationsprogramm die Software nicht als Systemdienst ein, und die Erfolgsmeldung für die Einrichtung des Nucleus als Systemdienst wird nicht angezeigt.
------
#### [ Nucleus lite ]
1. Wählen Sie **Nucleus Lite** als Software-Runtime für Ihr Kerngerät.
1. Wählen Sie Ihre Geräteeinrichtungsmethode aus, um Ihr Gerät für ein Greengrass-Core-Gerät bereitzustellen.
**Option 1: Richten Sie ein Gerät mit Paket-Download ein (ca. 1 MB)**
1. Erstelle ein AWS IoT Ding und die Rolle für Greengrass.
1. Laden Sie die ZIP-Datei herunter, die AWS IoT Ressourcen enthält, mit denen Ihr Gerät eine Verbindung herstellen muss AWS IoT:
+ Ein Zertifikat und ein privater Schlüssel, die mithilfe AWS IoT der Zertifizierungsstelle generiert wurden.
+ Eine Schemadatei, um die Greengrass-Installation für Ihr Gerät zu initiieren.
1. Laden Sie das Paket herunter, mit dem die neueste Greengrass Nucleus Lite-Laufzeit auf Ihrem Raspberry Pi installiert wird.
1. Richten Sie Ihr Gerät als AWS IoT Greengrass Core-Gerät ein und verbinden Sie es mit: AWS IoT
1. a. Übertragen Sie das Greengrass-Paket und das Verbindungskit mit einem USB-Stick, SCP/FTP oder SD-Karten auf Ihr Gerät.
1. b. Entpacken Sie die Datei greengrass-package.zip im GreengrassInstaller Verzeichnis/auf dem Gerät.
1. c. Entpacken Sie die ZIP-Datei des Connection Kits im Verzeichnis /auf dem Gerät.
1. d. Führen Sie zur Installation den bereitgestellten Befehl auf dem Gerät aus AWS IoT Greengrass
1. Wählen Sie dann „**Kerngeräte anzeigen**“.
**Option 2: Richten Sie ein Gerät mit einem vorkonfigurierten Beispiel-Image-Download für die gesamte Festplatte ein (ca. 100 MB)**
1. Erstelle ein AWS IoT Ding und die Rolle für Greengrass.
1. Laden Sie die ZIP-Datei herunter, die AWS IoT Ressourcen enthält, mit denen Ihr Gerät eine Verbindung herstellen muss AWS IoT:
+ Ein Zertifikat und ein privater Schlüssel, die mithilfe AWS IoT der Zertifizierungsstelle generiert wurden.
+ Eine Schemadatei, um die Greengrass-Installation für Ihr Gerät zu initiieren.
1. Laden Sie das vorkonfigurierte Beispiel-Image für die gesamte Festplatte herunter, das Greengrass und das Betriebssystem enthält.
1. Folgen Sie der Readme-Datei, die zusammen mit dem Image heruntergeladen wurde, um das Verbindungskit zu übertragen und das Image auf Ihr Gerät zu flashen.
1. Um die Greengrass-Installation zu starten, schalten Sie das Gerät ein und starten Sie es von dem Flash-Image aus
1. Wählen Sie dann „**Kerngeräte anzeigen**“.
**Option 3: Richten Sie ein Gerät mit Ihrem eigenen Build ein**
1. Erstelle ein AWS IoT Ding und die Rolle für Greengrass.
1. Laden Sie die ZIP-Datei herunter, die AWS IoT Ressourcen enthält, mit denen Ihr Gerät eine Verbindung herstellen muss AWS IoT:
+ Ein Zertifikat und ein privater Schlüssel, die mithilfe AWS IoT der Zertifizierungsstelle generiert wurden.
+ Eine Schemadatei, um die Greengrass-Installation für Ihr Gerät zu initiieren.
1. Um Ihr eigenes Image mit Yocto aus dem Quellcode anzupassen und zu erstellen und anschließend das Verbindungskit zur Installation von Nucleus Lite zu verwenden, folgen Sie den Anweisungen unter. GitHub
1. Wählen Sie dann „**Kerngeräte anzeigen**“.
------
# Installieren Sie die AWS IoT Greengrass Core-Software (CLI)
**Anmerkung**
Diese Schritte gelten nicht für Nucleus Lite.
**Um die AWS IoT Greengrass Core-Software zu installieren und zu konfigurieren**
1. Führen Sie auf Ihrem Greengrass-Core-Gerät den folgenden Befehl aus, um zum Home-Verzeichnis zu wechseln.
------
#### [ Linux or Unix ]
```
cd ~
```
------
#### [ Windows Command Prompt (CMD) ]
```
cd %USERPROFILE%
```
------
#### [ PowerShell ]
```
cd ~
```
------
1. Laden Sie auf Ihrem Core-Gerät die AWS IoT Greengrass Core-Software in eine Datei mit dem Namen `greengrass-nucleus-latest.zip` herunter.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Mit dem Download dieser Software stimmen Sie der [Greengrass Core-Software-Lizenzvereinbarung](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf) zu.
1. Entpacken Sie die AWS IoT Greengrass Core-Software in einen Ordner auf Ihrem Gerät. *GreengrassInstaller*Ersetzen Sie es durch den Ordner, den Sie verwenden möchten.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. Führen Sie den folgenden Befehl aus, um das AWS IoT Greengrass Core-Softwareinstallationsprogramm zu starten. Der Befehl hat folgende Auswirkungen:
+ Erstellen Sie die AWS Ressourcen, die das Kerngerät für den Betrieb benötigt.
+ Richten Sie die AWS IoT Greengrass Core-Software als Systemdienst ein, der beim Booten ausgeführt wird. Auf Linux-Geräten erfordert dies das [Systemd-Init-System](https://en.wikipedia.org/wiki/Systemd).
**Wichtig**
Auf Windows Core-Geräten müssen Sie die AWS IoT Greengrass Core-Software als Systemdienst einrichten.
+ Stellen Sie die [AWS IoT Greengrass CLI-Komponente](gg-cli.md) bereit. Dabei handelt es sich um ein Befehlszeilentool, mit dem Sie benutzerdefinierte Greengrass-Komponenten auf dem Kerngerät entwickeln können.
+ Geben Sie an, dass der `ggc_user` Systembenutzer zur Ausführung von Softwarekomponenten auf dem Kerngerät verwendet werden soll. Auf Linux-Geräten gibt dieser Befehl auch an, dass die `ggc_group` Systemgruppe verwendet werden soll, und das Installationsprogramm erstellt den Systembenutzer und die Systemgruppe für Sie.
Ersetzen Sie die Argumentwerte in Ihrem Befehl wie folgt.
1. `/greengrass/v2`oder*C:\$1greengrass\$1v2*: Der Pfad zum Stammordner, der für die Installation der AWS IoT Greengrass Core-Software verwendet werden soll.
1. *GreengrassInstaller*. Der Pfad zu dem Ordner, in den Sie das AWS IoT Greengrass Core-Softwareinstallationsprogramm entpackt haben.
1. *region*. Das, AWS-Region in dem Ressourcen gefunden oder erstellt werden sollen.
1. *MyGreengrassCore*. Der Name der AWS IoT Sache für Ihr Greengrass-Core-Gerät. Wenn das Ding nicht existiert, erstellt es das Installationsprogramm. Das Installationsprogramm lädt die Zertifikate herunter, um sich als das AWS IoT Ding zu authentifizieren. Weitere Informationen finden Sie unter [Geräteauthentifizierung und Autorisierung für AWS IoT Greengrass](device-auth.md).
**Anmerkung**
Der Name der Sache darf keine Doppelpunkte (`:`) enthalten.
1. *MyGreengrassCoreGroup*. Der Name der AWS IoT Dinggruppe für Ihr Greengrass-Core-Gerät. Wenn die Dinggruppe nicht existiert, erstellt das Installationsprogramm sie und fügt ihr das Ding hinzu. Wenn die Dinggruppe vorhanden ist und über eine aktive Bereitstellung verfügt, lädt das Kerngerät die in der Bereitstellung angegebene Software herunter und führt sie aus.
**Anmerkung**
Der Name der Dinggruppe darf keine Doppelpunkte (`:`) enthalten.
1. *GreengrassV2IoTThingPolicy*. Der Name der AWS IoT Richtlinie, die es den Greengrass-Core-Geräten ermöglicht, mit AWS IoT und AWS IoT Greengrass zu kommunizieren. Wenn die AWS IoT Richtlinie nicht existiert, erstellt das Installationsprogramm eine zulässige AWS IoT Richtlinie mit diesem Namen. Sie können die Berechtigungen dieser Richtlinie für Ihren Anwendungsfall einschränken. Weitere Informationen finden Sie unter [Minimale AWS IoT Richtlinie für AWS IoT Greengrass V2 Kerngeräte](device-auth.md#greengrass-core-minimal-iot-policy).
1. *GreengrassV2TokenExchangeRole*. Der Name der IAM-Rolle, die es dem Greengrass-Core-Gerät ermöglicht, temporäre AWS Anmeldeinformationen abzurufen. Wenn die Rolle nicht existiert, erstellt das Installationsprogramm sie und erstellt und fügt eine Richtlinie mit dem Namen hinzu. `GreengrassV2TokenExchangeRoleAccess` Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
1. *GreengrassCoreTokenExchangeRoleAlias*. Der Alias für die IAM-Rolle, der es dem Greengrass-Core-Gerät ermöglicht, später temporäre Anmeldeinformationen abzurufen. Wenn der Rollenalias nicht existiert, erstellt ihn das Installationsprogramm und verweist ihn auf die von Ihnen angegebene IAM-Rolle. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true \
--deploy-dev-tools true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true ^
--deploy-dev-tools true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true `
--deploy-dev-tools true
```
------
**Anmerkung**
Wenn Sie AWS IoT Greengrass auf einem Gerät mit begrenztem Arbeitsspeicher arbeiten, können Sie die Speichermenge steuern, die die AWS IoT Greengrass Core-Software verwendet. Um die Speicherzuweisung zu steuern, können Sie im `jvmOptions` Konfigurationsparameter Ihrer Nucleus-Komponente die Optionen für die JVM-Heap-Größe festlegen. Weitere Informationen finden Sie unter [Steuern Sie die Speicherzuweisung mit JVM-Optionen](configure-greengrass-core-v2.md#jvm-tuning).
Wenn Sie diesen Befehl ausführen, sollten Sie die folgenden Meldungen sehen, die darauf hinweisen, dass die Installation erfolgreich war.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**Anmerkung**
Wenn Sie ein Linux-Gerät haben und es nicht über [Systemd](https://en.wikipedia.org/wiki/Systemd) verfügt, richtet das Installationsprogramm die Software nicht als Systemdienst ein, und die Erfolgsmeldung für die Einrichtung des Nucleus als Systemdienst wird nicht angezeigt.
# (Optional) Führen Sie die Greengrass-Software aus (Linux)
**Anmerkung**
Diese Schritte gelten nicht für Nucleus Lite.
Wenn Sie die Software als Systemdienst installiert haben, führt das Installationsprogramm die Software für Sie aus. Andernfalls müssen Sie die Software ausführen. Um zu sehen, ob das Installationsprogramm die Software als Systemdienst eingerichtet hat, suchen Sie in der Ausgabe des Installationsprogramms nach der folgenden Zeile.
```
Successfully set up Nucleus as a system service
```
Wenn Sie diese Meldung nicht sehen, gehen Sie wie folgt vor, um die Software auszuführen:
1. Führen Sie den folgenden Befehl aus, um die Software auszuführen.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
Die Software druckt die folgende Meldung, wenn sie erfolgreich gestartet wurde.
```
Launched Nucleus successfully.
```
1. Sie müssen die aktuelle Befehlsshell geöffnet lassen, damit die AWS IoT Greengrass Core-Software weiter ausgeführt werden kann. Wenn Sie SSH verwenden, um eine Verbindung zum Core-Gerät herzustellen, führen Sie den folgenden Befehl auf Ihrem Entwicklungscomputer aus, um eine zweite SSH-Sitzung zu öffnen, mit der Sie zusätzliche Befehle auf dem Core-Gerät ausführen können. *username*Ersetzen Sie es durch den Namen des Benutzers, der sich anmelden soll, und *pi-ip-address* ersetzen Sie es durch die IP-Adresse des Geräts.
```
ssh username@pi-ip-address
```
Weitere Informationen zur Interaktion mit dem Greengrass-Systemdienst finden Sie unter[Den Greengrass Nucleus als Systemdienst konfigurieren](configure-greengrass-core-v2.md#configure-system-service).
# Überprüfen Sie die Greengrass CLI-Installation auf dem Gerät
**Anmerkung**
Diese Schritte gelten nicht für Nucleus Lite.
Die Bereitstellung der Greengrass-CLI kann bis zu einer Minute dauern. Führen Sie den folgenden Befehl aus, um den Status der Bereitstellung zu überprüfen. *MyGreengrassCore*Ersetzen Sie ihn durch den Namen Ihres Kerngeräts.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore
```
Das `coreDeviceExecutionStatus` gibt den Status der Bereitstellung auf dem Kerngerät an. Wenn der Status lautet`SUCCEEDED`, führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Greengrass-CLI installiert ist und ausgeführt wird. `/greengrass/v2`Ersetzen Sie ihn durch den Pfad zum Stammordner.
------
#### [ Linux or Unix ]
```
/greengrass/v2/bin/greengrass-cli help
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
Der Befehl gibt Hilfeinformationen für die Greengrass-CLI aus. Wenn das `greengrass-cli` nicht gefunden wird, konnte die Greengrass-CLI bei der Bereitstellung möglicherweise nicht installiert werden. Weitere Informationen finden Sie unter [Problembehebung AWS IoT Greengrass V2](troubleshooting.md).
Sie können auch den folgenden Befehl ausführen, um die AWS IoT Greengrass CLI manuell auf Ihrem Gerät bereitzustellen.
+ *region*Ersetzen Sie es durch AWS-Region das, was Sie verwenden. Stellen Sie sicher, dass Sie dasselbe verwenden AWS-Region , das Sie zur Konfiguration AWS CLI auf Ihrem Gerät verwendet haben.
+ Ersetze es *account-id* durch deine AWS-Konto ID.
+ *MyGreengrassCore*Ersetzen Sie es durch den Namen Ihres Kerngeräts.
------
#### [ Linux, macOS, or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--components '{
"aws.greengrass.Cli": {
"componentVersion": "2.16.1"
}
}'
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}"
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}'
```
------
**Tipp**
Sie können Ihrer `PATH` Umgebungsvariablen `/greengrass/v2/bin` (Linux) oder `C:\greengrass\v2\bin` (Windows) hinzufügen, um sie `greengrass-cli` ohne ihren absoluten Pfad auszuführen.
Die AWS IoT Greengrass Core-Software und die lokalen Entwicklungstools werden auf Ihrem Gerät ausgeführt. Als Nächstes können Sie eine Hello AWS IoT Greengrass World-Komponente auf Ihrem Gerät entwickeln.
# Schritt 4: Entwickeln und testen Sie eine Komponente auf Ihrem Gerät
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. Jede Komponente besteht aus einem *Rezept* und *Artefakten*.
+ **Rezepte**
Jede Komponente enthält eine Rezeptdatei, die ihre Metadaten definiert. Das Rezept spezifiziert auch die Konfigurationsparameter, die Komponentenabhängigkeiten, den Lebenszyklus und die Plattformkompatibilität der Komponente. Der Komponentenlebenszyklus definiert die Befehle, mit denen die Komponente installiert, ausgeführt und heruntergefahren wird. Weitere Informationen finden Sie unter [AWS IoT Greengrass Referenz zum Komponenten-Rezept](component-recipe-reference.md).
Sie können Rezepte im [JSON](https://en.wikipedia.org/wiki/JSON) - oder [YAML-Format](https://en.wikipedia.org/wiki/YAML) definieren.
+ **Artefakte**
Komponenten können eine beliebige Anzahl von Artefakten haben, bei denen es sich um Komponenten-Binärdateien handelt. Artefakte können Skripts, kompilierten Code, statische Ressourcen und alle anderen Dateien umfassen, die eine Komponente verwendet. Komponenten können auch Artefakte aus Komponentenabhängigkeiten verwenden.
Mit können Sie die Greengrass-CLI verwenden AWS IoT Greengrass, um Komponenten lokal auf einem Greengrass-Core-Gerät ohne Interaktion mit der AWS Cloud zu entwickeln und zu testen. Wenn Sie Ihre lokale Komponente fertiggestellt haben, können Sie das Komponentenrezept und die Artefakte verwenden, um diese Komponente im AWS IoT Greengrass Service in der AWS Cloud zu erstellen und sie dann auf all Ihren Greengrass-Kerngeräten bereitzustellen. Weitere Informationen zu Komponenten finden Sie unter[AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md).
In diesem Abschnitt erfahren Sie, wie Sie eine grundlegende Hello World-Komponente lokal auf Ihrem Kerngerät erstellen und ausführen.
**Um eine Hello World-Komponente auf Ihrem Gerät zu entwickeln**
1. Erstellen Sie einen Ordner für Ihre Komponenten mit Unterordnern für Rezepte und Artefakte. Führen Sie die folgenden Befehle auf Ihrem Greengrass-Core-Gerät aus, um diese Ordner zu erstellen und zum Komponentenordner zu wechseln. Ersetzen Sie *\$1/greengrassv2* oder *%USERPROFILE%\$1greengrassv2* durch den Pfad zu dem Ordner, der für die lokale Entwicklung verwendet werden soll.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Verwenden Sie einen Texteditor, um eine Rezeptdatei zu erstellen, die die Metadaten, Parameter, Abhängigkeiten, den Lebenszyklus und die Plattformfähigkeit Ihrer Komponente definiert. Nehmen Sie die Komponentenversion in den Namen der Rezeptdatei auf, damit Sie erkennen können, welches Rezept welche Komponentenversion widerspiegelt. Sie können das YAML- oder das JSON-Format für Ihr Rezept wählen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**Anmerkung**
AWS IoT Greengrass verwendet semantische Versionen für Komponenten. *Semantische Versionen folgen einem Hauptteil.* *geringfügig*. *Patch-Nummernsystem*. Version `1.0.0` steht beispielsweise für die erste Hauptversion einer Komponente. Weitere Informationen finden Sie in der [semantischen Versionsspezifikation](https://semver.org/).
1. Fügen Sie das folgende Rezept in die Datei ein.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
Der `ComponentConfiguration` Abschnitt dieses Rezepts definiert einen Parameter,`Message`, der standardmäßig ist. `world` Der `Manifests` Abschnitt definiert ein *Manifest*, bei dem es sich um eine Reihe von Lebenszyklusanweisungen und Artefakten für eine Plattform handelt. Sie können mehrere Manifeste definieren, um beispielsweise unterschiedliche Installationsanweisungen für verschiedene Plattformen anzugeben. Im Manifest weist der `Lifecycle` Abschnitt das Greengrass-Core-Gerät an, das Hello World-Skript mit dem `Message` Parameterwert als Argument auszuführen.
1. Führen Sie den folgenden Befehl aus, um einen Ordner für die Komponentenartefakte zu erstellen.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
**Wichtig**
Sie müssen das folgende Format für den Artefaktordnerpfad verwenden. Geben Sie den Komponentennamen und die Version an, die Sie im Rezept angeben.
```
artifacts/componentName/componentVersion/
```
1. Verwenden Sie einen Texteditor, um eine Python-Skript-Artefaktdatei für Ihre Hello World-Komponente zu erstellen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Kopieren Sie das folgende Python-Skript und fügen Sie es in die Datei ein.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Verwenden Sie die lokale AWS IoT Greengrass CLI, um Komponenten auf Ihrem Greengrass-Core-Gerät zu verwalten.
Führen Sie den folgenden Befehl aus, um die Komponente auf dem AWS IoT Greengrass Core bereitzustellen. Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch Ihren AWS IoT Greengrass V2 Stammordner und ersetzen Sie *\$1/greengrassv2* oder *%USERPROFILE%\$1greengrassv2* durch Ihren Entwicklungsordner für Komponenten.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Dieser Befehl fügt die Komponente hinzu, die das Rezept verwendet, `recipes` und das Python-Skript in`artifacts`. Die `--merge` Option fügt die von Ihnen angegebene Komponente und Version hinzu oder aktualisiert sie.
1. Die AWS IoT Greengrass Core-Software speichert Standarddaten aus dem Komponentenprozess 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 Nachrichten druckt.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Der `type` Befehl schreibt den Inhalt der Datei in das Terminal. Führen Sie diesen Befehl mehrmals aus, um Änderungen in der Datei zu beobachten.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.
```
Hello, world!
```
**Anmerkung**
Wenn die Datei nicht existiert, ist die lokale Bereitstellung möglicherweise noch nicht abgeschlossen. Wenn die Datei nicht innerhalb von 15 Sekunden existiert, ist die Bereitstellung wahrscheinlich fehlgeschlagen. Dies kann beispielsweise der Fall sein, wenn Ihr Rezept nicht gültig ist. Führen Sie den folgenden Befehl aus, um die AWS IoT Greengrass Kernprotokolldatei 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
```
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. Ändern Sie die lokale Komponente, um Ihren Code zu iterieren und zu testen. Öffnen Sie die Datei `hello_world.py` in einem Texteditor und fügen Sie in Zeile 4 den folgenden Code hinzu, um die Nachricht zu bearbeiten, die der AWS IoT Greengrass Kern protokolliert.
```
message += " Greetings from your first Greengrass component."
```
Das `hello_world.py` Skript sollte jetzt den folgenden Inhalt haben.
```
import sys
message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Führen Sie den folgenden Befehl aus, um die Komponente mit Ihren Änderungen zu aktualisieren.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Dieser Befehl aktualisiert die `com.example.HelloWorld` Komponente mit dem neuesten Hello World-Artefakt.
1. Führen Sie den folgenden Befehl aus, um die Komponente neu zu starten. Wenn Sie eine Komponente neu starten, verwendet das Kerngerät die neuesten Änderungen.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component restart \
--names "com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component restart ^
--names "com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component restart `
--names "com.example.HelloWorld"
```
------
1. Überprüfen Sie das Protokoll erneut, um sicherzustellen, dass die Hello World-Komponente die neue Nachricht druckt.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Der `type` Befehl schreibt den Inhalt der Datei in das Terminal. Führen Sie diesen Befehl mehrmals aus, um Änderungen in der Datei zu beobachten.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.
```
Hello, world! Greetings from your first Greengrass component.
```
1. Sie können die Konfigurationsparameter der Komponente aktualisieren, um verschiedene Konfigurationen zu testen. Wenn Sie eine Komponente bereitstellen, können Sie ein *Konfigurationsupdate* angeben, das definiert, wie die Konfiguration der Komponente auf dem Kerngerät geändert werden soll. Sie können angeben, welche Konfigurationswerte auf die Standardwerte zurückgesetzt werden sollen und welche neuen Konfigurationswerte auf dem Kerngerät zusammengeführt werden sollen. Weitere Informationen finden Sie unter [Komponentenkonfigurationen aktualisieren](update-component-configurations.md).
Gehen Sie wie folgt vor:
1. Verwenden Sie einen Texteditor, um eine Datei mit dem Namen `hello-world-config-update.json` zu erstellen, die das Konfigurationsupdate enthält
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano hello-world-config-update.json
```
1. Kopieren Sie das folgende JSON-Objekt und fügen Sie es in die Datei ein. Dieses JSON-Objekt definiert ein Konfigurationsupdate, das den Wert `friend` mit dem `Message` Parameter zusammenführt, um seinen Wert zu aktualisieren. Dieses Konfigurationsupdate spezifiziert keine Werte, die zurückgesetzt werden sollen. Sie müssen den `Message` Parameter nicht zurücksetzen, da das Merge-Update den vorhandenen Wert ersetzt.
```
{
"com.example.HelloWorld": {
"MERGE": {
"Message": "friend"
}
}
}
```
1. Führen Sie den folgenden Befehl aus, um das Konfigurationsupdate für die Hello World-Komponente bereitzustellen.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--merge "com.example.HelloWorld=1.0.0" \
--update-config hello-world-config-update.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--merge "com.example.HelloWorld=1.0.0" ^
--update-config hello-world-config-update.json
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--merge "com.example.HelloWorld=1.0.0" `
--update-config hello-world-config-update.json
```
------
1. Überprüfen Sie das Protokoll erneut, um sicherzustellen, dass die Hello World-Komponente die neue Nachricht ausgibt.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Der `type` Befehl schreibt den Inhalt der Datei in das Terminal. Führen Sie diesen Befehl mehrmals aus, um Änderungen in der Datei zu beobachten.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.
```
Hello, friend! Greetings from your first Greengrass component.
```
1. Wenn Sie mit dem Testen Ihrer Komponente fertig sind, entfernen Sie sie von Ihrem Kerngerät. Führen Sie den folgenden Befehl aus.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
**Wichtig**
Dieser Schritt ist erforderlich, damit Sie die Komponente nach dem Hochladen wieder auf dem Kerngerät bereitstellen können AWS IoT Greengrass. Andernfalls schlägt die Bereitstellung mit einem Versionskompatibilitätsfehler fehl, da bei der lokalen Bereitstellung eine andere Version der Komponente angegeben ist.
Führen Sie den folgenden Befehl aus und stellen Sie sicher, dass die `com.example.HelloWorld` Komponente nicht in der Liste der Komponenten auf Ihrem Gerät erscheint.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
Ihre Hello World-Komponente ist fertig und Sie können sie jetzt in den AWS IoT Greengrass Cloud-Dienst hochladen. Anschließend können Sie die Komponente auf Greengrass-Kerngeräten bereitstellen.
# Schritt 5: Erstellen Sie Ihre Komponente im AWS IoT Greengrass Service
Wenn Sie mit der Entwicklung einer Komponente auf Ihrem Kerngerät fertig sind, können Sie sie in den AWS IoT Greengrass Dienst hochladen AWS Cloud. Sie können die Komponente auch direkt in der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) erstellen. AWS IoT Greengrass bietet einen Komponentenverwaltungsdienst, der Ihre Komponenten hostet, sodass Sie sie auf einzelnen Geräten oder Geräteflotten bereitstellen können. Um eine Komponente in den AWS IoT Greengrass Dienst hochzuladen, führen Sie die folgenden Schritte aus:
+ Laden Sie Komponentenartefakte in einen S3-Bucket hoch.
+ Fügen Sie den Amazon Simple Storage Service (Amazon S3) -URI jedes Artefakts zum Komponentenrezept hinzu.
+ Erstellen Sie eine Komponente AWS IoT Greengrass aus dem Komponentenrezept.
In diesem Abschnitt führen Sie diese Schritte auf Ihrem Greengrass-Core-Gerät aus, um Ihre Hello World-Komponente in den AWS IoT Greengrass Dienst hochzuladen.
## Erstellen Sie Ihre Komponente in AWS IoT Greengrass (Konsole)
1. Verwenden Sie einen S3-Bucket in Ihrem AWS Konto, um AWS IoT Greengrass Komponentenartefakte zu hosten. Wenn Sie die Komponente auf einem Kerngerät bereitstellen, lädt das Gerät die Artefakte der Komponente aus dem Bucket herunter.
Sie können einen vorhandenen S3-Bucket verwenden oder einen neuen Bucket erstellen.
1. Wählen Sie in der [Amazon S3 S3-Konsole](https://console.aws.amazon.com/s3) unter **Buckets** die Option **Create Bucket** aus.
1. Geben Sie als **Bucket-Namen** einen eindeutigen Bucket-Namen ein. Sie können beispielsweise die Datei **greengrass-component-artifacts-*region*-*123456789012*** verwenden. *123456789012*Ersetzen Sie ihn durch Ihre AWS Konto-ID und *region* durch AWS-Region die, die Sie für dieses Tutorial verwenden.
1. Wählen Sie als **AWS Region** die AWS Region aus, die Sie für dieses Tutorial verwenden.
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Wählen Sie unter **Buckets** den Bucket aus, den Sie erstellt haben, und laden Sie das `hello_world.py` Skript in den `artifacts/com.example.HelloWorld/1.0.0` Ordner im Bucket hoch. Informationen zum Hochladen von Objekten in S3-Buckets finden Sie unter [Hochladen von Objekten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
1. Kopieren Sie die S3-URI des `hello_world.py` Objekts im S3-Bucket. Diese URI sollte dem folgenden Beispiel ähneln. Ersetzen Sie amzn-s3-demo-bucket durch den Namen des S3-Buckets.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
1. Erlauben Sie dem Core-Gerät den Zugriff auf Komponentenartefakte im S3-Bucket.
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.
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. 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. Ersetzen Sie amzn-s3-demo-bucket durch den Namen des S3-Buckets, der Komponentenartefakte für das Kerngerät zum Herunterladen enthält.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Wählen Sie **Weiter** aus.
1. **Geben Sie im Abschnitt **Richtliniendetails für Name den Text** ein.** **MyGreengrassV2ComponentArtifactPolicy**
1. Wählen Sie **Richtlinie erstellen** aus.
1. 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. Wählen Sie unter **Berechtigungen** die Option **Berechtigungen hinzufügen** und anschließend **Richtlinien anhängen** aus.
1. 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.
1. Verwenden Sie das Komponentenrezept, um eine Komponente in der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) zu erstellen.
1. Wählen Sie im Navigationsmenü der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) **Komponenten** und anschließend **Komponente erstellen** aus.
1. Wählen Sie unter **Komponenteninformationen** die Option **Rezept als JSON eingeben** aus. Das Platzhalterrezept sollte dem folgenden Beispiel ähneln.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
1. Ersetzen Sie die Platzhalter-URI in jedem `Artifacts` Abschnitt durch die S3-URI Ihres `hello_world.py` Objekts.
1. Wählen Sie **Komponente erstellen**.
1. Auf dem **com.example. HelloWorld**Überprüfen Sie auf der Komponentenseite, ob der **Status** der Komponente **Deployable** lautet.
## Erstellen Sie Ihre Komponente in AWS IoT Greengrass ()AWS CLI
**Um deine Hello World-Komponente hochzuladen**
1. Verwenden Sie einen S3-Bucket in Ihrem AWS-Konto , um AWS IoT Greengrass Komponentenartefakte zu hosten. Wenn Sie die Komponente auf einem Kerngerät bereitstellen, lädt das Gerät die Artefakte der Komponente aus dem Bucket herunter.
Sie können einen vorhandenen S3-Bucket verwenden oder den folgenden Befehl ausführen, um einen Bucket zu erstellen. Dieser Befehl erstellt einen Bucket mit Ihrer AWS-Konto ID und AWS-Region bildet einen eindeutigen Bucket-Namen. *123456789012*Ersetzen Sie es durch Ihre AWS-Konto ID und *region* durch AWS-Region die ID, die Sie für dieses Tutorial verwenden.
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
Der Befehl gibt die folgenden Informationen aus, wenn die Anfrage erfolgreich ist.
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
1. Erlauben Sie dem Core-Gerät den Zugriff auf Komponentenartefakte im S3-Bucket.
Jedes Kerngerät hat eine [IAM-Rolle für das Kerngerät](device-service-role.md), die es ermöglicht, mit dem zu interagieren AWS IoT und Protokolle an das 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.
Wenn die Rolle des Kerngerä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. Erstellen Sie eine Datei mit dem Namen `component-artifact-policy.json` und kopieren Sie den folgenden JSON-Code in die Datei. Diese Richtlinie ermöglicht den Zugriff auf alle Dateien in einem S3-Bucket. Ersetzen Sie amzn-s3-demo-bucket durch den Namen des S3-Buckets.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Führen Sie den folgenden Befehl aus, um die Richtlinie aus dem Richtliniendokument in zu erstellen. `component-artifact-policy.json`
------
#### [ Linux or Unix ]
```
aws iam create-policy \\
--policy-name MyGreengrassV2ComponentArtifactPolicy \\
--policy-document file://component-artifact-policy.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam create-policy ^
--policy-name MyGreengrassV2ComponentArtifactPolicy ^
--policy-document file://component-artifact-policy.json
```
------
#### [ PowerShell ]
```
aws iam create-policy `
--policy-name MyGreengrassV2ComponentArtifactPolicy `
--policy-document file://component-artifact-policy.json
```
------
Kopieren Sie den Amazon Resource Name (ARN) der Richtlinie aus den Richtlinienmetadaten in der Ausgabe. Sie verwenden diesen ARN, um diese Richtlinie im nächsten Schritt an die zentrale Geräterolle anzuhängen.
1. Führen Sie den folgenden Befehl aus, um die Richtlinie an die zentrale Geräterolle anzuhängen. *GreengrassV2TokenExchangeRole*Ersetzen Sie es durch den Namen der Rolle für das Kerngerät. Sie haben diesen Rollennamen bei der Installation der AWS IoT Greengrass Core-Software angegeben. Ersetzen Sie den Richtlinien-ARN durch den ARN aus dem vorherigen Schritt.
------
#### [ Linux or Unix ]
```
aws iam attach-role-policy \\
--role-name GreengrassV2TokenExchangeRole \\
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam attach-role-policy ^
--role-name GreengrassV2TokenExchangeRole ^
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ PowerShell ]
```
aws iam attach-role-policy `
--role-name GreengrassV2TokenExchangeRole `
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
Wenn der Befehl keine Ausgabe hat, war er erfolgreich. Das Core-Gerät kann jetzt auf Artefakte zugreifen, die Sie in diesen S3-Bucket hochladen.
1. Laden Sie das Python-Skript-Artefakt Hello World in den S3-Bucket hoch.
Führen Sie den folgenden Befehl aus, um das Skript in denselben Pfad im Bucket hochzuladen, in dem sich das Skript auf Ihrem AWS IoT Greengrass Core befindet. Ersetzen Sie amzn-s3-demo-bucket durch den Namen des S3-Buckets.
------
#### [ Linux or Unix ]
```
aws s3 cp \
artifacts/com.example.HelloWorld/1.0.0/hello_world.py \
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws s3 cp ^
artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ PowerShell ]
```
aws s3 cp `
artifacts/com.example.HelloWorld/1.0.0/hello_world.py `
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
Der Befehl gibt eine Zeile aus, die mit „Wenn die Anfrage erfolgreich ist“ beginnt. `upload:`
1. Fügen Sie den Amazon S3 S3-URI des Artefakts zum Komponentenrezept hinzu.
Die Amazon S3 S3-URI besteht aus dem Bucket-Namen und dem Pfad zum Artefaktobjekt im Bucket. Die Amazon S3 S3-URI Ihres Skript-Artefakts ist die URI, in die Sie das Artefakt im vorherigen Schritt hochgeladen haben. Diese URI sollte dem folgenden Beispiel ähneln. Ersetzen Sie amzn-s3-demo-bucket durch den Namen des S3-Buckets.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Um das Artefakt zum Rezept hinzuzufügen, fügen Sie eine Liste hinzu, `Artifacts` die eine Struktur mit dem Amazon S3 S3-URI enthält.
------
#### [ JSON ]
```
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
```
Öffnen Sie die Rezeptdatei in einem Texteditor.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
Fügen Sie das Artefakt dem Rezept hinzu. Ihre Rezeptdatei sollte dem folgenden Beispiel ähneln.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Öffnen Sie die Rezeptdatei in einem Texteditor.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
Fügen Sie das Artefakt dem Rezept hinzu. Ihre Rezeptdatei sollte dem folgenden Beispiel ähneln.
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
1. Erstellen Sie eine Komponentenressource AWS IoT Greengrass aus dem Rezept. Führen Sie den folgenden Befehl aus, um die Komponente aus dem Rezept zu erstellen, das Sie als Binärdatei bereitstellen.
------
#### [ JSON ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml
```
------
Die Antwort ähnelt dem folgenden Beispiel, wenn die Anfrage erfolgreich ist.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
Kopieren Sie das `arn` aus der Ausgabe, um im nächsten Schritt den Status der Komponente zu überprüfen.
**Anmerkung**
Sie können Ihre Hello World-Komponente auch in der [AWS IoT Greengrass Konsole](https://console.aws.amazon.com/greengrass) auf der **Komponentenseite** sehen.
1. Stellen Sie sicher, dass die Komponente erstellt wird und bereit ist, bereitgestellt zu werden. Wenn Sie eine Komponente erstellen, lautet ihr Status`REQUESTED`. AWS IoT Greengrass Überprüft dann, ob die Komponente bereitgestellt werden kann. Sie können den folgenden Befehl ausführen, um den Status der Komponente abzufragen und zu überprüfen, ob Ihre Komponente bereitgestellt werden kann. Ersetzen Sie das `arn` durch den ARN aus dem vorherigen Schritt.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0"
```
Wenn die Komponente validiert wird, gibt die Antwort an, dass der Status der Komponente lautet`DEPLOYABLE`.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-11-30T18:04:05.823Z",
"publisher": "Amazon",
"description": "My first Greengrass component.",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"os": "linux",
"architecture": "all"
}
]
}
```
Ihre Hello World-Komponente ist jetzt in AWS IoT Greengrass verfügbar. Sie können es wieder auf diesem Greengrass-Core-Gerät oder auf anderen Core-Geräten bereitstellen.
# Schritt 6: Stellen Sie Ihre Komponente bereit
Mit AWS IoT Greengrass können Sie Komponenten für einzelne Geräte oder Gerätegruppen bereitstellen. Wenn Sie eine Komponente bereitstellen, AWS IoT Greengrass wird die Software dieser Komponente auf jedem Zielgerät installiert und ausgeführt. Sie geben an, welche Komponenten bereitgestellt werden sollen und welches Konfigurationsupdate für jede Komponente bereitgestellt werden soll. Sie können auch steuern, wie die Bereitstellung auf die Geräte verteilt wird, auf die die Bereitstellung abzielt. Weitere Informationen finden Sie unter [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md).
In diesem Abschnitt stellen Sie Ihre Hello World-Komponente wieder auf Ihrem Greengrass-Core-Gerät bereit.
## Stellen Sie Ihre Komponente (Konsole) bereit
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** **auf der Registerkarte Meine Komponenten** **com.example.HelloWorld**.
1. Auf der **com.example.HelloWorld**Wählen Sie auf der Seite **Deploy** aus.
1. Wählen **Sie unter Zur Bereitstellung hinzufügen** die Option **Neue Bereitstellung erstellen** und dann **Weiter** aus.
1. Gehen Sie auf der Seite **Ziel angeben** wie folgt vor:
1. Geben Sie im Feld **Name (Name)** **Deployment for MyGreengrassCore** ein.
1. Wählen Sie als **Bereitstellungsziel** die Option **Kerngerät** und geben Sie den Namen der AWS IoT Sache für Ihr Kerngerät an. Der Standardwert in diesem Tutorial ist*MyGreengrassCore*.
1. Wählen Sie **Weiter**.
1. Vergewissern Sie sich auf der Seite **Komponenten auswählen** **unter Meine Komponenten**, dass **com.example.HelloWorld**Die Komponente ist ausgewählt, und klicken Sie auf **Weiter**.
1. Wählen Sie auf der Seite **Komponenten konfigurieren** **com.example.HelloWorld**, und gehen Sie wie folgt vor:
1. Wählen Sie **Komponente konfigurieren** aus.
1. Geben Sie unter **Konfigurationsupdate** unter **Zusammenzuführende Konfiguration** die folgende Konfiguration ein.
```
{
"Message": "universe"
}
```
Mit diesem Konfigurationsupdate wird der `Message` Parameter Hello World `universe` für das Gerät in dieser Bereitstellung auf festgelegt.
1. Wählen Sie **Bestätigen** aus.
1. Wählen Sie **Weiter**.
1. Behalten Sie auf der Seite **Erweiterte Einstellungen konfigurieren** die Standardkonfigurationseinstellungen bei und wählen Sie **Weiter**.
1. Wählen Sie auf der Seite **Review (Prüfen)** die Option **Deploy (Bereitstellen)** aus.
1. Stellen Sie sicher, dass die Bereitstellung erfolgreich abgeschlossen wurde. Es kann einige Minuten dauern, bis die Bereitstellung abgeschlossen ist. Überprüfen Sie das Hello World-Protokoll, um die Änderung zu überprüfen. Führen Sie den folgenden Befehl auf Ihrem Greengrass-Core-Gerät aus.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Anmerkung**
Wenn sich die Protokollmeldungen nicht ändern, ist die Bereitstellung fehlgeschlagen oder hat das Kerngerät nicht erreicht. Dies kann der Fall sein, wenn Ihr Kerngerät nicht mit dem Internet verbunden ist oder nicht berechtigt ist, Artefakte aus Ihrem S3-Bucket abzurufen. Führen Sie den folgenden Befehl auf Ihrem Core-Gerät aus, um die AWS IoT Greengrass Core-Software-Protokolldatei 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
```
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
```
Weitere Informationen finden Sie unter [Problembehebung AWS IoT Greengrass V2](troubleshooting.md).
## Stellen Sie Ihre Komponente (AWS CLI) bereit
**Um Ihre Hello World-Komponente bereitzustellen**
1. Erstellen Sie auf Ihrem Entwicklungscomputer eine Datei mit dem Namen `hello-world-deployment.json` und kopieren Sie den folgenden JSON-Code in die Datei. Diese Datei definiert die Komponenten und Konfigurationen, die bereitgestellt werden sollen.
```
{
"components": {
"com.example.HelloWorld": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"Message\":\"universe\"}"
}
}
}
}
```
Diese Konfigurationsdatei gibt an, dass die Version `1.0.0` der Hello World-Komponente bereitgestellt werden soll, die Sie im vorherigen Verfahren entwickelt und veröffentlicht haben. Die `configurationUpdate` gibt an, dass die Komponentenkonfiguration in einer JSON-codierten Zeichenfolge zusammengeführt werden soll. Dieses Konfigurationsupdate legt den Hello `Message` World-Parameter `universe` für das Gerät in dieser Bereitstellung auf fest.
1. Führen Sie den folgenden Befehl aus, um die Komponente auf Ihrem Greengrass-Core-Gerät bereitzustellen. Sie können die Bereitstellung auf Geräten durchführen, bei denen es sich um einzelne Geräte handelt, oder auf Dinggruppen, bei denen es sich um Gruppen von Geräten handelt. *MyGreengrassCore*Ersetzen Sie es durch den Namen der AWS IoT Sache für Ihr Kerngerät.
------
#### [ Linux or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--cli-input-json file://hello-world-deployment.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--cli-input-json file://hello-world-deployment.json
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--cli-input-json file://hello-world-deployment.json
```
------
Der Befehl gibt eine Antwort aus, die dem folgenden Beispiel ähnelt.
```
{
"deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9",
"iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75",
"iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75"
}
```
1. Stellen Sie sicher, dass die Bereitstellung erfolgreich abgeschlossen wurde. Es kann einige Minuten dauern, bis die Bereitstellung abgeschlossen ist. Überprüfen Sie das Hello World-Protokoll, um die Änderung zu überprüfen. Führen Sie den folgenden Befehl auf Ihrem Greengrass-Core-Gerät aus.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Sie sollten Meldungen sehen, die dem folgenden Beispiel ähneln.
```
Hello, universe! Greetings from your first Greengrass component.
```
**Anmerkung**
Wenn sich die Protokollmeldungen nicht ändern, ist die Bereitstellung fehlgeschlagen oder hat das Kerngerät nicht erreicht. Dies kann der Fall sein, wenn Ihr Kerngerät nicht mit dem Internet verbunden ist oder nicht berechtigt ist, Artefakte aus Ihrem S3-Bucket abzurufen. Führen Sie den folgenden Befehl auf Ihrem Core-Gerät aus, um die AWS IoT Greengrass Core-Software-Protokolldatei 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
```
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
```
Weitere Informationen finden Sie unter [Problembehebung AWS IoT Greengrass V2](troubleshooting.md).
# Nächste Schritte
Sie haben dieses Tutorial abgeschlossen. Die AWS IoT Greengrass Core-Software und Ihre Hello World-Komponente laufen auf Ihrem Gerät. Außerdem ist Ihre Hello World-Komponente im AWS IoT Greengrass Cloud-Dienst verfügbar, um sie auf anderen Geräten bereitzustellen. Weitere Informationen zu den Themen, die in diesem Tutorial behandelt werden, finden Sie im Folgenden:
+ [AWS IoT Greengrass Komponenten erstellen](create-components.md)
+ [Veröffentlichen Sie Komponenten zur Bereitstellung auf Ihren Kerngeräten](publish-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)