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.
# Einrichtung von AWS IoT Greengrass Kerngeräten
Führen Sie die Aufgaben in diesem Abschnitt aus, um die AWS IoT Greengrass Core-Software zu installieren, zu konfigurieren und auszuführen.
**Anmerkung**
In diesem Abschnitt wird die erweiterte Installation und Konfiguration der AWS IoT Greengrass Core-Software beschrieben. Diese Schritte gelten nicht für Nucleus Lite. Wenn Sie Nucleus Lite zum ersten Mal verwenden AWS IoT Greengrass V2, empfehlen wir Ihnen, zuerst das [Tutorial „Erste Schritte](getting-started.md)“ zu absolvieren, um ein Kerngerät einzurichten und die Funktionen von zu erkunden. AWS IoT Greengrass
**Topics**
+ [Unterstützte Plattformen](#supported-platforms)
+ [Anforderungen an Speichergeräte](#device-requirements)
+ [Anforderungen an die Lambda-Funktion](#greengrass-v2-lambda-requirements)
+ [Richten Sie eine ein AWS-Konto](#set-up-aws-account)
+ [Installieren Sie die AWS IoT Greengrass Core-Software](install-greengrass-core-v2.md)
+ [Führen Sie die AWS IoT Greengrass Core-Software aus](run-greengrass-core-v2.md)
+ [Führen Sie die AWS IoT Greengrass Core-Software in einem Docker-Container aus](run-greengrass-docker.md)
+ [Konfiguration der AWS IoT Greengrass Core-Software](configure-greengrass-core-v2.md)
+ [Aktualisieren Sie die AWS IoT Greengrass Core-Software (OTA)](update-greengrass-core-v2.md)
+ [Deinstallieren Sie die AWS IoT Greengrass Core-Software](uninstall-greengrass-core-v2.md)
## Unterstützte Plattformen
+ [Von Greengrass Nucleus unterstützte Plattformen](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Von Greengrass Nucleus Lite unterstützte Plattformen](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Anforderungen an Speichergeräte
+ [Anforderungen an das Greengrass Nucleus-Gerät](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Anforderungen an das Greengrass Nucleus Lite-Gerät](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Anforderungen an die Lambda-Funktion
**Wichtig**
Greengrass Lambda-Funktionen werden derzeit von Greengrass Nucleus Lite nicht unterstützt.
Ihr Gerät muss die folgenden Anforderungen erfüllen, um Lambda-Funktionen ausführen zu können:
+ Ein Linux-basiertes Betriebssystem.
+ Ihr Gerät muss über den `mkfifo` Shell-Befehl verfügen.
+ Ihr Gerät muss die Programmiersprachenbibliotheken ausführen, die für eine Lambda-Funktion erforderlich sind. Sie müssen die erforderlichen Bibliotheken auf dem Gerät installieren und sie der `PATH` Umgebungsvariablen hinzufügen. Greengrass unterstützt alle von Lambda unterstützten Versionen von Python-, Node.js- und Java-Runtimes. Greengrass wendet keine zusätzlichen Einschränkungen auf veraltete Lambda-Laufzeitversionen an. Weitere Informationen zur AWS IoT Greengrass Unterstützung von Lambda-Laufzeiten finden Sie unter. [AWS Lambda Funktionen ausführen](run-lambda-functions.md)
+ Um containerisierte Lambda-Funktionen ausführen zu können, muss Ihr Gerät die folgenden Anforderungen erfüllen:
+ Linux-Kernel-Version 4.4 oder höher.
+ Der Kernel muss [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 unterstützen, und Sie müssen die folgenden Cgroups aktivieren und mounten:
+ Die *Speicher-Cgroup* für AWS IoT Greengrass die Festlegung der Speicherbegrenzung für containerisierte Lambda-Funktionen.
+ Die *Gerätegruppe* für containerisierte Lambda-Funktionen für den Zugriff auf Systemgeräte oder Volumes.
Die AWS IoT Greengrass Core-Software unterstützt cgroups v2 nicht.
Um diese Anforderung zu erfüllen, starten Sie das Gerät mit den folgenden Linux-Kernelparametern.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**Tipp**
Bearbeiten Sie auf einem Raspberry Pi die `/boot/cmdline.txt` Datei, um die Kernel-Parameter des Geräts festzulegen.
+ Sie müssen die folgenden Linux-Kernelkonfigurationen auf dem Gerät aktivieren:
+ Namespace
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Cgroups:
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ Weitere:
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**Tipp**
In der Dokumentation zu Ihrer Linux-Distribution erfahren Sie, wie Sie die Linux-Kernelparameter überprüfen und festlegen. Sie können auch AWS IoT Device Tester für verwenden AWS IoT Greengrass , um zu überprüfen, ob Ihr Gerät diese Anforderungen erfüllt. Weitere Informationen finden Sie unter [AWS IoT Device Tester Für AWS IoT Greengrass V2 verwenden](device-tester-for-greengrass-ug.md).
## Richten Sie eine 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).
Wählen Sie zum Erstellen eines Administratorbenutzers eine der folgenden Optionen aus.
****
| Wählen Sie eine Möglichkeit zur Verwaltung Ihres Administrators aus. | Bis | Von | Sie können auch |
| --- | --- | --- | --- |
| Im IAM Identity Center (Empfohlen) | Verwendung von kurzfristigen Anmeldeinformationen für den Zugriff auf AWS.Dies steht im Einklang mit den bewährten Methoden für die Sicherheit. Weitere Informationen zu bewährten Methoden finden Sie unter [Bewährte Methoden für die Sicherheit in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) im *IAM-Benutzerhandbuch*. | Beachtung der Anweisungen unter [Erste Schritte](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html) im AWS IAM Identity Center -Benutzerhandbuch. | Konfigurieren Sie den programmatischen Zugriff, indem [Sie AWS CLI die Konfiguration für die Verwendung AWS IAM Identity Center](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html) im AWS Command Line Interface Benutzerhandbuch vornehmen. |
| In IAM (Nicht empfohlen) | Verwendung von langfristigen Anmeldeinformationen für den Zugriff auf AWS. | Folgen Sie den Anleitungen unter [IAM-Benutzer für den Notfallzugriff erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html) im IAM-Benutzerhandbuch. | Sie konfigurieren den programmgesteuerten Zugriff unter Verwendung der Informationen unter [Verwalten der Zugriffsschlüssel für IAM-Benutzer](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html) im IAM-Benutzerhandbuch. |
# Installieren Sie die AWS IoT Greengrass Core-Software
AWS IoT Greengrass erstreckt sich AWS auf Edge-Geräte, sodass diese auf die von ihnen generierten Daten reagieren können, während sie sie gleichzeitig AWS Cloud für Verwaltung, Analyse und dauerhaften Speicher verwenden. Installieren Sie die AWS IoT Greengrass Core-Software auf Edge-Geräten, um sie zu integrieren AWS IoT Greengrass und die AWS Cloud.
**Wichtig**
Bevor Sie die AWS IoT Greengrass Core-Software herunterladen und installieren, überprüfen Sie, ob Ihr Core-Gerät die [Anforderungen](greengrass-nucleus-component.md#greengrass-v2-requirements) für die Installation und Ausführung der AWS IoT Greengrass Core-Software v2.0 erfüllt.
Die AWS IoT Greengrass Core-Software enthält ein Installationsprogramm, das Ihr Gerät als Greengrass-Core-Gerät einrichtet. Wenn Sie das Installationsprogramm ausführen, können Sie Optionen wie den Stammordner und den AWS-Region zu verwendenden Ordner konfigurieren. Sie können wählen, ob das Installationsprogramm die erforderlichen AWS IoT und IAM-Ressourcen für Sie erstellt. Sie können sich auch dafür entscheiden, lokale Entwicklungstools bereitzustellen, um ein Gerät zu konfigurieren, das Sie für die Entwicklung benutzerdefinierter Komponenten verwenden.
Für die Verbindung AWS IoT und den Betrieb der AWS IoT Greengrass Core-Software sind die AWS Cloud folgenden IAM-Ressourcen erforderlich:
+ Irgendein AWS IoT Ding. Wenn Sie ein Gerät als Objekt AWS IoT registrieren, kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS Dieses Zertifikat ermöglicht dem Gerät die Kommunikation mit AWS IoT und AWS IoT Greengrass. Weitere Informationen finden Sie unter [Geräteauthentifizierung und Autorisierung für AWS IoT Greengrass](device-auth.md).
+ (Optional) Eine AWS IoT Dinggruppe. Sie verwenden Dinggruppen, um Flotten von Greengrass-Kerngeräten zu 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. Sie können einer Dinggruppe ein Gerät hinzufügen, um die Softwarekomponenten dieser Dinggruppe auf dem Gerät bereitzustellen. Weitere Informationen finden Sie unter [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md).
+ Eine IAM-Rolle. Greengrass-Core-Geräte verwenden den AWS IoT Core Credentials Provider, um Aufrufe von AWS Diensten mit einer IAM-Rolle zu autorisieren. Diese Rolle ermöglicht es Ihrem Gerät AWS IoT, mit Amazon Simple Storage Service (Amazon S3) zu interagieren, CloudWatch Protokolle an Amazon Logs zu senden und benutzerdefinierte Komponentenartefakte herunterzuladen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
+ Ein AWS IoT Rollenalias. Greengrass-Core-Geräte verwenden den Rollenalias, um die zu verwendende IAM-Rolle zu identifizieren. Mit dem Rollenalias können Sie die IAM-Rolle ändern, aber die Gerätekonfiguration beibehalten. Weitere Informationen finden Sie im [*AWS IoT Core Entwicklerhandbuch* unter Autorisieren von direkten Aufrufen von AWS Diensten](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html).
Wählen Sie eine der folgenden Optionen, um die AWS IoT Greengrass Core-Software auf Ihrem Core-Gerät zu installieren.
+ **Schnelle Installation**
Wählen Sie diese Option, um ein Greengrass Core-Gerät in so wenigen Schritten wie möglich einzurichten. Das Installationsprogramm erstellt die erforderlichen AWS IoT und IAM-Ressourcen für Sie. Für diese Option müssen Sie AWS Anmeldeinformationen für das Installationsprogramm angeben, um Ressourcen in Ihrem AWS-Konto zu erstellen.
Sie können diese Option nicht verwenden, um hinter einer Firewall oder einem Netzwerk-Proxy zu installieren. Wenn sich Ihre Geräte hinter einer Firewall oder einem Netzwerk-Proxy befinden, sollten Sie eine [manuelle Installation](manual-installation.md) in Betracht ziehen.
Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit automatischer Ressourcenbereitstellung](quick-installation.md).
+ **Manuelle Installation**
Wählen Sie diese Option, um die erforderlichen AWS Ressourcen manuell zu erstellen oder um sie hinter einer Firewall oder einem Netzwerk-Proxy zu installieren. Wenn Sie eine manuelle Installation verwenden, müssen Sie dem Installateur nicht die Erlaubnis geben, Ressourcen in Ihrem zu erstellen AWS-Konto, da Sie die erforderlichen Ressourcen AWS IoT und IAM-Ressourcen selbst erstellen. Sie können Ihr Gerät auch so konfigurieren, dass es eine Verbindung über Port 443 oder über einen Netzwerk-Proxy herstellt. Sie können die AWS IoT Greengrass Core-Software auch so konfigurieren, dass sie einen privaten Schlüssel und ein Zertifikat verwendet, die Sie in einem Hardware-Sicherheitsmodul (HSM), einem Trusted Platform Module (TPM) oder einem anderen kryptografischen Element speichern.
Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit manueller Ressourcenbereitstellung](manual-installation.md).
+ **Installation mit Flottenbereitstellung AWS IoT **
Wählen Sie diese Option, um die erforderlichen AWS Ressourcen anhand einer AWS IoT Flottenbereitstellungsvorlage zu erstellen. Sie können diese Option wählen, um ähnliche Geräte in einer Flotte zu erstellen, oder wenn Sie Geräte herstellen, die Ihre Kunden später aktivieren, z. B. Fahrzeuge oder Smart-Home-Geräte. Geräte verwenden Anspruchszertifikate, um AWS Ressourcen zu authentifizieren und bereitzustellen, einschließlich eines X.509-Client-Zertifikats, mit dem das Gerät AWS Cloud für den normalen Betrieb eine Verbindung mit dem herstellt. Sie können die Antragszertifikate während der Herstellung in die Hardware des Geräts einbetten oder flashen, und Sie können dasselbe Anspruchszertifikat und denselben Schlüssel verwenden, um mehrere Geräte bereitzustellen. Sie können Geräte auch so konfigurieren, dass sie eine Verbindung über Port 443 oder über einen Netzwerk-Proxy herstellen.
Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit AWS IoT Flottenbereitstellung](fleet-provisioning.md).
+ **Installation mit benutzerdefinierter Bereitstellung**
Wählen Sie diese Option, um eine benutzerdefinierte Java-Anwendung zu entwickeln, die die erforderlichen AWS Ressourcen bereitstellt. Sie können diese Option wählen, wenn Sie [Ihre eigenen X.509-Clientzertifikate erstellen](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) oder wenn Sie mehr Kontrolle über den Bereitstellungsprozess wünschen. AWS IoT Greengrass bietet eine Schnittstelle, die Sie für den Informationsaustausch zwischen Ihrer benutzerdefinierten Bereitstellungsanwendung und dem AWS IoT Greengrass Core-Softwareinstaller implementieren können.
Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit benutzerdefinierter Ressourcenbereitstellung](custom-provisioning.md).
AWS IoT Greengrass stellt auch containerisierte Umgebungen bereit, in denen die Core-Software ausgeführt wird. AWS IoT Greengrass Sie können ein Dockerfile verwenden, um es [AWS IoT Greengrass in einem Docker-Container auszuführen](run-greengrass-docker.md).
**Topics**
+ [Installieren Sie mit automatischer Bereitstellung](quick-installation.md)
+ [Installieren Sie mit manueller Bereitstellung](manual-installation.md)
+ [Installation mit Flottenbereitstellung](fleet-provisioning.md)
+ [Installieren Sie mit benutzerdefinierter Bereitstellung](custom-provisioning.md)
+ [Argumente des Installers](configure-installer.md)
# Installieren Sie die AWS IoT Greengrass Core-Software mit automatischer Ressourcenbereitstellung
Die AWS IoT Greengrass Core-Software enthält ein Installationsprogramm, das Ihr Gerät als Greengrass-Core-Gerät einrichtet. Um ein Gerät schnell einzurichten, kann das Installationsprogramm das AWS IoT AWS IoT Ding, die Dinggruppe, die AWS IoT IAM-Rolle und den Rollenalias bereitstellen, die das Kerngerät für den Betrieb benötigt. Das Installationsprogramm kann auch die lokalen Entwicklungstools auf dem Kerngerät bereitstellen, sodass Sie das Gerät verwenden können, um benutzerdefinierte Softwarekomponenten zu entwickeln und zu testen. Das Installationsprogramm benötigt AWS Anmeldeinformationen, um diese Ressourcen bereitzustellen und die Bereitstellung zu erstellen.
Wenn Sie keine AWS Anmeldeinformationen für das Gerät angeben können, können Sie die AWS Ressourcen bereitstellen, die das Kerngerät für den Betrieb benötigt. Sie können die Entwicklungstools auch auf einem Kerngerät bereitstellen, um es als Entwicklungsgerät zu verwenden. Auf diese Weise können Sie dem Gerät weniger Berechtigungen zuweisen, wenn Sie das Installationsprogramm ausführen. Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit manueller Ressourcenbereitstellung](manual-installation.md).
**Wichtig**
Bevor Sie die AWS IoT Greengrass Core-Software herunterladen, überprüfen Sie, ob Ihr Kerngerät die [Anforderungen](greengrass-nucleus-component.md#greengrass-v2-requirements) für die Installation und Ausführung der AWS IoT Greengrass Core-Software v2.0 erfüllt.
**Topics**
+ [Richten Sie die Geräteumgebung ein](#set-up-device-environment)
+ [Geben Sie AWS Anmeldeinformationen für das Gerät ein](#provide-installer-aws-credentials)
+ [Laden Sie die AWS IoT Greengrass Core-Software herunter](#download-greengrass-core-v2)
+ [Installieren Sie die Core-Software AWS IoT Greengrass](#run-greengrass-core-v2-installer)
## Richten Sie die Geräteumgebung ein
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 ein
**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 (in der Regel`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
**Anmerkung**
Diese Funktion ist für Version 2.5.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
**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
## Geben Sie AWS Anmeldeinformationen für das Gerät ein
Geben Sie Ihre AWS Anmeldeinformationen für Ihr Gerät ein, damit das Installationsprogramm die erforderlichen AWS Ressourcen bereitstellen kann. Weitere Informationen zu den erforderlichen Berechtigungen finden Sie unter [Minimale IAM-Richtlinie für das Installationsprogramm zur Bereitstellung von Ressourcen](provision-minimal-iam-policy.md).
**Um AWS Anmeldeinformationen für das Gerät bereitzustellen**
+ 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 Sicherheitsanmeldedaten 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).
## Laden Sie die AWS IoT Greengrass Core-Software herunter
Sie können die neueste Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Anmerkung**
Sie können eine bestimmte Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen. Ersetzen Sie es *version* durch die Version, die Sie herunterladen möchten.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Um die AWS IoT Greengrass Core-Software herunterzuladen**
1. Laden Sie die Core-Software auf Ihrem AWS IoT Greengrass Core-Gerät in eine Datei mit dem Namen herunter`greengrass-nucleus-latest.zip`.
------
#### [ 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. (Optional) Um die Greengrass Nucleus-Softwaresignatur zu überprüfen
**Anmerkung**
Diese Funktion ist mit Greengrass Nucleus Version 2.9.5 und höher verfügbar.
1. Verwenden Sie den folgenden Befehl, um die Signatur Ihres Greengrass-Kernartefakts zu überprüfen:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Der Dateiname kann je nach installierter JDK-Version anders aussehen. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Der Dateiname sieht je nach installierter JDK-Version möglicherweise anders aus. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. Der `jarsigner` Aufruf liefert eine Ausgabe, die die Ergebnisse der Überprüfung angibt.
1. Wenn die Greengrass Nucleus-Zip-Datei signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar verified.
```
1. Wenn die Greengrass Nucleus-Zip-Datei nicht signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar is unsigned.
```
1. Wenn Sie die `-certs` Option Jarsigner zusammen mit den `-verbose` Optionen `-verify` und angegeben haben, enthält die Ausgabe auch detaillierte Informationen zum Unterzeichnerzertifikat.
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. (Optional) Führen Sie den folgenden Befehl aus, um die Version der AWS IoT Greengrass Core-Software zu sehen.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Wichtig**
Wenn Sie eine Version von Greengrass Nucleus vor v2.4.0 installieren, entfernen Sie diesen Ordner nicht, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben. Die AWS IoT Greengrass Core-Software verwendet die Dateien in diesem Ordner zur Ausführung.
Wenn Sie die neueste Version der Software heruntergeladen haben, installieren Sie v2.4.0 oder höher, und Sie können diesen Ordner nach der Installation der AWS IoT Greengrass Core-Software entfernen.
## Installieren Sie die Core-Software AWS IoT Greengrass
Führen Sie das Installationsprogramm mit Argumenten aus, die Folgendes angeben:
+ Erstellen Sie die AWS Ressourcen, die das Kerngerät für den Betrieb benötigt.
+ Geben Sie an, dass der `ggc_user` Systembenutzer Softwarekomponenten auf dem Kerngerät ausführen 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.
+ 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.
Um ein Entwicklungsgerät mit lokalen Entwicklungstools einzurichten, geben Sie das `--deploy-dev-tools true` Argument an. Die Bereitstellung der lokalen Entwicklungstools kann nach Abschluss der Installation bis zu einer Minute dauern.
Weitere Hinweise zu den Argumenten, die Sie angeben können, finden Sie unter[Argumente des Installers](configure-installer.md).
**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).
**Um die Core-Software zu installieren AWS IoT Greengrass**
1. Führen Sie das AWS IoT Greengrass Core-Installationsprogramm aus. Ersetzen Sie die Argumentwerte in Ihrem Befehl wie folgt.
**Anmerkung**
Windows hat eine Pfadlängenbegrenzung von 260 Zeichen. Wenn Sie Windows verwenden, verwenden Sie einen Stammordner wie `C:\greengrass\v2` oder, `D:\greengrass\v2` um die Greengrass-Komponentenpfade unter der Obergrenze von 260 Zeichen zu halten.
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 sie das Installationsprogramm 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
```
------
#### [ 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
```
------
#### [ 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
```
------
**Wichtig**
Auf Windows Core-Geräten müssen Sie angeben, `--setup-system-service true` dass die AWS IoT Greengrass Core-Software als Systemdienst eingerichtet werden soll.
Das Installationsprogramm gibt die folgenden Meldungen aus, wenn es erfolgreich ist:
+ Wenn Sie angeben`--provision`, druckt das Installationsprogramm, `Successfully configured Nucleus with provisioned resource details` ob es die Ressourcen erfolgreich konfiguriert hat.
+ Wenn Sie dies angeben`--deploy-dev-tools`, druckt das Installationsprogramm, `Configured Nucleus to deploy aws.greengrass.Cli component` ob es die Einrichtung erfolgreich erstellt hat.
+ Wenn Sie dies angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Successfully set up Nucleus as a system service` ob es die Software als Dienst eingerichtet und ausgeführt hat.
+ Wenn Sie nichts angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Launched Nucleus successfully` ob es erfolgreich war und die Software ausgeführt hat.
1. Überspringen Sie diesen Schritt, wenn Sie [Grüngraskern](greengrass-nucleus-component.md) v2.0.4 oder höher installiert haben. Wenn Sie die neueste Version der Software heruntergeladen haben, haben Sie v2.0.4 oder höher installiert.
Führen Sie den folgenden Befehl aus, um die erforderlichen Dateiberechtigungen für Ihren AWS IoT Greengrass Core-Software-Stammordner festzulegen. `/greengrass/v2`Ersetzen Sie es durch den Stammordner, den Sie in Ihrem Installationsbefehl angegeben haben, und */greengrass* durch den übergeordneten Ordner für Ihren Stammordner.
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
Wenn Sie die AWS IoT Greengrass Core-Software als Systemdienst installiert haben, führt das Installationsprogramm die Software für Sie aus. Andernfalls müssen Sie die Software manuell ausführen. Weitere Informationen finden Sie unter [Führen Sie die AWS IoT Greengrass Core-Software aus](run-greengrass-core-v2.md).
**Anmerkung**
Standardmäßig erlaubt die IAM-Rolle, die das Installationsprogramm erstellt, keinen Zugriff auf Komponentenartefakte in S3-Buckets. Um benutzerdefinierte Komponenten bereitzustellen, die Artefakte in Amazon S3 definieren, müssen Sie der Rolle Berechtigungen hinzufügen, damit Ihr Kerngerät Komponentenartefakte abrufen kann. Weitere Informationen finden Sie unter [Erlauben Sie den Zugriff auf S3-Buckets für Komponentenartefakte](device-service-role.md#device-service-role-access-s3-bucket).
Wenn Sie noch keinen S3-Bucket für Komponentenartefakte haben, können Sie diese Berechtigungen später hinzufügen, nachdem Sie einen Bucket erstellt haben.
**Anmerkung**
Wenn die AWS IoT Greengrass Core-Software eine Verbindung zur Cloud herstellt, wird Ihr Gerät als Core-Gerät erkannt.
Weitere Informationen zur Konfiguration und Verwendung der Software finden Sie unter: AWS IoT Greengrass
+ [Konfiguration der AWS IoT Greengrass Core-Software](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)
+ [Greengrass-Befehlszeilenschnittstelle](gg-cli.md)
# Installieren Sie die AWS IoT Greengrass Core-Software mit manueller Ressourcenbereitstellung
Die AWS IoT Greengrass Core-Software enthält ein Installationsprogramm, das Ihr Gerät als Greengrass-Core-Gerät einrichtet. Um ein Gerät manuell einzurichten, können Sie die erforderlichen AWS IoT und IAM-Ressourcen für das Gerät erstellen. Wenn Sie diese Ressourcen manuell erstellen, müssen Sie keine AWS Anmeldeinformationen für das Installationsprogramm angeben.
Wenn Sie die AWS IoT Greengrass Core-Software manuell installieren, können Sie das Gerät auch so konfigurieren, dass es einen Netzwerk-Proxy verwendet oder eine Verbindung AWS über Port 443 herstellt. Möglicherweise müssen Sie diese Konfigurationsoptionen angeben, wenn Ihr Gerät beispielsweise hinter einer Firewall oder einem Netzwerk-Proxy läuft. Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](configure-greengrass-core-v2.md#configure-alpn-network-proxy).
Sie können die AWS IoT Greengrass Core-Software auch so konfigurieren, dass sie ein Hardware-Sicherheitsmodul (HSM) über die [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11) -Schnittstelle verwendet. Mit dieser Funktion können Sie private Schlüssel- und Zertifikatsdateien sicher speichern, sodass sie nicht offengelegt oder in der Software dupliziert werden. Sie können private Schlüssel und Zertifikate auf einem Hardwaremodul wie einem HSM, einem Trusted Platform Module (TPM) oder einem anderen kryptografischen Element speichern. Diese Funktion ist nur auf Linux-Geräten verfügbar. Weitere Informationen zur Hardwaresicherheit und zu den Voraussetzungen für ihre Verwendung finden Sie unter[Integration von Hardware-Sicherheit](hardware-security.md).
**Wichtig**
Bevor Sie die AWS IoT Greengrass Core-Software herunterladen, überprüfen Sie, ob Ihr Core-Gerät die [Anforderungen](greengrass-nucleus-component.md#greengrass-v2-requirements) für die Installation und Ausführung der AWS IoT Greengrass Core-Software v2.0 erfüllt.
**Topics**
+ [Endpunkte abrufen AWS IoT](#retrieve-iot-endpoints)
+ [Erstelle ein Ding AWS IoT](#create-iot-thing)
+ [Erstellen Sie das Ding-Zertifikat](#create-thing-certificate)
+ [Konfigurieren Sie das Ding-Zertifikat](#configure-thing-certificate)
+ [Erstellen Sie eine Token-Exchange-Rolle](#create-token-exchange-role)
+ [Laden Sie Zertifikate auf das Gerät herunter](#download-thing-certificates)
+ [Richten Sie die Geräteumgebung ein](#set-up-device-environment)
+ [Laden Sie die AWS IoT Greengrass Core-Software herunter](#download-greengrass-core-v2)
+ [Installieren Sie die Core-Software AWS IoT Greengrass](#run-greengrass-core-v2-installer-manual)
## Endpunkte abrufen AWS IoT
Holen Sie sich die AWS IoT Endpunkte für Sie und speichern Sie sie AWS-Konto, um sie später zu verwenden. Ihr Gerät verwendet diese Endpunkte, um eine Verbindung herzustellen. AWS IoT Gehen Sie wie folgt vor:
1. Holen Sie sich den AWS IoT Datenendpunkt für Ihren AWS-Konto.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Rufen Sie den Endpunkt der AWS IoT Anmeldeinformationen für Ihren AWS-Konto ab.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Erstelle ein Ding AWS IoT
AWS IoT *Dinge* stehen für Geräte und logische Entitäten, mit denen eine Verbindung hergestellt wird AWS IoT. Greengrass-Core-Geräte sind AWS IoT Dinge. Wenn Sie ein Gerät als Objekt registrieren AWS IoT , kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS
In diesem Abschnitt erstellen Sie eine AWS IoT Sache, die Ihr Gerät repräsentiert.
**Um ein AWS IoT Ding zu erstellen**
1. Erstelle AWS IoT etwas für dein Gerät. Führen Sie auf Ihrem Entwicklungscomputer den folgenden Befehl aus.
+ *MyGreengrassCore*Ersetzen Sie es durch den Namen des zu verwendenden Dings. Dieser Name ist auch der Name Ihres Greengrass-Core-Geräts.
**Anmerkung**
Der Name der Sache darf keine Doppelpunkte (`:`) enthalten.
```
aws iot create-thing --thing-name MyGreengrassCore
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Optional) Fügen Sie das AWS IoT Ding einer neuen oder vorhandenen Dinggruppe hinzu. Sie verwenden Dinggruppen, um Flotten von Greengrass-Kerngeräten zu verwalten. Wenn Sie Softwarekomponenten auf Ihren Geräten bereitstellen, können Sie einzelne Geräte oder Gerätegruppen gezielt ansprechen. Sie können ein Gerät zu einer Dinggruppe mit einer aktiven Greengrass-Bereitstellung hinzufügen, um die Softwarekomponenten dieser Dinggruppe auf dem Gerät bereitzustellen. Gehen Sie wie folgt vor:
1. (Optional) Erstellen Sie eine AWS IoT Dinggruppe.
+ *MyGreengrassCoreGroup*Ersetzen Sie durch den Namen der zu erstellenden Dinggruppe.
**Anmerkung**
Der Name der Dinggruppe darf keine Doppelpunkte (`:`) enthalten.
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Fügt das AWS IoT Ding einer Dinggruppe hinzu.
+ Ersetze es *MyGreengrassCore* durch den Namen deines AWS IoT Dings.
+ Ersetze es *MyGreengrassCoreGroup* durch den Namen der Dinggruppe.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
## Erstellen Sie das Ding-Zertifikat
Wenn Sie ein Gerät als AWS IoT Ding registrieren, kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS Dieses Zertifikat ermöglicht dem Gerät die Kommunikation mit AWS IoT und AWS IoT Greengrass.
In diesem Abschnitt erstellen und laden Sie Zertifikate herunter, mit denen Ihr Gerät eine Verbindung herstellen kann AWS.
Wenn Sie die AWS IoT Greengrass Core-Software so konfigurieren möchten, dass sie ein Hardware-Sicherheitsmodul (HSM) verwendet, um den privaten Schlüssel und das Zertifikat sicher zu speichern, gehen Sie wie folgt vor, um das Zertifikat aus einem privaten Schlüssel in einem HSM zu erstellen. Folgen Sie andernfalls den Schritten zum Erstellen des Zertifikats und des privaten Schlüssels im AWS IoT Dienst. Die Hardware-Sicherheitsfunktion ist nur auf Linux-Geräten verfügbar. Weitere Informationen zur Hardwaresicherheit und zu den Voraussetzungen für ihre Verwendung finden Sie unter[Integration von Hardware-Sicherheit](hardware-security.md).
### Erstellen Sie das Zertifikat und den privaten Schlüssel im AWS IoT Dienst
**Um das Ding-Zertifikat zu erstellen**
1. Erstellen Sie einen Ordner, in den Sie die Zertifikate für das AWS IoT Ding herunterladen.
```
mkdir greengrass-v2-certs
```
1. Erstellen Sie die Zertifikate für das AWS IoT Ding und laden Sie sie herunter.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Speichern Sie den Amazon-Ressourcennamen (ARN) des Zertifikats, um das Zertifikat später zu konfigurieren.
### Erstellen Sie das Zertifikat aus einem privaten Schlüssel in einem HSM
**Anmerkung**
Diese Funktion ist für Version 2.5.3 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten.
**Um das Ding-Zertifikat zu erstellen**
1. Initialisieren Sie auf dem Core-Gerät ein PKCS \$111 -Token im HSM und generieren Sie einen privaten Schlüssel. Der private Schlüssel muss ein RSA-Schlüssel mit einer RSA-2048-Schlüsselgröße (oder größer) oder ein ECC-Schlüssel sein.
**Anmerkung**
Um ein Hardware-Sicherheitsmodul mit ECC-Schlüsseln zu verwenden, müssen Sie [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.6 oder höher verwenden.
Um ein Hardware-Sicherheitsmodul und einen [Secret Manager](secret-manager-component.md) zu verwenden, müssen Sie ein Hardware-Sicherheitsmodul mit RSA-Schlüsseln verwenden.
In der Dokumentation zu Ihrem HSM erfahren Sie, wie Sie das Token initialisieren und den privaten Schlüssel generieren. Wenn Ihr HSM Objekte unterstützt IDs, geben Sie bei der Generierung des privaten Schlüssels eine Objekt-ID an. Speichern Sie die Slot-ID, die Benutzer-PIN, die Objektbezeichnung und die Objekt-ID (falls Ihr HSM eine verwendet), die Sie angeben, wenn Sie das Token initialisieren und den privaten Schlüssel generieren. Sie verwenden diese Werte später, wenn Sie das Ding-Zertifikat in das HSM importieren und die Core-Software konfigurieren. AWS IoT Greengrass
1. Erstellen Sie eine Zertifikatsignieranforderung (CSR) aus dem privaten Schlüssel. AWS IoT verwendet diese CSR, um ein Ding-Zertifikat für den privaten Schlüssel zu erstellen, den Sie im HSM generiert haben. Informationen zum Erstellen einer CSR aus dem privaten Schlüssel finden Sie in der Dokumentation zu Ihrem HSM. Die CSR ist eine Datei, wie z. `iotdevicekey.csr`
1. Kopieren Sie die CSR vom Gerät auf Ihren Entwicklungscomputer. Wenn SSH und SCP auf dem Entwicklungscomputer und dem Gerät aktiviert sind, können Sie den `scp` Befehl auf Ihrem Entwicklungscomputer verwenden, um die CSR zu übertragen. *device-ip-address*Ersetzen Sie es durch die IP-Adresse Ihres Geräts und *\$1/iotdevicekey.csr* ersetzen Sie es durch den Pfad zur CSR-Datei auf dem Gerät.
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. Erstellen Sie auf Ihrem Entwicklungscomputer einen Ordner, in den Sie das Zertifikat für das AWS IoT Ding herunterladen.
```
mkdir greengrass-v2-certs
```
1. Verwenden Sie die CSR-Datei, um das Zertifikat für das AWS IoT Ding zu erstellen und auf Ihren Entwicklungscomputer herunterzuladen.
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die Anfrage erfolgreich ist.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
Speichern Sie den ARN des Zertifikats, um das Zertifikat später zu konfigurieren.
## Konfigurieren Sie das Ding-Zertifikat
Hängen Sie das Ding-Zertifikat an das AWS IoT Ding an, das Sie zuvor erstellt haben, und fügen Sie dem Zertifikat eine AWS IoT Richtlinie hinzu, um die AWS IoT Berechtigungen für das Kerngerät zu definieren.
**Um das Zertifikat des Dings zu konfigurieren**
1. Hängen Sie das Zertifikat an das AWS IoT Ding an.
+ Ersetze es *MyGreengrassCore* durch den Namen deines AWS IoT Dings.
+ Ersetzen Sie das Zertifikat Amazon Resource Name (ARN) durch den ARN des Zertifikats, das Sie im vorherigen Schritt erstellt haben.
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
1. Erstellen Sie eine AWS IoT Richtlinie, die die AWS IoT Berechtigungen für Ihr Greengrass-Core-Gerät definiert, und fügen Sie sie hinzu. Die folgende Richtlinie ermöglicht den Zugriff auf alle MQTT-Themen und Greengrass-Operationen, sodass Ihr Gerät mit benutzerdefinierten Anwendungen und future Änderungen, die neue Greengrass-Operationen erfordern, funktioniert. Sie können diese Richtlinie je nach 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).
Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen AWS IoT Richtlinie anhängen, anstatt eine neue zu erstellen.
Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das AWS IoT Richtliniendokument enthält, das für Greengrass-Core-Geräte erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano greengrass-v2-iot-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. Erstellen Sie eine AWS IoT Richtlinie aus dem Richtliniendokument.
+ *GreengrassV2IoTThingPolicy*Ersetzen Sie es durch den Namen der zu erstellenden Richtlinie.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Hängen Sie die AWS IoT Richtlinie an das Zertifikat der AWS IoT Sache an.
+ *GreengrassV2IoTThingPolicy*Ersetzen Sie es durch den Namen der Richtlinie, die angehängt werden soll.
+ Ersetzen Sie den Ziel-ARN durch den ARN des Zertifikats für Ihr AWS IoT Ding.
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
## Erstellen Sie eine Token-Exchange-Rolle
Greengrass-Core-Geräte verwenden eine IAM-Servicerolle, die so genannte *Token-Exchange-Rolle*, um Aufrufe von Diensten zu autorisieren. AWS Das Gerät verwendet den AWS IoT Anmeldeinformationsanbieter, um temporäre AWS Anmeldeinformationen für diese Rolle abzurufen. Dadurch kann das Gerät mit Amazon Logs interagieren AWS IoT, Protokolle an Amazon CloudWatch Logs senden und benutzerdefinierte Komponentenartefakte von Amazon S3 herunterladen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
Sie verwenden einen AWS IoT *Rollenalias*, um die Token-Austauschrolle für Greengrass-Core-Geräte zu konfigurieren. Rollenaliase ermöglichen es Ihnen, die Token-Austauschrolle für ein Gerät zu ändern, aber die Gerätekonfiguration beizubehalten. Weitere Informationen finden Sie im [*AWS IoT Core Entwicklerhandbuch* unter Autorisieren von direkten Aufrufen von AWS Diensten](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html).
In diesem Abschnitt erstellen Sie eine Token-Exchange-IAM-Rolle und einen AWS IoT Rollenalias, der auf die Rolle verweist. Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen Token-Austauschrolle und seinen Rollenalias verwenden, anstatt neue zu erstellen. Anschließend konfigurieren Sie das Gerät so, dass es AWS IoT diese Rolle und diesen Alias verwendet.
**Um eine Token-Exchange-IAM-Rolle zu erstellen**
1. Erstellen Sie eine IAM-Rolle, die Ihr Gerät als Token-Austauschrolle verwenden kann. Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das Dokument mit der Vertrauensrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-trust-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Erstellen Sie die Token-Austauschrolle mit dem Dokument zur Vertrauensrichtlinie.
+ *GreengrassV2TokenExchangeRole*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Rolle.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Erstellen Sie eine Datei, die das Dokument mit der Zugriffsrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-access-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Anmerkung**
Diese Zugriffsrichtlinie erlaubt keinen Zugriff auf Komponentenartefakte in S3-Buckets. Um benutzerdefinierte Komponenten bereitzustellen, die Artefakte in Amazon S3 definieren, müssen Sie der Rolle Berechtigungen hinzufügen, damit Ihr Kerngerät Komponentenartefakte abrufen kann. Weitere Informationen finden Sie unter [Erlauben Sie den Zugriff auf S3-Buckets für Komponentenartefakte](device-service-role.md#device-service-role-access-s3-bucket).
Wenn Sie noch keinen S3-Bucket für Komponentenartefakte haben, können Sie diese Berechtigungen später hinzufügen, nachdem Sie einen Bucket erstellt haben.
1. Erstellen Sie die IAM-Richtlinie anhand des Richtliniendokuments.
+ *GreengrassV2TokenExchangeRoleAccess*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Richtlinie.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Hängen Sie die IAM-Richtlinie an die Token-Exchange-Rolle an.
+ Ersetzen Sie *GreengrassV2TokenExchangeRole* durch den Namen der IAM-Rolle.
+ Ersetzen Sie den Richtlinien-ARN durch den ARN der IAM-Richtlinie, die Sie im vorherigen Schritt erstellt haben.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
1. Erstellen Sie einen AWS IoT Rollenalias, der auf die Token-Exchange-Rolle verweist.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie ihn durch den Namen des Rollenalias, den Sie erstellen möchten.
+ Ersetzen Sie den Rollen-ARN durch den ARN der IAM-Rolle, die Sie im vorherigen Schritt erstellt haben.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Anmerkung**
Um einen Rollenalias zu erstellen, benötigen Sie die Berechtigung, die Token-Exchange-IAM-Rolle zu übergeben. AWS IoT Wenn Sie beim Versuch, einen Rollenalias zu erstellen, eine Fehlermeldung erhalten, überprüfen Sie, ob Ihr AWS Benutzer über diese Berechtigung verfügt. *Weitere Informationen finden Sie im [Benutzerhandbuch unter Erteilen von Benutzerberechtigungen zur Übergabe einer Rolle an einen AWS Dienst](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).AWS Identity and Access Management *
1. Erstellen und fügen Sie eine AWS IoT Richtlinie hinzu, die es Ihrem Greengrass-Core-Gerät ermöglicht, den Rollenalias zu verwenden, um die Token-Austauschrolle zu übernehmen. Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen AWS IoT Rollenalias-Richtlinie anhängen, anstatt eine neue zu erstellen. Gehen Sie wie folgt vor:
1. (Optional) Erstellen Sie eine Datei, die das AWS IoT Richtliniendokument enthält, das für den Rollenalias erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
+ Ersetzen Sie den Ressourcen-ARN durch den ARN Ihres Rollenalias.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Erstellen Sie eine AWS IoT Richtlinie aus dem Richtliniendokument.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Ersetzen Sie es durch den Namen der zu erstellenden AWS IoT Richtlinie.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Hängen Sie die AWS IoT Richtlinie an das Zertifikat der AWS IoT Sache an.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Ersetzen Sie es durch den Namen der AWS IoT Rollenalias-Richtlinie.
+ Ersetzen Sie den Ziel-ARN durch den ARN des Zertifikats für Ihr AWS IoT Ding.
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
## Laden Sie Zertifikate auf das Gerät herunter
Zuvor haben Sie das Zertifikat Ihres Geräts auf Ihren Entwicklungscomputer heruntergeladen. In diesem Abschnitt kopieren Sie das Zertifikat auf Ihr Kerngerät, um das Gerät mit den Zertifikaten einzurichten, mit denen es eine Verbindung herstellt AWS IoT. Sie laden auch das Zertifikat der Amazon Root Certificate Authority (CA) herunter. Wenn Sie ein HSM verwenden, importieren Sie in diesem Abschnitt auch die Zertifikatsdatei in das HSM.
+ Wenn Sie das Ding-Zertifikat und den privaten Schlüssel zuvor im AWS IoT Dienst erstellt haben, folgen Sie den Schritten, um die Zertifikate mit dem privaten Schlüssel und den Zertifikatsdateien herunterzuladen.
+ Wenn Sie das Ding-Zertifikat zuvor aus einem privaten Schlüssel in einem Hardware-Sicherheitsmodul (HSM) erstellt haben, gehen Sie wie folgt vor, um die Zertifikate mit dem privaten Schlüssel und dem Zertifikat in ein HSM herunterzuladen.
### Laden Sie Zertifikate mit privatem Schlüssel und Zertifikatsdateien herunter
**Um Zertifikate auf das Gerät herunterzuladen**
1. Kopieren Sie das AWS IoT Ding-Zertifikat von Ihrem Entwicklungscomputer auf das Gerät. Wenn SSH und SCP auf dem Entwicklungscomputer und dem Gerät aktiviert sind, können Sie den `scp` Befehl auf Ihrem Entwicklungscomputer verwenden, um das Zertifikat zu übertragen. *device-ip-address*Ersetzen Sie es durch die IP-Adresse Ihres Geräts.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Erstellen Sie den Greengrass-Stammordner auf dem Gerät. Sie werden später die AWS IoT Greengrass Core-Software in diesem Ordner installieren.
**Anmerkung**
Windows hat eine Pfadlängenbegrenzung von 260 Zeichen. Wenn Sie Windows verwenden, verwenden Sie einen Stammordner wie `C:\greengrass\v2` oder, `D:\greengrass\v2` um die Greengrass-Komponentenpfade unter der Obergrenze von 260 Zeichen zu halten.
------
#### [ Linux or Unix ]
+ Ersetzen Sie es `/greengrass/v2` durch den zu verwendenden Ordner.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
1. (Nur Linux) Legen Sie die Berechtigungen des übergeordneten Elements des Greengrass-Stammordners fest.
+ */greengrass*Ersetzen Sie es durch das übergeordnete Objekt des Stammordners.
```
sudo chmod 755 /greengrass
```
1. Kopieren Sie die AWS IoT Ding-Zertifikate in den Greengrass-Stammordner.
------
#### [ Linux or Unix ]
+ `/greengrass/v2`Ersetzen Sie es durch den Greengrass-Stammordner.
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Ersetzen Sie es *C:\$1greengrass\$1v2* durch den Ordner, den Sie verwenden möchten.
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Laden Sie das Zertifikat der Amazon Root Certificate Authority (CA) herunter. AWS IoT Zertifikate sind standardmäßig mit dem Root-CA-Zertifikat von Amazon verknüpft.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### Laden Sie Zertifikate mit dem privaten Schlüssel und dem Zertifikat in ein HSM herunter
**Anmerkung**
Diese Funktion ist für Version 2.5.3 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten.
**Um Zertifikate auf das Gerät herunterzuladen**
1. Kopieren Sie das AWS IoT Ding-Zertifikat von Ihrem Entwicklungscomputer auf das Gerät. Wenn SSH und SCP auf dem Entwicklungscomputer und dem Gerät aktiviert sind, können Sie den `scp` Befehl auf Ihrem Entwicklungscomputer verwenden, um das Zertifikat zu übertragen. *device-ip-address*Ersetzen Sie es durch die IP-Adresse Ihres Geräts.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Erstellen Sie den Greengrass-Stammordner auf dem Gerät. Sie werden später die AWS IoT Greengrass Core-Software in diesem Ordner installieren.
**Anmerkung**
Windows hat eine Pfadlängenbegrenzung von 260 Zeichen. Wenn Sie Windows verwenden, verwenden Sie einen Stammordner wie `C:\greengrass\v2` oder, `D:\greengrass\v2` um die Greengrass-Komponentenpfade unter der Obergrenze von 260 Zeichen zu halten.
------
#### [ Linux or Unix ]
+ Ersetzen Sie es `/greengrass/v2` durch den zu verwendenden Ordner.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
1. (Nur Linux) Legen Sie die Berechtigungen des übergeordneten Elements des Greengrass-Stammordners fest.
+ */greengrass*Ersetzen Sie es durch das übergeordnete Objekt des Stammordners.
```
sudo chmod 755 /greengrass
```
1. Importieren Sie die Ding-Zertifikatsdatei,`~/greengrass-v2-certs/device.pem.crt`, in das HSM. In der Dokumentation zu Ihrem HSM erfahren Sie, wie Sie Zertifikate in Ihr HSM importieren können. Importieren Sie das Zertifikat mit demselben Token, derselben Slot-ID, derselben Benutzer-PIN, derselben Objektbezeichnung und Objekt-ID (falls Ihr HSM eine verwendet), mit denen Sie zuvor den privaten Schlüssel im HSM generiert haben.
**Anmerkung**
Wenn Sie den privaten Schlüssel zuvor ohne Objekt-ID generiert haben und das Zertifikat eine Objekt-ID hat, setzen Sie die Objekt-ID des privaten Schlüssels auf denselben Wert wie das Zertifikat. In der Dokumentation zu Ihrem HSM erfahren Sie, wie Sie die Objekt-ID für das Objekt mit dem privaten Schlüssel festlegen.
1. (Optional) Löschen Sie die Ding-Zertifikatsdatei, sodass sie nur im HSM existiert.
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Laden Sie das Zertifikat der Amazon Root Certificate Authority (CA) herunter. AWS IoT Zertifikate sind standardmäßig mit dem Root-CA-Zertifikat von Amazon verknüpft.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Richten Sie die Geräteumgebung ein
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 ein
**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 (in der Regel`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
**Anmerkung**
Diese Funktion ist für Version 2.5.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
**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
## Laden Sie die AWS IoT Greengrass Core-Software herunter
Sie können die neueste Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Anmerkung**
Sie können eine bestimmte Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen. Ersetzen Sie es *version* durch die Version, die Sie herunterladen möchten.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Um die AWS IoT Greengrass Core-Software herunterzuladen**
1. Laden Sie die Core-Software auf Ihrem AWS IoT Greengrass Core-Gerät in eine Datei mit dem Namen herunter`greengrass-nucleus-latest.zip`.
------
#### [ 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. (Optional) Um die Greengrass Nucleus-Softwaresignatur zu überprüfen
**Anmerkung**
Diese Funktion ist mit Greengrass Nucleus Version 2.9.5 und höher verfügbar.
1. Verwenden Sie den folgenden Befehl, um die Signatur Ihres Greengrass-Kernartefakts zu überprüfen:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Der Dateiname kann je nach installierter JDK-Version anders aussehen. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Der Dateiname sieht je nach installierter JDK-Version möglicherweise anders aus. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. Der `jarsigner` Aufruf liefert eine Ausgabe, die die Ergebnisse der Überprüfung angibt.
1. Wenn die Greengrass Nucleus-Zip-Datei signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar verified.
```
1. Wenn die Greengrass Nucleus-Zip-Datei nicht signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar is unsigned.
```
1. Wenn Sie die `-certs` Option Jarsigner zusammen mit den `-verbose` Optionen `-verify` und angegeben haben, enthält die Ausgabe auch detaillierte Informationen zum Unterzeichnerzertifikat.
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. (Optional) Führen Sie den folgenden Befehl aus, um die Version der AWS IoT Greengrass Core-Software zu sehen.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Wichtig**
Wenn Sie eine Version von Greengrass Nucleus vor v2.4.0 installieren, entfernen Sie diesen Ordner nicht, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben. Die AWS IoT Greengrass Core-Software verwendet die Dateien in diesem Ordner zur Ausführung.
Wenn Sie die neueste Version der Software heruntergeladen haben, installieren Sie v2.4.0 oder höher, und Sie können diesen Ordner nach der Installation der AWS IoT Greengrass Core-Software entfernen.
## Installieren Sie die Core-Software AWS IoT Greengrass
Führen Sie das Installationsprogramm mit Argumenten aus, die die folgenden Aktionen angeben:
+ Installieren Sie die Installation aus einer Teilkonfigurationsdatei, in der angegeben ist, dass die AWS Ressourcen und Zertifikate verwendet werden sollen, die Sie zuvor erstellt haben. Die AWS IoT Greengrass Core-Software verwendet eine Konfigurationsdatei, die die Konfiguration jeder Greengrass-Komponente auf dem Gerät spezifiziert. Das Installationsprogramm erstellt aus der von Ihnen bereitgestellten Teilkonfigurationsdatei eine vollständige Konfigurationsdatei.
+ Geben Sie an, dass der `ggc_user` Systembenutzer Softwarekomponenten auf dem Kerngerät ausführen 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.
+ 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.
Weitere Hinweise zu den Argumenten, die Sie angeben können, finden Sie unter[Argumente des Installers](configure-installer.md).
**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 das Ding-Zertifikat und den privaten Schlüssel zuvor im AWS IoT Dienst erstellt haben, folgen Sie den Schritten, um die AWS IoT Greengrass Core-Software mit privaten Schlüssel- und Zertifikatsdateien zu installieren.
+ Wenn Sie das Ding-Zertifikat zuvor mit einem privaten Schlüssel in einem Hardware-Sicherheitsmodul (HSM) erstellt haben, folgen Sie den Schritten, um die AWS IoT Greengrass Core-Software mit dem privaten Schlüssel und dem Zertifikat in einem HSM zu installieren.
### Installieren Sie die AWS IoT Greengrass Core-Software mit privaten Schlüssel- und Zertifikatsdateien
**Um die AWS IoT Greengrass Core-Software zu installieren**
1. Überprüfen Sie die Version der AWS IoT Greengrass Core-Software.
+ *GreengrassInstaller*Ersetzen Sie durch den Pfad zu dem Ordner, der die Software enthält.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `config.yaml` zu erstellen, die dem Installationsprogramm zur Verfügung gestellt werden soll.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano GreengrassInstaller/config.yaml
```
Kopieren Sie den folgenden YAML-Inhalt in die Datei. Diese Teilkonfigurationsdatei spezifiziert Systemparameter und Greengrass-Nukleus-Parameter.
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
Führen Sie dann die folgenden Schritte aus:
+ Ersetzen Sie jede Instanz von `/greengrass/v2` durch den Greengrass-Stammordner.
+ Ersetze es *MyGreengrassCore* durch den Namen der AWS IoT Sache.
+ *2.16.1*Ersetzen Sie durch die Version der AWS IoT Greengrass Core-Software.
+ *us-west-2*Ersetzen Sie durch den AWS-Region Ort, an dem Sie die Ressourcen erstellt haben.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie es durch den Namen des Alias der Token-Exchange-Rolle.
+ Ersetzen Sie den `iotDataEndpoint` durch Ihren AWS IoT Datenendpunkt.
+ Ersetzen Sie den Endpunkt `iotCredEndpoint` durch Ihren AWS IoT Anmeldeinformationen-Endpunkt.
**Anmerkung**
In dieser Konfigurationsdatei können Sie andere Nucleus-Konfigurationsoptionen wie die zu verwendenden Ports und den Netzwerk-Proxy anpassen, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter [Greengrass Nucleus-Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. Führen Sie das Installationsprogramm aus und geben Sie `--init-config` an, dass Sie die Konfigurationsdatei bereitstellen möchten.
+ Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Greengrass-Stammordner.
+ Ersetzen Sie jede Instanz von *GreengrassInstaller* durch den Ordner, in den Sie das Installationsprogramm entpackt haben.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Wichtig**
Auf Windows Core-Geräten müssen Sie angeben, `--setup-system-service true` dass die AWS IoT Greengrass Core-Software als Systemdienst eingerichtet werden soll.
Wenn Sie dies angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Successfully set up Nucleus as a system service` ob es die Software als Systemdienst eingerichtet und ausgeführt hat. Andernfalls gibt das Installationsprogramm keine Meldung aus, wenn es die Software erfolgreich installiert hat.
**Anmerkung**
Sie können das `deploy-dev-tools` Argument nicht verwenden, um lokale Entwicklungstools bereitzustellen, wenn Sie das Installationsprogramm ohne das `--provision true` Argument ausführen. Informationen zur direkten Bereitstellung der Greengrass-CLI auf Ihrem Gerät finden Sie unter[Greengrass-Befehlszeilenschnittstelle](gg-cli.md).
1. Überprüfen Sie die Installation, indem Sie sich die Dateien im Stammordner ansehen.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Wenn die Installation erfolgreich war, enthält der Stammordner mehrere Ordner, z. B. `config``packages`, und`logs`.
### Installieren Sie die AWS IoT Greengrass Core-Software mit dem privaten Schlüssel und dem Zertifikat in einem HSM
**Anmerkung**
Diese Funktion ist für Version 2.5.3 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten.
**Um die AWS IoT Greengrass Core-Software zu installieren**
1. Überprüfen Sie die Version der AWS IoT Greengrass Core-Software.
+ *GreengrassInstaller*Ersetzen Sie durch den Pfad zu dem Ordner, der die Software enthält.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Damit die AWS IoT Greengrass Core-Software den privaten Schlüssel und das Zertifikat im HSM verwenden kann, installieren Sie bei der Installation der AWS IoT Greengrass Core-Software die [PKCS \$111 -Anbieterkomponente](pkcs11-provider-component.md). Die PKCS \$111 -Provider-Komponente ist ein Plugin, das Sie während der Installation konfigurieren können. Sie können die neueste Version der PKCS \$111 -Provider-Komponente von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
Laden Sie das PKCS \$111 -Provider-Plugin in eine Datei mit dem Namen herunter. `aws.greengrass.crypto.Pkcs11Provider.jar` *GreengrassInstaller*Ersetzen Sie es durch den Ordner, den Sie verwenden möchten.
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
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. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `config.yaml` zu erstellen, die dem Installationsprogramm zur Verfügung gestellt werden soll.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano GreengrassInstaller/config.yaml
```
Kopieren Sie den folgenden YAML-Inhalt in die Datei. Diese Teilkonfigurationsdatei spezifiziert Systemparameter, Greengrass-Nukleus-Parameter und PKCS \$111 -Anbieterparameter.
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
Führen Sie dann die folgenden Schritte aus:
+ Ersetzen Sie jede Instanz von *iotdevicekey* in PKCS \$111 URIs durch die Objektbezeichnung, in der Sie den privaten Schlüssel erstellt und das Zertifikat importiert haben.
+ Ersetzen Sie jede Instanz von `/greengrass/v2` durch den Greengrass-Stammordner.
+ Ersetze es *MyGreengrassCore* durch den Namen der AWS IoT Sache.
+ *2.16.1*Ersetzen Sie durch die Version der AWS IoT Greengrass Core-Software.
+ *us-west-2*Ersetzen Sie durch den AWS-Region Ort, an dem Sie die Ressourcen erstellt haben.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie es durch den Namen des Alias der Token-Exchange-Rolle.
+ Ersetzen Sie den `iotDataEndpoint` durch Ihren AWS IoT Datenendpunkt.
+ Ersetzen Sie den Endpunkt `iotCredEndpoint` durch Ihren AWS IoT Anmeldeinformationen-Endpunkt.
+ Ersetzen Sie die Konfigurationsparameter für die `aws.greengrass.crypto.Pkcs11Provider` Komponente durch die Werte für die HSM-Konfiguration auf dem Kerngerät.
**Anmerkung**
In dieser Konfigurationsdatei können Sie andere Nucleus-Konfigurationsoptionen wie die zu verwendenden Ports und den Netzwerk-Proxy anpassen, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter [Greengrass Nucleus-Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. Führen Sie das Installationsprogramm aus und geben Sie `--init-config` an, dass Sie die Konfigurationsdatei bereitstellen möchten.
+ `/greengrass/v2`Ersetzen Sie es durch den Greengrass-Stammordner.
+ Ersetzen Sie jede Instanz von *GreengrassInstaller* durch den Ordner, in den Sie das Installationsprogramm entpackt haben.
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**Wichtig**
Auf Windows Core-Geräten müssen Sie angeben, `--setup-system-service true` dass die AWS IoT Greengrass Core-Software als Systemdienst eingerichtet werden soll.
Wenn Sie dies angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Successfully set up Nucleus as a system service` ob es die Software als Systemdienst eingerichtet und ausgeführt hat. Andernfalls gibt das Installationsprogramm keine Meldung aus, wenn es die Software erfolgreich installiert hat.
**Anmerkung**
Sie können das `deploy-dev-tools` Argument nicht verwenden, um lokale Entwicklungstools bereitzustellen, wenn Sie das Installationsprogramm ohne das `--provision true` Argument ausführen. Informationen zur direkten Bereitstellung der Greengrass-CLI auf Ihrem Gerät finden Sie unter[Greengrass-Befehlszeilenschnittstelle](gg-cli.md).
1. Überprüfen Sie die Installation, indem Sie sich die Dateien im Stammordner ansehen.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Wenn die Installation erfolgreich war, enthält der Stammordner mehrere Ordner, z. B. `config``packages`, und`logs`.
Wenn Sie die AWS IoT Greengrass Core-Software als Systemdienst installiert haben, führt das Installationsprogramm die Software für Sie aus. Andernfalls müssen Sie die Software manuell ausführen. Weitere Informationen finden Sie unter [Führen Sie die AWS IoT Greengrass Core-Software aus](run-greengrass-core-v2.md).
**Anmerkung**
Wenn die AWS IoT Greengrass Core-Software eine Verbindung zur Cloud herstellt, wird Ihr Gerät als Core-Gerät erkannt.
Weitere Informationen zur Konfiguration und Verwendung der Software finden Sie unter: AWS IoT Greengrass
+ [Konfiguration der AWS IoT Greengrass Core-Software](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)
+ [Greengrass-Befehlszeilenschnittstelle](gg-cli.md)
# Installieren Sie die AWS IoT Greengrass Core-Software mit AWS IoT Flottenbereitstellung
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
Mit AWS IoT Fleet Provisioning können Sie konfigurieren, AWS IoT dass X.509-Gerätezertifikate und private Schlüssel generiert und sicher an Ihre Geräte gesendet werden, wenn diese zum ersten Mal eine Verbindung herstellen. AWS IoT AWS IoT stellt Client-Zertifikate bereit, die von der Amazon Root Certificate Authority (CA) signiert wurden. Sie können auch so konfigurieren AWS IoT , dass Dinggruppen, Dingtypen und Berechtigungen für Greengrass-Kerngeräte angegeben werden, die Sie mit Fleet Provisioning bereitstellen. Sie definieren eine *Bereitstellungsvorlage*, um zu definieren, wie jedes Gerät bereitgestellt wird AWS IoT . In der Bereitstellungsvorlage werden die Ressourcen für Dinge, Richtlinien und Zertifikate angegeben, die bei der Bereitstellung für ein Gerät erstellt werden sollen. *Weitere Informationen finden Sie unter [Bereitstellungsvorlagen im Entwicklerhandbuch](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html).AWS IoT Core *
AWS IoT Greengrass bietet ein AWS IoT Flottenbereitstellungs-Plugin, mit dem Sie die AWS IoT Greengrass Core-Software mithilfe von AWS Ressourcen installieren können, die durch AWS IoT Fleet Provisioning erstellt wurden. Das Fleet Provisioning Plugin verwendet die *Bereitstellung* nach Anspruch. Geräte verwenden ein Provisioning-Anspruchszertifikat und einen privaten Schlüssel, um ein eindeutiges X.509-Gerätezertifikat und einen privaten Schlüssel zu erhalten, die sie für den regulären Betrieb verwenden können. Sie können das Antragszertifikat und den privaten Schlüssel während der Herstellung in jedes Gerät einbetten, sodass Ihre Kunden die Geräte später aktivieren können, wenn jedes Gerät online ist. Sie können dasselbe Antragszertifikat und denselben privaten Schlüssel für mehrere Geräte verwenden. Weitere Informationen finden Sie unter [Provisioning by Claim](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) im *AWS IoT Core Developer Guide*.
**Anmerkung**
Das Fleet Provisioning-Plugin unterstützt derzeit nicht das Speichern von privaten Schlüssel- und Zertifikatsdateien in einem Hardware-Sicherheitsmodul (HSM). Um ein HSM zu verwenden, [installieren Sie die AWS IoT Greengrass Core-Software mit](manual-installation.md) manueller Bereitstellung.
Um die AWS IoT Greengrass Core-Software mit AWS IoT Flottenbereitstellung zu installieren, müssen Sie Ressourcen in Ihrem einrichten, die für AWS-Konto die Bereitstellung von Greengrass-Core-Geräten AWS IoT verwendet werden. Zu diesen Ressourcen gehören eine Bereitstellungsvorlage, Antragszertifikate und eine IAM-Rolle für den [Tokenaustausch](device-service-role.md). Nachdem Sie diese Ressourcen erstellt haben, können Sie sie wiederverwenden, um mehrere Kerngeräte in einer Flotte bereitzustellen. Weitere Informationen finden Sie unter [AWS IoT Flottenbereitstellung für Greengrass-Kerngeräte einrichten](fleet-provisioning-setup.md).
**Wichtig**
Bevor Sie die AWS IoT Greengrass Core-Software herunterladen, überprüfen Sie, ob Ihr Kerngerät die [Anforderungen](greengrass-nucleus-component.md#greengrass-v2-requirements) für die Installation und Ausführung der AWS IoT Greengrass Core-Software v2.0 erfüllt.
**Topics**
+ [Voraussetzungen](#fleet-provisioning-prerequisites)
+ [Endpunkte abrufen AWS IoT](#retrieve-iot-endpoints)
+ [Laden Sie Zertifikate auf das Gerät herunter](#download-claim-certificates)
+ [Richten Sie die Geräteumgebung ein](#set-up-device-environment)
+ [Laden Sie die AWS IoT Greengrass Core-Software herunter](#download-greengrass-core-v2)
+ [Laden Sie das AWS IoT Fleet Provisioning Plugin herunter](#download-fleet-provisioning-plugin)
+ [Installieren Sie die AWS IoT Greengrass Core-Software](#run-greengrass-core-v2-installer-fleet)
+ [AWS IoT Flottenbereitstellung für Greengrass-Kerngeräte einrichten](fleet-provisioning-setup.md)
+ [Konfigurieren Sie das AWS IoT Flottenbereitstellungs-Plugin](fleet-provisioning-configuration.md)
+ [AWS IoT Changelog des Plug-ins für die Flottenbereitstellung](fleet-provisioning-changelog.md)
## Voraussetzungen
Um die AWS IoT Greengrass Core-Software mit AWS IoT Flottenbereitstellung zu installieren, müssen Sie zunächst die [AWS IoT Flottenbereitstellung für Greengrass-Kerngeräte einrichten](fleet-provisioning-setup.md). Nachdem Sie diese Schritte einmal abgeschlossen haben, können Sie Fleet Provisioning verwenden, um die AWS IoT Greengrass Core-Software auf einer beliebigen Anzahl von Geräten zu installieren.
## Endpunkte abrufen AWS IoT
Holen Sie sich die AWS IoT Endpunkte für Sie und speichern Sie sie AWS-Konto, um sie später zu verwenden. Ihr Gerät verwendet diese Endpunkte, um eine Verbindung herzustellen. AWS IoT Gehen Sie wie folgt vor:
1. Holen Sie sich den AWS IoT Datenendpunkt für Ihren AWS-Konto.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Rufen Sie den Endpunkt der AWS IoT Anmeldeinformationen für Ihren AWS-Konto ab.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Laden Sie Zertifikate auf das Gerät herunter
Das Gerät verwendet ein Anspruchszertifikat und einen privaten Schlüssel, um seine Anfrage zur Bereitstellung von AWS Ressourcen zu authentifizieren und ein X.509-Gerätezertifikat zu erwerben. Sie können das Antragszertifikat und den privaten Schlüssel bei der Herstellung in das Gerät einbetten oder das Zertifikat und den Schlüssel bei der Installation auf das Gerät kopieren. In diesem Abschnitt kopieren Sie das Antragszertifikat und den privaten Schlüssel auf das Gerät. Sie laden auch das Zertifikat der Amazon Root Certificate Authority (CA) auf das Gerät herunter.
**Wichtig**
Private Schlüssel für Provisioning Claim sollten jederzeit gesichert sein, auch auf Greengrass-Core-Geräten. Wir empfehlen Ihnen, anhand von CloudWatch Kennzahlen und Protokollen von Amazon nach Hinweisen auf Missbrauch zu suchen, wie z. B. die unbefugte Verwendung des Antragszertifikats zur Bereitstellung von Geräten. Wenn Sie einen Missbrauch feststellen, deaktivieren Sie das Provisioning Claim Certificate, sodass es nicht für die Bereitstellung von Geräten verwendet werden kann. Weitere Informationen finden Sie unter [Überwachung AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) im *AWS IoT Core Entwicklerhandbuch*.
Damit Sie die Anzahl der Geräte und die Geräte, die sich bei Ihnen registrieren, besser verwalten können, können Sie AWS-Konto bei der Erstellung einer Flottenbereitstellungsvorlage einen Pre-Provisioning-Hook angeben. Ein Pre-Provisioning-Hook ist eine AWS Lambda Funktion, die Vorlagenparameter validiert, die Geräte bei der Registrierung angeben. Sie können beispielsweise einen Pre-Provisioning-Hook erstellen, der eine Geräte-ID mit einer Datenbank vergleicht, um sicherzustellen, dass das Gerät über eine Bereitstellungsberechtigung verfügt. *Weitere Informationen finden Sie unter [Pre-Provisioning Hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) im Developer Guide.AWS IoT Core *
**So laden Sie Anspruchszertifikate auf das Gerät herunter**
1. Kopieren Sie das Antragszertifikat und den privaten Schlüssel auf das Gerät. Wenn SSH und SCP auf dem Entwicklungscomputer und dem Gerät aktiviert sind, können Sie den `scp` Befehl auf Ihrem Entwicklungscomputer verwenden, um das Anspruchszertifikat und den privaten Schlüssel zu übertragen. Der folgende Beispielbefehl überträgt diese Dateien in einem Ordner mit dem Namen `claim-certs` auf Ihrem Entwicklungscomputer auf das Gerät. *device-ip-address*Ersetzen Sie es durch die IP-Adresse Ihres Geräts.
```
scp -r claim-certs/ device-ip-address:~
```
1. Erstellen Sie den Greengrass-Stammordner auf dem Gerät. Sie werden später die AWS IoT Greengrass Core-Software in diesem Ordner installieren.
**Anmerkung**
Windows hat eine Pfadlängenbegrenzung von 260 Zeichen. Wenn Sie Windows verwenden, verwenden Sie einen Stammordner wie `C:\greengrass\v2` oder, `D:\greengrass\v2` um die Greengrass-Komponentenpfade unter der Obergrenze von 260 Zeichen zu halten.
------
#### [ Linux or Unix ]
+ Ersetzen Sie es `/greengrass/v2` durch den Ordner, den Sie verwenden möchten.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ *C:\$1greengrass\$1v2*Ersetzen Sie durch den zu verwendenden Ordner.
```
mkdir C:\greengrass\v2
```
------
1. (Nur Linux) Legen Sie die Berechtigungen des übergeordneten Elements des Greengrass-Stammordners fest.
+ */greengrass*Ersetzen Sie es durch das übergeordnete Objekt des Stammordners.
```
sudo chmod 755 /greengrass
```
1. Verschieben Sie die Anspruchszertifikate in den Greengrass-Stammordner.
+ Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Greengrass-Stammordner.
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. Laden Sie das Zertifikat der Amazon Root Certificate Authority (CA) herunter. AWS IoT Zertifikate sind standardmäßig mit dem Root-CA-Zertifikat von Amazon verknüpft.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Richten Sie die Geräteumgebung ein
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 ein
**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 mithilfe des `--component-default-user` Installer-Arguments 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
**Anmerkung**
Diese Funktion ist für Version 2.5.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
**So richten Sie ein Windows-Gerät ein 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
## Laden Sie die AWS IoT Greengrass Core-Software herunter
Sie können die neueste Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Anmerkung**
Sie können eine bestimmte Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen. Ersetzen Sie es *version* durch die Version, die Sie herunterladen möchten.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Um die AWS IoT Greengrass Core-Software herunterzuladen**
1. Laden Sie die Core-Software auf Ihrem AWS IoT Greengrass Core-Gerät in eine Datei mit dem Namen herunter`greengrass-nucleus-latest.zip`.
------
#### [ 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. (Optional) Um die Greengrass Nucleus-Softwaresignatur zu überprüfen
**Anmerkung**
Diese Funktion ist mit Greengrass Nucleus Version 2.9.5 und höher verfügbar.
1. Verwenden Sie den folgenden Befehl, um die Signatur Ihres Greengrass-Kernartefakts zu überprüfen:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Der Dateiname kann je nach installierter JDK-Version anders aussehen. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Der Dateiname sieht je nach installierter JDK-Version möglicherweise anders aus. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. Der `jarsigner` Aufruf liefert eine Ausgabe, die die Ergebnisse der Überprüfung angibt.
1. Wenn die Greengrass Nucleus-Zip-Datei signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar verified.
```
1. Wenn die Greengrass Nucleus-Zip-Datei nicht signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar is unsigned.
```
1. Wenn Sie die `-certs` Option Jarsigner zusammen mit den `-verbose` Optionen `-verify` und angegeben haben, enthält die Ausgabe auch detaillierte Informationen zum Unterzeichnerzertifikat.
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. (Optional) Führen Sie den folgenden Befehl aus, um die Version der AWS IoT Greengrass Core-Software zu sehen.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Wichtig**
Wenn Sie eine Version von Greengrass Nucleus vor v2.4.0 installieren, entfernen Sie diesen Ordner nicht, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben. Die AWS IoT Greengrass Core-Software verwendet die Dateien in diesem Ordner zur Ausführung.
Wenn Sie die neueste Version der Software heruntergeladen haben, installieren Sie v2.4.0 oder höher, und Sie können diesen Ordner entfernen, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben.
## Laden Sie das AWS IoT Fleet Provisioning Plugin herunter
Sie können die neueste Version des AWS IoT Fleet Provisioning-Plug-ins von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)-latest.jar
**Anmerkung**
Sie können eine bestimmte Version des AWS IoT Fleet Provisioning-Plug-ins von der folgenden Adresse herunterladen. Ersetzen Sie es *version* durch die Version, die heruntergeladen werden soll. Weitere Informationen zu den einzelnen Versionen des Fleet Provisioning-Plug-ins finden Sie unter[AWS IoT Changelog des Plug-ins für die Flottenbereitstellung](fleet-provisioning-changelog.md).
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
Das Fleet Provisioning Plugin ist Open Source. Den Quellcode finden Sie im [AWS IoT Fleet Provisioning Plugin](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) unter. GitHub
**Um das AWS IoT Fleet Provisioning Plugin herunterzuladen**
+ Laden Sie auf Ihrem Gerät das AWS IoT Fleet Provisioning-Plugin in eine Datei mit dem Namen herunter. `aws.greengrass.FleetProvisioningByClaim.jar` *GreengrassInstaller*Ersetzen Sie es durch den Ordner, den Sie verwenden möchten.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
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.
## Installieren Sie die AWS IoT Greengrass Core-Software
Führen Sie das Installationsprogramm mit Argumenten aus, die die folgenden Aktionen angeben:
+ Die Installation erfolgt aus einer Teilkonfigurationsdatei, in der angegeben ist, dass das Fleet Provisioning-Plugin zur Bereitstellung von AWS Ressourcen verwendet werden soll. Die AWS IoT Greengrass Core-Software verwendet eine Konfigurationsdatei, die die Konfiguration jeder Greengrass-Komponente auf dem Gerät spezifiziert. Das Installationsprogramm erstellt eine vollständige Konfigurationsdatei aus der von Ihnen bereitgestellten Teilkonfigurationsdatei und den AWS Ressourcen, die das Fleet Provisioning-Plugin erstellt.
+ 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.
+ 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.
Weitere Hinweise zu den Argumenten, die Sie angeben können, finden Sie unter[Argumente des Installers](configure-installer.md).
**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).
**Um die Core-Software zu installieren AWS IoT Greengrass**
1. Überprüfen Sie die Version der AWS IoT Greengrass Core-Software.
+ *GreengrassInstaller*Ersetzen Sie durch den Pfad zu dem Ordner, der die Software enthält.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `config.yaml` zu erstellen, die dem Installationsprogramm zur Verfügung gestellt werden soll.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano GreengrassInstaller/config.yaml
```
Kopieren Sie den folgenden YAML-Inhalt in die Datei. Diese Teilkonfigurationsdatei spezifiziert Parameter für das Fleet Provisioning Plugin. Weitere Informationen zu den Optionen, die Sie angeben können, finden Sie unter[Konfigurieren Sie das AWS IoT Flottenbereitstellungs-Plugin](fleet-provisioning-configuration.md).
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
Führen Sie dann die folgenden Schritte aus:
+ *2.16.1*Ersetzen Sie es durch die Version der AWS IoT Greengrass Core-Software.
+ Ersetzen Sie jede Instanz von `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Greengrass-Stammordner.
**Anmerkung**
Auf Windows-Geräten müssen Sie Pfadtrennzeichen als doppelte umgekehrte Schrägstriche (`\\`) angeben, z. B. `C:\\greengrass\\v2`
+ *us-west-2*Ersetzen Sie durch die AWS Region, in der Sie die Provisioning-Vorlage und andere Ressourcen erstellt haben.
+ Ersetzen Sie das `iotDataEndpoint` durch Ihren AWS IoT Datenendpunkt.
+ Ersetzen Sie den `iotCredentialEndpoint` durch den Endpunkt Ihrer AWS IoT Anmeldeinformationen.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie es durch den Namen des Alias der Token-Exchange-Rolle.
+ *GreengrassFleetProvisioningTemplate*Ersetzen Sie es durch den Namen der Vorlage für die Flottenbereitstellung.
+ Ersetzen Sie den `claimCertificatePath` durch den Pfad zum Antragszertifikat auf dem Gerät.
+ Ersetzen Sie den `claimCertificatePrivateKeyPath` durch den Pfad zum privaten Schlüssel des Anspruchszertifikats auf dem Gerät.
+ Ersetzen Sie die Vorlagenparameter (`templateParameters`) durch die Werte, die für die Bereitstellung des Geräts verwendet werden sollen. Dieses Beispiel bezieht sich auf die [Beispielvorlage](fleet-provisioning-setup.md#example-fleet-provisioning-template), die `ThingGroupName` Parameter definiert`ThingName`.
**Anmerkung**
In dieser Konfigurationsdatei können Sie andere Konfigurationsoptionen wie die zu verwendenden Ports und den Netzwerk-Proxy anpassen, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter [Greengrass Nucleus-Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
Um einen HTTPS-Proxy zu verwenden, müssen Sie Version 1.1.0 oder höher des Fleet Provisioning-Plug-ins verwenden. Sie müssen zusätzlich Folgendes angeben `rootCaPath``system`, wie im folgenden Beispiel gezeigt.
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. Führen Sie das Installationsprogramm aus. Geben Sie `--trusted-plugin` an, ob das Fleet Provisioning-Plug-In bereitgestellt werden soll, und geben Sie `--init-config` an, dass die Konfigurationsdatei bereitgestellt werden soll.
+ `/greengrass/v2`Ersetzen Sie es durch den Greengrass-Stammordner.
+ Ersetzen Sie jede Instanz von *GreengrassInstaller* durch den Ordner, in den Sie das Installationsprogramm entpackt haben.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Wichtig**
Auf Windows Core-Geräten müssen Sie angeben, `--setup-system-service true` dass die AWS IoT Greengrass Core-Software als Systemdienst eingerichtet werden soll.
Wenn Sie dies angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Successfully set up Nucleus as a system service` ob es die Software als Systemdienst eingerichtet und ausgeführt hat. Andernfalls gibt das Installationsprogramm keine Meldung aus, wenn es die Software erfolgreich installiert hat.
**Anmerkung**
Sie können das `deploy-dev-tools` Argument nicht verwenden, um lokale Entwicklungstools bereitzustellen, wenn Sie das Installationsprogramm ohne das `--provision true` Argument ausführen. Informationen zur direkten Bereitstellung der Greengrass-CLI auf Ihrem Gerät finden Sie unter[Greengrass-Befehlszeilenschnittstelle](gg-cli.md).
1. Überprüfen Sie die Installation, indem Sie sich die Dateien im Stammordner ansehen.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Wenn die Installation erfolgreich war, enthält der Stammordner mehrere Ordner, z. B. `config``packages`, und`logs`.
Wenn Sie die AWS IoT Greengrass Core-Software als Systemdienst installiert haben, führt das Installationsprogramm die Software für Sie aus. Andernfalls müssen Sie die Software manuell ausführen. Weitere Informationen finden Sie unter [Führen Sie die AWS IoT Greengrass Core-Software aus](run-greengrass-core-v2.md).
Weitere Informationen zur Konfiguration und Verwendung der Software finden Sie unter: AWS IoT Greengrass
+ [Konfiguration der AWS IoT Greengrass Core-Software](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)
+ [Greengrass-Befehlszeilenschnittstelle](gg-cli.md)
# AWS IoT Flottenbereitstellung für Greengrass-Kerngeräte einrichten
Um [die AWS IoT Greengrass Core-Software mit Flottenbereitstellung zu installieren](fleet-provisioning.md), müssen Sie zunächst die folgenden Ressourcen in Ihrem einrichten. AWS-Konto Diese Ressourcen ermöglichen es Geräten, sich bei Greengrass-Core-Geräten zu registrieren AWS IoT und als solche zu arbeiten. Folgen Sie einmal den Schritten in diesem Abschnitt, um diese Ressourcen in Ihrem AWS-Konto zu erstellen und zu konfigurieren.
+ Eine IAM-Rolle für den Tokenaustausch, mit der Kerngeräte Aufrufe von Diensten autorisieren. AWS
+ Ein AWS IoT Rollenalias, der auf die Token-Exchange-Rolle verweist.
+ (Optional) Eine AWS IoT Richtlinie, anhand derer Kerngeräte Anrufe an die AWS IoT Greengrass Dienste AWS IoT und autorisieren. Diese AWS IoT Richtlinie muss die `iot:AssumeRoleWithCertificate` Berechtigung für den AWS IoT Rollenalias gewähren, der auf die Token-Exchange-Rolle verweist.
Sie können eine einzige AWS IoT Richtlinie für alle Kerngeräte in Ihrer Flotte verwenden, oder Sie können Ihre Flottenbereitstellungsvorlage so konfigurieren, dass für jedes Kerngerät eine AWS IoT Richtlinie erstellt wird.
+ Eine Vorlage für die AWS IoT Flottenbereitstellung. In dieser Vorlage muss Folgendes angegeben werden:
+ AWS IoT Irgendeine Ressource. Sie können eine Liste vorhandener Dinggruppen angeben, um Komponenten für jedes Gerät bereitzustellen, wenn es online geht.
+ Eine AWS IoT Richtlinienressource. Diese Ressource kann eine der folgenden Eigenschaften definieren:
+ Der Name einer vorhandenen AWS IoT Richtlinie. Wenn Sie diese Option wählen, verwenden die Kerngeräte, die Sie anhand dieser Vorlage erstellen, dieselbe AWS IoT Richtlinie, und Sie können ihre Berechtigungen als Flotte verwalten.
+ Ein AWS IoT Richtliniendokument. Wenn Sie diese Option wählen, verwendet jedes Core-Gerät, das Sie anhand dieser Vorlage erstellen, eine eigene AWS IoT Richtlinie, und Sie können die Berechtigungen für jedes einzelne Core-Gerät verwalten.
+ Eine AWS IoT Zertifikatsressource. Diese Zertifikatsressource muss den `AWS::IoT::Certificate::Id` Parameter verwenden, um das Zertifikat an das Kerngerät anzuhängen. Weitere Informationen finden Sie im *AWS IoT Developer Guide* unter [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html).
+ Ein AWS IoT Provisioning-Anspruchszertifikat und ein privater Schlüssel für die Flottenbereitstellungsvorlage. Sie können dieses Zertifikat und den privaten Schlüssel während der Herstellung in Geräte einbetten, sodass sich die Geräte selbst registrieren und bereitstellen können, wenn sie online gehen.
**Wichtig**
Private Schlüssel für Provisioning Claim sollten jederzeit gesichert sein, auch auf Greengrass-Core-Geräten. Wir empfehlen Ihnen, anhand von CloudWatch Kennzahlen und Protokollen von Amazon nach Hinweisen auf Missbrauch zu suchen, wie z. B. die unbefugte Verwendung des Antragszertifikats zur Bereitstellung von Geräten. Wenn Sie einen Missbrauch feststellen, deaktivieren Sie das Provisioning Claim Certificate, sodass es nicht für die Bereitstellung von Geräten verwendet werden kann. Weitere Informationen finden Sie unter [Überwachung AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) im *AWS IoT Core Entwicklerhandbuch*.
Damit Sie die Anzahl der Geräte und die Geräte, die sich bei Ihnen registrieren, besser verwalten können, können Sie AWS-Konto bei der Erstellung einer Flottenbereitstellungsvorlage einen Pre-Provisioning-Hook angeben. Ein Pre-Provisioning-Hook ist eine AWS Lambda Funktion, die Vorlagenparameter validiert, die Geräte bei der Registrierung angeben. Sie können beispielsweise einen Pre-Provisioning-Hook erstellen, der eine Geräte-ID mit einer Datenbank vergleicht, um sicherzustellen, dass das Gerät über eine Bereitstellungsberechtigung verfügt. *Weitere Informationen finden Sie unter [Pre-Provisioning Hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) im Developer Guide.AWS IoT Core *
+ Eine AWS IoT Richtlinie, die Sie dem Provisioning-Antragszertifikat beifügen, damit sich Geräte registrieren und die Flottenbereitstellungsvorlage verwenden können.
**Topics**
+ [Erstellen Sie eine Token-Austauschrolle](#create-token-exchange-role)
+ [Erstellen Sie eine AWS IoT Richtlinie](#create-iot-policy)
+ [Erstellen Sie eine Vorlage für die Flottenbereitstellung](#create-provisioning-template)
+ [Erstellen Sie ein Provisioning-Anspruchszertifikat und einen privaten Schlüssel](#create-claim-certificates)
## Erstellen Sie eine Token-Austauschrolle
Greengrass-Core-Geräte verwenden eine IAM-Servicerolle, die so genannte *Token-Exchange-Rolle*, um Aufrufe von Diensten zu autorisieren. AWS Das Gerät verwendet den AWS IoT Anmeldeinformationsanbieter, um temporäre AWS Anmeldeinformationen für diese Rolle abzurufen. Dadurch kann das Gerät mit Amazon Logs interagieren AWS IoT, Protokolle an Amazon CloudWatch Logs senden und benutzerdefinierte Komponentenartefakte von Amazon S3 herunterladen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
Sie verwenden einen AWS IoT *Rollenalias*, um die Token-Austauschrolle für Greengrass-Core-Geräte zu konfigurieren. Rollenaliase ermöglichen es Ihnen, die Token-Austauschrolle für ein Gerät zu ändern, aber die Gerätekonfiguration beizubehalten. Weitere Informationen finden Sie im [*AWS IoT Core Entwicklerhandbuch* unter Autorisieren von direkten Aufrufen von AWS Diensten](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html).
In diesem Abschnitt erstellen Sie eine Token-Exchange-IAM-Rolle und einen AWS IoT Rollenalias, der auf die Rolle verweist. Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen Token-Austauschrolle und seinen Rollenalias verwenden, anstatt neue zu erstellen.
**Um eine IAM-Rolle für den Token-Austausch zu erstellen**
1. Erstellen Sie eine IAM-Rolle, die Ihr Gerät als Token-Austauschrolle verwenden kann. Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das Dokument mit der Vertrauensrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-trust-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Erstellen Sie die Token-Austauschrolle mit dem Dokument zur Vertrauensrichtlinie.
+ *GreengrassV2TokenExchangeRole*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Rolle.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Erstellen Sie eine Datei, die das Dokument mit der Zugriffsrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-access-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Anmerkung**
Diese Zugriffsrichtlinie erlaubt keinen Zugriff auf Komponentenartefakte in S3-Buckets. Um benutzerdefinierte Komponenten bereitzustellen, die Artefakte in Amazon S3 definieren, müssen Sie der Rolle Berechtigungen hinzufügen, damit Ihr Kerngerät Komponentenartefakte abrufen kann. Weitere Informationen finden Sie unter [Erlauben Sie den Zugriff auf S3-Buckets für Komponentenartefakte](device-service-role.md#device-service-role-access-s3-bucket).
Wenn Sie noch keinen S3-Bucket für Komponentenartefakte haben, können Sie diese Berechtigungen später hinzufügen, nachdem Sie einen Bucket erstellt haben.
1. Erstellen Sie die IAM-Richtlinie anhand des Richtliniendokuments.
+ *GreengrassV2TokenExchangeRoleAccess*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Richtlinie.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Hängen Sie die IAM-Richtlinie an die Token-Exchange-Rolle an.
+ Ersetzen Sie *GreengrassV2TokenExchangeRole* durch den Namen der IAM-Rolle.
+ Ersetzen Sie den Richtlinien-ARN durch den ARN der IAM-Richtlinie, die Sie im vorherigen Schritt erstellt haben.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
1. Erstellen Sie einen AWS IoT Rollenalias, der auf die Token-Exchange-Rolle verweist.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie ihn durch den Namen des Rollenalias, den Sie erstellen möchten.
+ Ersetzen Sie den Rollen-ARN durch den ARN der IAM-Rolle, die Sie im vorherigen Schritt erstellt haben.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Anmerkung**
Um einen Rollenalias zu erstellen, benötigen Sie die Berechtigung, die Token-Exchange-IAM-Rolle zu übergeben. AWS IoT Wenn Sie beim Versuch, einen Rollenalias zu erstellen, eine Fehlermeldung erhalten, überprüfen Sie, ob Ihr AWS Benutzer über diese Berechtigung verfügt. *Weitere Informationen finden Sie im [Benutzerhandbuch unter Erteilen von Benutzerberechtigungen zur Übergabe einer Rolle an einen AWS Dienst](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).AWS Identity and Access Management *
## Erstellen Sie eine AWS IoT Richtlinie
Nachdem Sie ein Gerät als Objekt registriert AWS IoT haben, kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS Dieses Zertifikat enthält eine oder mehrere AWS IoT Richtlinien, die die Berechtigungen definieren, die ein Gerät mit dem Zertifikat verwenden kann. Diese Richtlinien ermöglichen dem Gerät die Kommunikation mit AWS IoT und AWS IoT Greengrass.
Bei der AWS IoT Flottenbereitstellung stellen Geräte eine Verbindung her, AWS IoT um ein Gerätezertifikat zu erstellen und herunterzuladen. In der Flottenbereitstellungsvorlage, die Sie im nächsten Abschnitt erstellen, können Sie angeben, ob AWS IoT den Zertifikaten aller Geräte dieselbe AWS IoT Richtlinie zugewiesen wird oder ob für jedes Gerät eine neue Richtlinie erstellt wird.
In diesem Abschnitt erstellen Sie eine AWS IoT Richtlinie, die an die Zertifikate aller Geräte AWS IoT angehängt wird. Mit diesem Ansatz können Sie die Berechtigungen für alle Geräte als Flotte verwalten. Wenn Sie lieber für jedes Gerät eine neue AWS IoT Richtlinie erstellen möchten, können Sie diesen Abschnitt überspringen und bei der Definition Ihrer Flottenvorlage auf die darin enthaltene Richtlinie verweisen.
**Um eine AWS IoT Richtlinie zu erstellen**
+ Erstellen Sie eine AWS IoT Richtlinie, die die AWS IoT Berechtigungen für Ihre Flotte von Greengrass-Core-Geräten definiert. Die folgende Richtlinie ermöglicht den Zugriff auf alle MQTT-Themen und Greengrass-Operationen, sodass Ihr Gerät mit benutzerdefinierten Anwendungen und future Änderungen, die neue Greengrass-Operationen erfordern, funktioniert. Diese Richtlinie ermöglicht auch die `iot:AssumeRoleWithCertificate` Genehmigung, die es Ihren Geräten ermöglicht, die Token-Austauschrolle zu verwenden, die Sie im vorherigen Abschnitt erstellt haben. Sie können diese Richtlinie je nach 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).
Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das AWS IoT Richtliniendokument enthält, das für Greengrass-Core-Geräte erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano greengrass-v2-iot-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
+ Ersetzen Sie die `iot:AssumeRoleWithCertificate` Ressource durch den ARN des AWS IoT Rollenalias, den Sie im vorherigen Abschnitt erstellt haben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. Erstellen Sie eine AWS IoT Richtlinie aus dem Richtliniendokument.
+ *GreengrassV2IoTThingPolicy*Ersetzen Sie es durch den Namen der zu erstellenden Richtlinie.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die Anfrage erfolgreich ist.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## Erstellen Sie eine Vorlage für die Flottenbereitstellung
AWS IoT Vorlagen für die Flottenbereitstellung definieren, wie AWS IoT Dinge, Richtlinien und Zertifikate bereitgestellt werden. Um Greengrass-Kerngeräte mit dem Fleet Provisioning Plugin bereitzustellen, müssen Sie eine Vorlage erstellen, die Folgendes spezifiziert:
+ Irgendeine Ressource AWS IoT . Sie können eine Liste vorhandener Dinggruppen angeben, um Komponenten für jedes Gerät bereitzustellen, wenn es online geht.
+ Eine AWS IoT Richtlinienressource. Diese Ressource kann eine der folgenden Eigenschaften definieren:
+ Der Name einer vorhandenen AWS IoT Richtlinie. Wenn Sie diese Option wählen, verwenden die Kerngeräte, die Sie anhand dieser Vorlage erstellen, dieselbe AWS IoT Richtlinie, und Sie können ihre Berechtigungen als Flotte verwalten.
+ Ein AWS IoT Richtliniendokument. Wenn Sie diese Option wählen, verwendet jedes Core-Gerät, das Sie anhand dieser Vorlage erstellen, eine eigene AWS IoT Richtlinie, und Sie können die Berechtigungen für jedes einzelne Core-Gerät verwalten.
+ Eine AWS IoT Zertifikatsressource. Diese Zertifikatsressource muss den `AWS::IoT::Certificate::Id` Parameter verwenden, um das Zertifikat an das Kerngerät anzuhängen. Weitere Informationen finden Sie im *AWS IoT Developer Guide* unter [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html).
In der Vorlage können Sie angeben, dass das AWS IoT Ding zu einer Liste vorhandener Dinggruppen hinzugefügt werden soll. Wenn das Kerngerät AWS IoT Greengrass zum ersten Mal eine Verbindung herstellt, empfängt es Greengrass-Bereitstellungen für jede Dinggruppe, der es angehört. Sie können Dinggruppen verwenden, um die neueste Software auf jedem Gerät bereitzustellen, sobald es online ist. Weitere Informationen finden Sie unter [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md).
Für den AWS IoT Dienst sind AWS-Konto bei der Bereitstellung von Geräten Berechtigungen zum Erstellen und Aktualisieren von AWS IoT Ressourcen auf Ihrem Gerät erforderlich. Um dem AWS IoT Dienst Zugriff zu gewähren, erstellen Sie eine IAM-Rolle und geben sie bei der Erstellung der Vorlage an. AWS IoT stellt eine verwaltete Richtlinie ([AWSIoTThingsRegistrierung](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration)) bereit, die den Zugriff auf alle Berechtigungen ermöglicht, die bei der Bereitstellung von Geräten verwendet werden AWS IoT könnten. Sie können diese verwaltete Richtlinie verwenden oder eine benutzerdefinierte Richtlinie erstellen, die die Berechtigungen in der verwalteten Richtlinie für Ihren Anwendungsfall einschränkt.
In diesem Abschnitt erstellen Sie eine IAM-Rolle, die die Bereitstellung von Ressourcen für Geräte ermöglicht AWS IoT , und Sie erstellen eine Flottenbereitstellungsvorlage, die diese IAM-Rolle verwendet.
**Um eine Vorlage für die Flottenbereitstellung zu erstellen**
1. Erstellen Sie eine IAM-Rolle, die die Bereitstellung von Ressourcen in Ihrem übernehmen AWS IoT kann. AWS-Konto Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das Dokument mit der Vertrauensrichtlinie enthält, mit dem AWS IoT Sie die Rolle übernehmen können.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano aws-iot-trust-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Erstellen Sie eine IAM-Rolle mit dem Dokument zur Vertrauensrichtlinie.
+ *GreengrassFleetProvisioningRole*Ersetzen Sie sie durch den Namen der zu erstellenden IAM-Rolle.
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. Lesen Sie sich die [AWSIoTThingsRegistrierungsrichtlinie](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration) durch, die den Zugriff auf alle Berechtigungen ermöglicht, die AWS IoT möglicherweise bei der Bereitstellung von Geräten verwendet werden. Sie können diese verwaltete Richtlinie verwenden oder eine benutzerdefinierte Richtlinie erstellen, die spezifische Berechtigungen für Ihren Anwendungsfall definiert. Wenn Sie sich dafür entscheiden, eine benutzerdefinierte Richtlinie zu erstellen, tun Sie dies jetzt.
1. Fügen Sie die IAM-Richtlinie der Flottenbereitstellungsrolle hinzu.
+ Ersetzen Sie *GreengrassFleetProvisioningRole* durch den Namen der IAM-Rolle.
+ Wenn Sie im vorherigen Schritt eine benutzerdefinierte Richtlinie erstellt haben, ersetzen Sie den Richtlinien-ARN durch den ARN der zu verwendenden IAM-Richtlinie.
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
1. (Optional) Erstellen Sie einen *Pre-Provisioning-Hook*. Dabei handelt es sich um eine AWS Lambda Funktion, die Vorlagenparameter überprüft, die Geräte bei der Registrierung angeben. Sie können einen Pre-Provisioning-Hook verwenden, um mehr Kontrolle darüber zu erhalten, welche und wie viele Geräte in Ihrem Gerät integriert sind. AWS-Konto*Weitere Informationen finden Sie unter [Pre-Provisioning Hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) im Developer Guide.AWS IoT Core *
1. Erstellen Sie eine Vorlage für die Flottenbereitstellung. Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das Vorlagendokument für die Bereitstellung 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 greengrass-fleet-provisioning-template.json
```
Schreiben Sie das Provisioning-Vorlagendokument. Sie können mit der folgenden Beispielvorlage für die Bereitstellung beginnen, in der angegeben wird, dass ein Objekt mit den folgenden AWS IoT Eigenschaften erstellt werden soll:
+ Der Name der Sache ist der Wert, den Sie im `ThingName` Vorlagenparameter angeben.
+ Das Ding ist ein Mitglied der Dinggruppe, die Sie im `ThingGroupName` Vorlagenparameter angeben. Die Dinggruppe muss in Ihrer vorhanden sein AWS-Konto.
+ Dem Zertifikat der Sache ist die angegebene AWS IoT Richtlinie `GreengrassV2IoTThingPolicy` angehängt.
Weitere Informationen finden Sie unter [Bereitstellungsvorlagen](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) im *AWS IoT Core Entwicklerhandbuch*.
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**Anmerkung**
*MyThing**MyPolicy*, und *MyCertificate* sind willkürliche Namen, die jede Ressourcenspezifikation in der Flottenbereitstellungsvorlage identifizieren. AWS IoT verwendet diese Namen nicht in den Ressourcen, die es anhand der Vorlage erstellt. Sie können diese Namen verwenden oder sie durch Werte ersetzen, die Ihnen helfen, die einzelnen Ressourcen in der Vorlage zu identifizieren.
1. Erstellen Sie die Vorlage für die Flottenbereitstellung anhand des Vorlagendokuments für die Bereitstellung von Flotten.
+ Ersetzen Sie *GreengrassFleetProvisioningTemplate* durch den Namen der zu erstellenden Vorlage.
+ Ersetzen Sie die Beschreibung der Vorlage durch eine Beschreibung für Ihre Vorlage.
+ Ersetzen Sie den ARN der Bereitstellungsrolle durch den ARN der Rolle, die Sie zuvor erstellt haben.
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**Anmerkung**
Wenn Sie einen Pre-Provisioning-Hook erstellt haben, geben Sie den ARN der Lambda-Funktion des Pre-Provisioning-Hooks mit dem Argument an. `--pre-provisioning-hook`
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## Erstellen Sie ein Provisioning-Anspruchszertifikat und einen privaten Schlüssel
Anspruchszertifikate sind X.509-Zertifikate, die es Geräten ermöglichen, sich als AWS IoT Dinge zu registrieren und ein eindeutiges X.509-Gerätezertifikat abzurufen, das für den regulären Betrieb verwendet werden kann. Nachdem Sie ein Anspruchszertifikat erstellt haben, fügen Sie eine AWS IoT Richtlinie hinzu, die es Geräten ermöglicht, damit eindeutige Gerätezertifikate zu erstellen und diese mit einer Flottenbereitstellungsvorlage bereitzustellen. Geräte mit dem Antragszertifikat können nur mithilfe der Bereitstellungsvorlage bereitgestellt werden, die Sie in der AWS IoT Richtlinie zulassen.
In diesem Abschnitt erstellen Sie das Antragszertifikat und konfigurieren es für Geräte zur Verwendung mit der Flottenbereitstellungsvorlage, die Sie im vorherigen Abschnitt erstellt haben.
**Wichtig**
Private Schlüssel für Provisioning Claim sollten jederzeit gesichert sein, auch auf Greengrass-Core-Geräten. Wir empfehlen Ihnen, anhand von CloudWatch Kennzahlen und Protokollen von Amazon nach Hinweisen auf Missbrauch zu suchen, wie z. B. die unbefugte Verwendung des Antragszertifikats zur Bereitstellung von Geräten. Wenn Sie einen Missbrauch feststellen, deaktivieren Sie das Provisioning Claim Certificate, sodass es nicht für die Bereitstellung von Geräten verwendet werden kann. Weitere Informationen finden Sie unter [Überwachung AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) im *AWS IoT Core Entwicklerhandbuch*.
Damit Sie die Anzahl der Geräte und die Geräte, die sich bei Ihnen registrieren, besser verwalten können, können Sie AWS-Konto bei der Erstellung einer Flottenbereitstellungsvorlage einen Pre-Provisioning-Hook angeben. Ein Pre-Provisioning-Hook ist eine AWS Lambda Funktion, die Vorlagenparameter validiert, die Geräte bei der Registrierung angeben. Sie können beispielsweise einen Pre-Provisioning-Hook erstellen, der eine Geräte-ID mit einer Datenbank vergleicht, um sicherzustellen, dass das Gerät über eine Bereitstellungsberechtigung verfügt. *Weitere Informationen finden Sie unter [Pre-Provisioning Hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) im Developer Guide.AWS IoT Core *
**Um ein Provisioning zu erstellen, beanspruchen Sie ein Zertifikat und einen privaten Schlüssel**
1. Erstellen Sie einen Ordner, in den Sie das Anspruchszertifikat und den privaten Schlüssel herunterladen.
```
mkdir claim-certs
```
1. Erstellen und speichern Sie ein Zertifikat und einen privaten Schlüssel, um sie für die Bereitstellung zu verwenden. AWS IoT stellt Client-Zertifikate bereit, die von der Amazon Root Certificate Authority (CA) signiert wurden.
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
Die Antwort enthält Informationen über das Zertifikat, falls die Anfrage erfolgreich ist. Speichern Sie den ARN des Zertifikats, um ihn später zu verwenden.
1. Erstellen und fügen Sie eine AWS IoT Richtlinie hinzu, die es Geräten ermöglicht, das Zertifikat zu verwenden, um eindeutige Gerätezertifikate zu erstellen und diese mit der Flottenbereitstellungsvorlage bereitzustellen. Die folgende Richtlinie ermöglicht den Zugriff auf die MQTT-API zur Gerätebereitstellung. *Weitere Informationen finden Sie unter [MQTT-API zur Gerätebereitstellung](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html) im Entwicklerhandbuch.AWS IoT Core *
Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das AWS IoT Richtliniendokument enthält, das für Greengrass-Core-Geräte erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano greengrass-provisioning-claim-iot-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
+ Ersetzen Sie jede Instanz von *region* durch die Instanz, für AWS-Region die Sie die Flottenbereitstellung eingerichtet haben.
+ Ersetzen Sie jede Instanz von *account-id* durch Ihre AWS-Konto ID.
+ Ersetzen Sie jede Instanz von *GreengrassFleetProvisioningTemplate* durch den Namen der Flottenbereitstellungsvorlage, die Sie im vorherigen Abschnitt erstellt haben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. Erstellen Sie eine AWS IoT Richtlinie anhand des Richtliniendokuments.
+ *GreengrassProvisioningClaimPolicy*Ersetzen Sie es durch den Namen der zu erstellenden Richtlinie.
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die Anfrage erfolgreich ist.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. Fügen Sie die AWS IoT Richtlinie dem Provisioning Claim Certificate bei.
+ *GreengrassProvisioningClaimPolicy*Ersetzen Sie es durch den Namen der Richtlinie, die angehängt werden soll.
+ Ersetzen Sie den Ziel-ARN durch den ARN des Provisioning-Anspruchszertifikats.
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
Sie verfügen jetzt über ein Provisioning-Anspruchszertifikat und einen privaten Schlüssel, mit denen sich Geräte registrieren AWS IoT und sich selbst als Greengrass-Core-Geräte bereitstellen können. Sie können das Antragszertifikat und den privaten Schlüssel während der Herstellung in Geräte einbetten oder das Zertifikat und den Schlüssel auf die Geräte kopieren, bevor Sie die AWS IoT Greengrass Core-Software installieren. Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software mit AWS IoT Flottenbereitstellung](fleet-provisioning.md).
# Konfigurieren Sie das AWS IoT Flottenbereitstellungs-Plugin
Das AWS IoT Fleet Provisioning Plugin bietet die folgenden Konfigurationsparameter, die Sie anpassen können, wenn Sie die [AWS IoT Greengrass Core-Software mit Fleet Provisioning installieren](fleet-provisioning.md).
`rootPath`
Der Pfad zu dem Ordner, der als Stammverzeichnis für die AWS IoT Greengrass Core-Software verwendet werden soll.
`awsRegion`
Der AWS-Region , den das Fleet Provisioning-Plugin zur Bereitstellung von AWS Ressourcen verwendet.
`iotDataEndpoint`
Der AWS IoT Datenendpunkt für Ihren AWS-Konto.
`iotCredentialEndpoint`
Der Endpunkt der AWS IoT Anmeldeinformationen für Ihren AWS-Konto.
`iotRoleAlias`
Der AWS IoT Rollenalias, der auf eine Token-Exchange-IAM-Rolle verweist. Der Anbieter AWS IoT für Anmeldeinformationen übernimmt diese Rolle, damit das Greengrass-Core-Gerät mit AWS Diensten interagieren kann. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
`provisioningTemplate`
Die Vorlage für die AWS IoT Flottenbereitstellung, die für die Bereitstellung AWS von Ressourcen verwendet werden soll. In dieser Vorlage muss Folgendes angegeben werden:
+ AWS IoT Irgendeine Ressource. Sie können eine Liste vorhandener Dinggruppen angeben, um Komponenten für jedes Gerät bereitzustellen, wenn es online geht.
+ Eine AWS IoT Richtlinienressource. Diese Ressource kann eine der folgenden Eigenschaften definieren:
+ Der Name einer vorhandenen AWS IoT Richtlinie. Wenn Sie diese Option wählen, verwenden die Kerngeräte, die Sie anhand dieser Vorlage erstellen, dieselbe AWS IoT Richtlinie, und Sie können ihre Berechtigungen als Flotte verwalten.
+ Ein AWS IoT Richtliniendokument. Wenn Sie diese Option wählen, verwendet jedes Core-Gerät, das Sie anhand dieser Vorlage erstellen, eine eigene AWS IoT Richtlinie, und Sie können die Berechtigungen für jedes einzelne Core-Gerät verwalten.
+ Eine AWS IoT Zertifikatsressource. Diese Zertifikatsressource muss den `AWS::IoT::Certificate::Id` Parameter verwenden, um das Zertifikat an das Kerngerät anzuhängen. Weitere Informationen finden Sie im *AWS IoT Developer Guide* unter [Just-in-time Provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html).
Weitere Informationen finden Sie im *AWS IoT Core Developer* [Guide unter Provisioning Templates](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html).
`claimCertificatePath`
Der Pfad zum Provisioning-Anspruchszertifikat für die Bereitstellungsvorlage, das Sie unter angeben. `provisioningTemplate` Weitere Informationen finden Sie unter [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) in der *AWS IoT Core -API-Referenz*.
`claimCertificatePrivateKeyPath`
Der Pfad zum privaten Schlüssel des Provisioning-Anspruchszertifikats für die Bereitstellungsvorlage, die Sie in angeben. `provisioningTemplate` Weitere Informationen finden Sie unter [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) in der *AWS IoT Core -API-Referenz*.
Private Schlüssel für Provisioning Claim sollten jederzeit gesichert sein, auch auf Greengrass-Core-Geräten. Wir empfehlen Ihnen, anhand von CloudWatch Kennzahlen und Protokollen von Amazon nach Hinweisen auf Missbrauch zu suchen, wie z. B. die unbefugte Verwendung des Antragszertifikats zur Bereitstellung von Geräten. Wenn Sie einen Missbrauch feststellen, deaktivieren Sie das Provisioning Claim Certificate, sodass es nicht für die Bereitstellung von Geräten verwendet werden kann. Weitere Informationen finden Sie unter [Überwachung AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) im *AWS IoT Core Entwicklerhandbuch*.
Damit Sie die Anzahl der Geräte und die Geräte, die sich bei Ihnen registrieren, besser verwalten können, können Sie AWS-Konto bei der Erstellung einer Flottenbereitstellungsvorlage einen Pre-Provisioning-Hook angeben. Ein Pre-Provisioning-Hook ist eine AWS Lambda Funktion, die Vorlagenparameter validiert, die Geräte bei der Registrierung angeben. Sie können beispielsweise einen Pre-Provisioning-Hook erstellen, der eine Geräte-ID mit einer Datenbank vergleicht, um sicherzustellen, dass das Gerät über eine Bereitstellungsberechtigung verfügt. *Weitere Informationen finden Sie unter [Pre-Provisioning Hooks](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) im Developer Guide.AWS IoT Core *
`rootCaPath`
Der Pfad zum Zertifikat der Amazon Root Certificate Authority (CA).
`templateParameters`
(Optional) Die Zuordnung der Parameter, die der Flottenbereitstellungsvorlage zur Verfügung gestellt werden sollen. *Weitere Informationen finden Sie im [Abschnitt mit den Parametern für Bereitstellungsvorlagen im AWS IoT Core Entwicklerhandbuch](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section).*
`deviceId`
(Optional) Die Geräte-ID, die als Client-ID verwendet werden soll, wenn das Fleet Provisioning-Plugin eine MQTT-Verbindung herstellt. AWS IoT
Standard: Eine zufällige UUID.
`mqttPort`
(Optional) Der Port, der für MQTT-Verbindungen verwendet werden soll.
Standard: `8883`
`proxyUrl`
(Optional) Die URL des Proxyservers im Format`scheme://userinfo@host:port`. Um einen HTTPS-Proxy zu verwenden, müssen Sie Version 1.1.0 oder höher des Fleet Provisioning-Plug-ins verwenden.
+ `scheme`— Das Schema, das oder sein muss. `http` `https`
**Wichtig**
Greengrass-Core-Geräte müssen [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 oder höher ausführen, um HTTPS-Proxys verwenden zu können.
Wenn Sie einen HTTPS-Proxy konfigurieren, müssen Sie das Proxy-Server-CA-Zertifikat zum Amazon-Root-CA-Zertifikat des Kerngeräts hinzufügen. Weitere Informationen finden Sie unter [Ermöglichen Sie dem Kerngerät, einem HTTPS-Proxy zu vertrauen](configure-greengrass-core-v2.md#https-proxy-certificate-trust).
+ `userinfo`— (Optional) Der Benutzername und das Passwort. Wenn Sie diese Informationen in der angeben`url`, ignoriert das Greengrass-Core-Gerät die Felder `username` und`password`.
+ `host`— Der Hostname oder die IP-Adresse des Proxyservers.
+ `port`— (Optional) Die Portnummer. Wenn Sie den Port nicht angeben, verwendet das Greengrass-Core-Gerät die folgenden Standardwerte:
+ `http`— 80
+ `https`— 443
`proxyUserName`
(Optional) Der Benutzername, der den Proxyserver authentifiziert.
`proxyPassword`
(Optional) Der Benutzername, der den Proxyserver authentifiziert.
CSRPath
(Optional) Der Pfad zur CSR-Datei (Certificate Signing Request), die verwendet werden soll, um das Gerätezertifikat aus einer CSR zu erstellen. *Weitere Informationen finden Sie im [Entwicklerhandbuch unter Provisioning by Claim](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) AWS IoT Core .*
csrPrivateKeyPfad
(Optional, erforderlich, falls `csrPath` deklariert) Der Pfad zu dem privaten Schlüssel, der zur Generierung der CSR verwendet wurde. Der private Schlüssel muss zur Generierung der CSR verwendet worden sein. Weitere Informationen finden Sie im [*AWS IoT Core Entwicklerhandbuch* unter Provisioning by Claim](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based).
Pfad des Zertifikats
(Optional) Der Pfad, der zum Speichern des heruntergeladenen Gerätezertifikats verwendet werden soll.
privateKeyPath
(Optional) Der Pfad, der zum Speichern des heruntergeladenen privaten Geräteschlüssels verwendet werden soll.
# AWS IoT Changelog des Plug-ins für die Flottenbereitstellung
In der folgenden Tabelle werden die Änderungen in den einzelnen Versionen des Plug-ins AWS IoT Fleet Provisioning by Claim (`aws.greengrass.FleetProvisioningByClaim`) beschrieben.
| Version | Änderungen |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | Erste Version |
# Installieren Sie die AWS IoT Greengrass Core-Software mit benutzerdefinierter Ressourcenbereitstellung
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
Das AWS IoT Greengrass Core-Softwareinstallationsprogramm bietet eine Java-Schnittstelle, die Sie in einem benutzerdefinierten Plugin implementieren können, das die erforderlichen Ressourcen bereitstellt. AWS Sie können ein Provisioning-Plugin entwickeln, um benutzerdefinierte X.509-Clientzertifikate zu verwenden oder komplexe Bereitstellungsschritte auszuführen, die andere Installationsprozesse nicht unterstützen. *Weitere Informationen finden Sie im Entwicklerhandbuch unter [Erstellen eigener Client-Zertifikate](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html).AWS IoT Core *
Um bei der Installation der AWS IoT Greengrass Core-Software ein benutzerdefiniertes Provisioning-Plugin auszuführen, erstellen Sie eine JAR-Datei, die Sie dem Installationsprogramm zur Verfügung stellen. Das Installationsprogramm führt das Plugin aus und das Plugin gibt eine Bereitstellungskonfiguration zurück, die die AWS Ressourcen für das Greengrass-Core-Gerät definiert. Das Installationsprogramm verwendet diese Informationen, um die AWS IoT Greengrass Core-Software auf dem Gerät zu konfigurieren. Weitere Informationen finden Sie unter [Entwickeln Sie benutzerdefinierte Provisioning-Plugins](develop-custom-provisioning-plugins.md).
**Wichtig**
Bevor Sie die AWS IoT Greengrass Core-Software herunterladen, überprüfen Sie, ob Ihr Core-Gerät die [Anforderungen](greengrass-nucleus-component.md#greengrass-v2-requirements) für die Installation und Ausführung der AWS IoT Greengrass Core-Software v2.0 erfüllt.
**Topics**
+ [Voraussetzungen](#custom-provisioning-prerequisites)
+ [Richten Sie die Geräteumgebung ein](#set-up-device-environment)
+ [Laden Sie die AWS IoT Greengrass Core-Software herunter](#download-greengrass-core-v2)
+ [Installieren Sie die Core-Software AWS IoT Greengrass](#run-greengrass-core-v2-installer-custom)
+ [Entwickeln Sie benutzerdefinierte Provisioning-Plugins](develop-custom-provisioning-plugins.md)
## Voraussetzungen
Um die AWS IoT Greengrass Core-Software mit benutzerdefinierter Bereitstellung zu installieren, müssen Sie über Folgendes verfügen:
+ Eine JAR-Datei für ein benutzerdefiniertes Provisioning-Plugin, das das implementiert. `DeviceIdentityInterface` Das benutzerdefinierte Provisioning-Plugin muss Werte für jeden System- und Nucleus-Konfigurationsparameter zurückgeben. Andernfalls müssen Sie diese Werte während der Installation in der Konfigurationsdatei angeben. Weitere Informationen finden Sie unter [Entwickeln Sie benutzerdefinierte Provisioning-Plugins](develop-custom-provisioning-plugins.md).
## Richten Sie die Geräteumgebung ein
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 ein
**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 (in der Regel`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
**Anmerkung**
Diese Funktion ist für Version 2.5.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
**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
## Laden Sie die AWS IoT Greengrass Core-Software herunter
Sie können die neueste Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**Anmerkung**
Sie können eine bestimmte Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen. Ersetzen Sie es *version* durch die Version, die Sie herunterladen möchten.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Um die AWS IoT Greengrass Core-Software herunterzuladen**
1. Laden Sie die Core-Software auf Ihrem AWS IoT Greengrass Core-Gerät in eine Datei mit dem Namen herunter`greengrass-nucleus-latest.zip`.
------
#### [ 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. (Optional) Um die Greengrass Nucleus-Softwaresignatur zu überprüfen
**Anmerkung**
Diese Funktion ist mit Greengrass Nucleus Version 2.9.5 und höher verfügbar.
1. Verwenden Sie den folgenden Befehl, um die Signatur Ihres Greengrass-Kernartefakts zu überprüfen:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
Der Dateiname kann je nach installierter JDK-Version anders aussehen. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
Der Dateiname sieht je nach installierter JDK-Version möglicherweise anders aus. Ersetzen Sie es *`jdk17.0.6_10`* durch die JDK-Version, die Sie installiert haben.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. Der `jarsigner` Aufruf liefert eine Ausgabe, die die Ergebnisse der Überprüfung angibt.
1. Wenn die Greengrass Nucleus-Zip-Datei signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar verified.
```
1. Wenn die Greengrass Nucleus-Zip-Datei nicht signiert ist, enthält die Ausgabe die folgende Anweisung:
```
jar is unsigned.
```
1. Wenn Sie die `-certs` Option Jarsigner zusammen mit den `-verbose` Optionen `-verify` und angegeben haben, enthält die Ausgabe auch detaillierte Informationen zum Unterzeichnerzertifikat.
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. (Optional) Führen Sie den folgenden Befehl aus, um die Version der AWS IoT Greengrass Core-Software zu sehen.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Wichtig**
Wenn Sie eine Version von Greengrass Nucleus vor v2.4.0 installieren, entfernen Sie diesen Ordner nicht, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben. Die AWS IoT Greengrass Core-Software verwendet die Dateien in diesem Ordner zur Ausführung.
Wenn Sie die neueste Version der Software heruntergeladen haben, installieren Sie v2.4.0 oder höher, und Sie können diesen Ordner entfernen, nachdem Sie die AWS IoT Greengrass Core-Software installiert haben.
## Installieren Sie die Core-Software AWS IoT Greengrass
Führen Sie das Installationsprogramm mit Argumenten aus, die die folgenden Aktionen angeben:
+ Installieren Sie aus einer Teilkonfigurationsdatei, in der angegeben ist, dass Sie Ihr benutzerdefiniertes Provisioning-Plugin für die Bereitstellung von AWS Ressourcen verwenden möchten. Die AWS IoT Greengrass Core-Software verwendet eine Konfigurationsdatei, die die Konfiguration jeder Greengrass-Komponente auf dem Gerät spezifiziert. Das Installationsprogramm erstellt eine vollständige Konfigurationsdatei aus der Teilkonfigurationsdatei, die Sie bereitstellen, und den AWS Ressourcen, die das benutzerdefinierte Provisioning-Plugin erstellt.
+ Geben Sie an, dass der `ggc_user` Systembenutzer Softwarekomponenten auf dem Kerngerät ausführen 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.
+ 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.
Weitere Hinweise zu den Argumenten, die Sie angeben können, finden Sie unter[Argumente des Installers](configure-installer.md).
**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).
**So installieren Sie die AWS IoT Greengrass Core-Software (Linux)**
1. Überprüfen Sie die Version der AWS IoT Greengrass Core-Software.
+ *GreengrassInstaller*Ersetzen Sie durch den Pfad zu dem Ordner, der die Software enthält.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `config.yaml` zu erstellen, die dem Installationsprogramm zur Verfügung gestellt werden soll.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano GreengrassInstaller/config.yaml
```
Kopieren Sie den folgenden YAML-Inhalt in die Datei.
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
Führen Sie dann die folgenden Schritte aus:
+ *2.16.1*Ersetzen Sie es durch die Version der AWS IoT Greengrass Core-Software.
+ Ersetzen Sie jede Instanz von `/greengrass/v2` durch den Greengrass-Stammordner.
+ (Optional) Geben Sie System- und Nucleus-Konfigurationswerte an. Sie müssen diese Werte festlegen, wenn Ihr Provisioning-Plugin sie nicht bereitstellt.
+ (Optional) Geben Sie die Konfigurationsparameter an, die für Ihr Provisioning-Plugin bereitgestellt werden sollen.
**Anmerkung**
In dieser Konfigurationsdatei können Sie weitere Konfigurationsoptionen anpassen, z. B. die zu verwendenden Ports und den Netzwerk-Proxy, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter [Greengrass Nucleus-Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. Führen Sie das Installationsprogramm aus. Geben Sie `--trusted-plugin` an, ob Sie Ihr benutzerdefiniertes Provisioning-Plugin bereitstellen möchten, und geben Sie `--init-config` an, dass Sie die Konfigurationsdatei bereitstellen möchten.
**Anmerkung**
Windows hat eine Pfadlängenbegrenzung von 260 Zeichen. Wenn Sie Windows verwenden, verwenden Sie einen Stammordner wie `C:\greengrass\v2` oder, `D:\greengrass\v2` um die Greengrass-Komponentenpfade unter der Obergrenze von 260 Zeichen zu halten.
+ Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Greengrass-Stammordner.
+ Ersetzen Sie jede Instanz von *GreengrassInstaller* durch den Ordner, in den Sie das Installationsprogramm entpackt haben.
+ Ersetzen Sie den Pfad zur JAR-Datei des benutzerdefinierten Provisioning-Plugins durch den Pfad zur JAR-Datei Ihres Plugins.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Wichtig**
Auf Windows Core-Geräten müssen Sie angeben, `--setup-system-service true` dass die AWS IoT Greengrass Core-Software als Systemdienst eingerichtet werden soll.
Wenn Sie dies angeben`--setup-system-service true`, gibt das Installationsprogramm aus, `Successfully set up Nucleus as a system service` ob es die Software als Systemdienst eingerichtet und ausgeführt hat. Andernfalls gibt das Installationsprogramm keine Meldung aus, wenn es die Software erfolgreich installiert hat.
**Anmerkung**
Sie können das `deploy-dev-tools` Argument nicht verwenden, um lokale Entwicklungstools bereitzustellen, wenn Sie das Installationsprogramm ohne das `--provision true` Argument ausführen. Informationen zur direkten Bereitstellung der Greengrass-CLI auf Ihrem Gerät finden Sie unter[Greengrass-Befehlszeilenschnittstelle](gg-cli.md).
1. Überprüfen Sie die Installation, indem Sie sich die Dateien im Stammordner ansehen.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Wenn die Installation erfolgreich war, enthält der Stammordner mehrere Ordner, z. B. `config``packages`, und`logs`.
Wenn Sie die AWS IoT Greengrass Core-Software als Systemdienst installiert haben, führt das Installationsprogramm die Software für Sie aus. Andernfalls müssen Sie die Software manuell ausführen. Weitere Informationen finden Sie unter [Führen Sie die AWS IoT Greengrass Core-Software aus](run-greengrass-core-v2.md).
Weitere Informationen zur Konfiguration und Verwendung der Software finden Sie unter: AWS IoT Greengrass
+ [Konfiguration der AWS IoT Greengrass Core-Software](configure-greengrass-core-v2.md)
+ [AWS IoT Greengrass Komponenten entwickeln](develop-greengrass-components.md)
+ [AWS IoT Greengrass Komponenten auf Geräten bereitstellen](manage-deployments.md)
+ [Greengrass-Befehlszeilenschnittstelle](gg-cli.md)
# Entwickeln Sie benutzerdefinierte Provisioning-Plugins
Um ein benutzerdefiniertes Provisioning-Plugin zu entwickeln, erstellen Sie eine Java-Klasse, die die Schnittstelle implementiert. `com.aws.greengrass.provisioning.DeviceIdentityInterface` Sie können die Greengrass Nucleus-JAR-Datei in Ihr Projekt aufnehmen, um auf diese Schnittstelle und ihre Klassen zuzugreifen. Diese Schnittstelle definiert eine Methode, die eine Plugin-Konfiguration eingibt und eine Provisioning-Konfiguration ausgibt. Die Provisioning-Konfiguration definiert Konfigurationen für das System und die [Greengrass Nucleus-Komponente](greengrass-nucleus-component.md). Das AWS IoT Greengrass Core-Softwareinstallationsprogramm verwendet diese Bereitstellungskonfiguration, um die AWS IoT Greengrass Core-Software auf einem Gerät zu konfigurieren.
Nachdem Sie ein benutzerdefiniertes Provisioning-Plugin entwickelt haben, erstellen Sie es als JAR-Datei, die Sie dem AWS IoT Greengrass Core-Softwareinstaller zur Verfügung stellen können, um Ihr Plugin während der Installation auszuführen. Das Installationsprogramm führt Ihr benutzerdefiniertes Provisioning-Plugin in derselben JVM aus, die das Installationsprogramm verwendet, sodass Sie eine JAR erstellen können, die nur Ihren Plugin-Code enthält.
**Anmerkung**
Das [AWS IoT Fleet-Provisioning-Plugin implementiert die Option, Fleet Provisioning](fleet-provisioning.md) während der Installation `DeviceIdentityInterface` zu verwenden. Das Fleet Provisioning-Plugin ist Open Source, sodass Sie den Quellcode untersuchen können, um ein Beispiel für die Verwendung der Provisioning-Plug-in-Schnittstelle zu sehen. Weitere Informationen finden Sie im [AWS IoT Fleet Provisioning Plugin](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) unter. GitHub
**Topics**
+ [Voraussetzungen](#custom-provisioning-plugin-requirements)
+ [Implementieren Sie die DeviceIdentityInterface Schnittstelle](#implement-device-identity-interface)
## Voraussetzungen
Um ein benutzerdefiniertes Provisioning-Plugin zu entwickeln, müssen Sie eine Java-Klasse erstellen, die die folgenden Anforderungen erfüllt:
+ Verwendet das `com.aws.greengrass` Paket oder ein Paket innerhalb des `com.aws.greengrass` Pakets.
+ Hat einen Konstruktor ohne Argumente.
+ Implementiert die `DeviceIdentityInterface` Schnittstelle. Weitere Informationen finden Sie unter [Implementieren Sie die DeviceIdentityInterface Schnittstelle](#implement-device-identity-interface).
## Implementieren Sie die DeviceIdentityInterface Schnittstelle
Um die `com.aws.greengrass.provisioning.DeviceIdentityInterface` Schnittstelle in Ihrem benutzerdefinierten Plugin zu verwenden, fügen Sie den Greengrass-Kern als Abhängigkeit zu Ihrem Projekt hinzu.
**Um das DeviceIdentityInterface in einem benutzerdefinierten Provisioning-Plugin-Projekt zu verwenden**
+ Sie können die Greengrass Nucleus JAR-Datei als Bibliothek oder den Greengrass Nucleus als Maven-Abhängigkeit hinzufügen. Führen Sie eine der folgenden Aktionen aus:
+ Um die Greengrass Nucleus JAR-Datei als Bibliothek hinzuzufügen, laden Sie die AWS IoT Greengrass Core-Software herunter, die die Greengrass Nucleus-JAR enthält. Sie können die neueste Version der AWS IoT Greengrass Core-Software von der folgenden Adresse herunterladen:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
Sie finden die Greengrass Nucleus-JAR-Datei (`Greengrass.jar`) im `lib` Ordner in der ZIP-Datei. Fügen Sie diese JAR-Datei zu Ihrem Projekt hinzu.
+ Um den Greengrass-Kern in einem Maven-Projekt zu konsumieren, fügen Sie eine Abhängigkeit vom `nucleus` Artefakt in der Gruppe hinzu. `com.aws.greengrass` Sie müssen auch das `greengrass-common` Repository hinzufügen, da der Greengrass-Kern nicht im Maven Central Repository verfügbar ist.
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### Die Schnittstelle DeviceIdentityInterface
Die `com.aws.greengrass.provisioning.DeviceIdentityInterface` Schnittstelle hat die folgende Form.
**Anmerkung**
[Sie können diese Klassen auch im [com.aws.greengrass.provisioning Paket des Greengrass Nucleus-Quellcodes unter](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning) erkunden.](https://github.com/aws-greengrass/aws-greengrass-nucleus) GitHub
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
Jeder Konfigurationswert in `SystemConfiguration` und `NucleusConfiguration` ist für die Installation der Core-Software erforderlich, Sie können jedoch zurückkehren. AWS IoT Greengrass `null` Wenn Ihr benutzerdefiniertes Provisioning-Plug-in `null` für einen beliebigen Konfigurationswert zurückgegeben wird, müssen Sie diesen Wert in der System- oder Nucleus-Konfiguration angeben, wenn Sie die `config.yaml` Datei für das AWS IoT Greengrass Core-Software-Installationsprogramm erstellen. Wenn Ihr benutzerdefiniertes Provisioning-Plugin für eine Option, in der Sie auch definiert haben, einen Wert ungleich Null zurückgibt`config.yaml`, ersetzt das Installationsprogramm den Wert in `config.yaml` durch den vom Plugin zurückgegebenen Wert.
# Argumente des Installers
Die AWS IoT Greengrass Core-Software umfasst ein Installationsprogramm, das die Software einrichtet und die erforderlichen AWS Ressourcen bereitstellt, damit das Greengrass-Core-Gerät ausgeführt werden kann. Das Installationsprogramm enthält die folgenden Argumente, die Sie zur Konfiguration der Installation angeben können:
`-h`, `--help`
(Optional) Zeigt die Hilfeinformationen des Installationsprogramms an.
`--version`
(Optional) Zeigt die Version der AWS IoT Greengrass Core-Software an.
`-Droot`
(Optional) Der Pfad zu dem Ordner, der als Stammverzeichnis für die AWS IoT Greengrass Core-Software verwendet werden soll.
Dieses Argument legt eine JVM-Eigenschaft fest, sodass Sie sie zuvor angeben müssen, `-jar` wenn Sie das Installationsprogramm ausführen. Geben Sie beispielsweise `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar` an.
Standard:
+ Linux: `~/.greengrass`
+ Windows: `%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
Die AWS-Region , die AWS IoT Greengrass Core-Software verwendet, um die erforderlichen AWS Ressourcen abzurufen oder zu erstellen.
`-p`, `--provision`
(Optional) Sie können dieses Gerät als Objekt registrieren AWS IoT und die AWS Ressourcen bereitstellen, die das Kerngerät benötigt. Wenn Sie angeben`true`, stellt die AWS IoT Greengrass Core-Software ein AWS IoT Ding, (optional) eine AWS IoT Dinggruppe, eine IAM-Rolle und einen AWS IoT Rollenalias bereit.
Standard: `false`
`-tn`, `--thing-name`
(Optional) Der Name der AWS IoT Sache, die Sie als dieses Kerngerät registrieren. Wenn das Ding mit dem Namen in Ihrem nicht existiert AWS-Konto, wird es von der AWS IoT Greengrass Core-Software erstellt.
Der Dingname darf keine Doppelpunkte (`:`) enthalten.
Sie müssen angeben`--provision true`, ob dieses Argument angewendet werden soll.
Standard: `GreengrassV2IotThing_` plus eine zufällige UUID.
`-tgn`, `--thing-group-name`
(Optional) Der Name der Dinggruppe AWS IoT , der Sie das Ding dieses Kerngeräts hinzufügen. AWS IoT Wenn eine Bereitstellung auf diese Dinggruppe abzielt, empfängt dieses Kerngerät diese Bereitstellung, wenn es eine Verbindung herstellt AWS IoT Greengrass. Wenn die Dinggruppe mit diesem Namen in Ihrer nicht existiert AWS-Konto, wird sie von der AWS IoT Greengrass Core-Software erstellt.
Der Name der Dinggruppe darf keine Doppelpunkte (`:`) enthalten.
Sie müssen angeben`--provision true`, ob dieses Argument angewendet werden soll.
`-tpn`, `--thing-policy-name`
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
(Optional) Der Name der AWS IoT Richtlinie, die an das Ding-Zertifikat dieses Kerngeräts angehängt werden soll. AWS IoT Wenn die AWS IoT Richtlinie mit diesem Namen in Ihrem nicht vorhanden ist AWS-Konto, wird sie von der AWS IoT Greengrass Core-Software erstellt.
Die AWS IoT Greengrass Core-Software erstellt standardmäßig eine permissive AWS IoT Richtlinie. Sie können den Geltungsbereich dieser Richtlinie einschränken oder eine benutzerdefinierte Richtlinie erstellen, mit der Sie die Berechtigungen 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).
Sie müssen angeben`--provision true`, ob dieses Argument angewendet werden soll.
Standard: `GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
(Optional) Der Name der IAM-Rolle, die zum Abrufen von AWS Anmeldeinformationen verwendet werden soll, mit denen das Kerngerät mit AWS Diensten interagieren kann. Wenn die Rolle mit diesem Namen in Ihrer nicht vorhanden ist AWS-Konto, erstellt die AWS IoT Greengrass Core-Software sie anhand der `GreengrassV2TokenExchangeRoleAccess` Richtlinie. Diese Rolle hat keinen Zugriff auf Ihre S3-Buckets, in denen Sie Komponentenartefakte hosten. Daher müssen Sie den S3-Buckets und Objekten Ihrer Artefakte Berechtigungen hinzufügen, wenn Sie eine Komponente erstellen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
Sie müssen angeben, ob dieses Argument angewendet `--provision true` werden soll.
Standard: `GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
(Optional) Der Name des AWS IoT Rollenalias, der auf die IAM-Rolle verweist, die AWS Anmeldeinformationen für dieses Kerngerät bereitstellt. Wenn der Rollenalias mit diesem Namen in Ihrem nicht vorhanden ist AWS-Konto, erstellt ihn die AWS IoT Greengrass Core-Software und verweist ihn auf die von Ihnen angegebene IAM-Rolle.
Sie müssen angeben`--provision true`, ob dieses Argument angewendet werden soll.
Standard: `GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
(Optional) Sie können die AWS IoT Greengrass Core-Software als Systemdienst einrichten, der ausgeführt wird, wenn das Gerät gestartet wird. Der Name des Systemdienstes lautet`greengrass`. Weitere Informationen finden Sie unter [Den Greengrass Nucleus als Systemdienst konfigurieren](configure-greengrass-core-v2.md#configure-system-service).
Auf Linux-Betriebssystemen setzt dieses Argument voraus, dass das Systemd-Init-System auf dem Gerät verfügbar ist.
Auf Windows Core-Geräten müssen Sie die AWS IoT Greengrass Core-Software als Systemdienst einrichten.
Standard: `false`
`-u`, `--component-default-user`
Der Name oder die ID des Benutzers, den die AWS IoT Greengrass Core-Software zum Ausführen von Komponenten verwendet. Sie können beispielsweise **ggc\$1user** angeben. Dieser Wert ist erforderlich, wenn Sie das Installationsprogramm auf Windows-Betriebssystemen ausführen.
Auf Linux-Betriebssystemen können Sie die Gruppe auch optional angeben. Geben Sie den Benutzer und die Gruppe durch einen Doppelpunkt getrennt an. Beispiel, **ggc\$1user:ggc\$1group**.
Die folgenden zusätzlichen Überlegungen gelten für Linux-Betriebssysteme:
+ Wenn Sie als Root ausführen, ist der Standardbenutzer der Komponente der Benutzer, der in der Konfigurationsdatei definiert ist. Wenn die Konfigurationsdatei keinen Benutzer definiert, ist dies standardmäßig. `ggc_user:ggc_group` Wenn sie existieren `ggc_user` oder `ggc_group` nicht, erstellt die Software sie.
+ Wenn Sie die Software als Nicht-Root-Benutzer ausführen, verwendet die AWS IoT Greengrass Core-Software diesen Benutzer, um Komponenten auszuführen.
+ Wenn Sie keine Gruppe angeben, verwendet die AWS IoT Greengrass Core-Software die primäre Gruppe des Systembenutzers.
Weitere Informationen finden Sie unter [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](configure-greengrass-core-v2.md#configure-component-user).
`-d`, `--deploy-dev-tools`
(Optional) Sie können die [Greengrass CLI-Komponente](greengrass-cli-component.md) herunterladen und auf diesem Core-Gerät bereitstellen. Sie können dieses Tool verwenden, um Komponenten auf diesem Kerngerät zu entwickeln und zu debuggen.
Wir empfehlen, diese Komponente nur in Entwicklungsumgebungen und nicht in Produktionsumgebungen zu verwenden. Diese Komponente bietet Zugriff auf Informationen und Operationen, die Sie in einer Produktionsumgebung normalerweise nicht benötigen. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie diese Komponente nur dort einsetzen, wo Sie sie benötigen.
Sie müssen angeben`--provision true`, ob dieses Argument angewendet werden soll.
Standard: `false`
`-init`, `--init-config`
(Optional) Der Pfad zur Konfigurationsdatei, die zur Installation der AWS IoT Greengrass Core-Software verwendet werden soll. Sie können diese Option verwenden, um beispielsweise neue Core-Geräte mit einer bestimmten Nucleus-Konfiguration einzurichten.
Die von Ihnen angegebene Konfigurationsdatei wird mit der vorhandenen Konfigurationsdatei auf dem Core-Gerät zusammengeführt. Dazu gehören die Komponenten und Komponentenkonfigurationen auf dem Kerngerät. Wir empfehlen, dass in der Konfigurationsdatei nur die Konfigurationen aufgeführt sind, die Sie ändern möchten.
`-tp`, `--trusted-plugin`
(Optional) Der Pfad zu einer JAR-Datei, die als vertrauenswürdiges Plugin geladen werden soll. Verwenden Sie diese Option, um JAR-Dateien für das Provisioning-Plugin bereitzustellen, z. B. für die Installation mit [Flottenbereitstellung](fleet-provisioning.md) oder [benutzerdefinierter Bereitstellung](custom-provisioning.md) oder für die Installation mit dem privaten Schlüssel und dem Zertifikat in einem [Hardwaresicherheitsmodul](hardware-security.md).
`-s`, `--start`
(Optional) Sie können die AWS IoT Greengrass Core-Software nach der Installation starten und optional Ressourcen bereitstellen.
Standard: `true`
# Führen Sie die AWS IoT Greengrass Core-Software aus
Nachdem Sie [die AWS IoT Greengrass Core-Software installiert](install-greengrass-core-v2.md) haben, führen Sie sie aus, um Ihr Gerät damit zu verbinden AWS IoT Greengrass.
Wenn Sie die AWS IoT Greengrass Core-Software installieren, können Sie angeben, ob sie als Systemdienst mit [systemd](https://en.wikipedia.org/wiki/Systemd) installiert werden soll. Wenn Sie diese Option wählen, führt das Installationsprogramm die Software für Sie aus und konfiguriert sie so, dass sie beim Booten Ihres Geräts ausgeführt wird.
**Wichtig**
Auf Windows Core-Geräten müssen Sie die AWS IoT Greengrass Core-Software als Systemdienst einrichten.
**Topics**
+ [Überprüfen Sie, ob die AWS IoT Greengrass Core-Software als Systemdienst ausgeführt wird](#check-system-service)
+ [Führen Sie die AWS IoT Greengrass Core-Software als Systemdienst aus](#run-greengrass-core-system-service)
+ [Führen Sie die AWS IoT Greengrass Core-Software ohne Systemdienst aus](#run-greengrass-core-no-system-service)
## Überprüfen Sie, ob die AWS IoT Greengrass Core-Software als Systemdienst ausgeführt wird
Wenn Sie die AWS IoT Greengrass Core-Software installieren, können Sie das `--setup-system-service true` Argument angeben, um die AWS IoT Greengrass Core-Software als Systemdienst zu installieren. Linux-Geräte benötigen das [Systemd-Init-System](https://en.wikipedia.org/wiki/Systemd), um die AWS IoT Greengrass Core-Software als Systemdienst einzurichten. Wenn Sie diese Option verwenden, führt das Installationsprogramm die Software für Sie aus und konfiguriert sie so, dass sie beim Booten Ihres Geräts ausgeführt wird. Das Installationsprogramm gibt die folgende Meldung aus, wenn es die AWS IoT Greengrass Core-Software erfolgreich als Systemdienst installiert hat.
```
Successfully set up Nucleus as a system service
```
Wenn Sie die AWS IoT Greengrass Core-Software bereits installiert haben und die Installationsausgabe nicht verfügbar ist, können Sie überprüfen, ob die Software als Systemdienst installiert wurde.
**Um zu überprüfen, ob die AWS IoT Greengrass Core-Software als Systemdienst installiert ist**
+ Führen Sie den folgenden Befehl aus, um den Status des Greengrass-Systemdienstes zu überprüfen.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die AWS IoT Greengrass Core-Software als Systemdienst installiert und aktiv ist.
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
Wenn `systemctl` oder `greengrass.service` nicht gefunden wird, ist die AWS IoT Greengrass Core-Software nicht als Systemdienst installiert. Informationen zum Ausführen der Software finden Sie unter[Führen Sie die AWS IoT Greengrass Core-Software ohne Systemdienst aus](#run-greengrass-core-no-system-service).
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die AWS IoT Greengrass Core-Software als Windows-Dienst installiert und aktiv ist.
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
Die Antwort ähnelt dem folgenden Beispiel, wenn die AWS IoT Greengrass Core-Software als Windows-Dienst installiert und aktiv ist.
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## Führen Sie die AWS IoT Greengrass Core-Software als Systemdienst aus
Wenn die AWS IoT Greengrass Core-Software als Systemdienst installiert ist, können Sie den Systemdienstmanager verwenden, um die Software zu starten, zu beenden und zu verwalten. Weitere Informationen finden Sie unter [Den Greengrass Nucleus als Systemdienst konfigurieren](configure-greengrass-core-v2.md#configure-system-service).
**Um die AWS IoT Greengrass Core-Software auszuführen**
+ Führen Sie den folgenden Befehl aus, um die AWS IoT Greengrass Core-Software zu starten.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## Führen Sie die AWS IoT Greengrass Core-Software ohne Systemdienst aus
Wenn die Core-Software auf AWS IoT Greengrass Linux-Core-Geräten nicht als Systemdienst installiert ist, können Sie das Loader-Skript der Software ausführen, um die Software auszuführen.
**Um die AWS IoT Greengrass Core-Software ohne Systemdienst auszuführen**
+ Führen Sie den folgenden Befehl aus, um die AWS IoT Greengrass Core-Software zu starten. Wenn Sie diesen Befehl in einem Terminal ausführen, müssen Sie die Terminalsitzung geöffnet lassen, damit die AWS IoT Greengrass Core-Software weiterläuft.
+ Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Greengrass-Stammordner, den Sie verwenden.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
Die Software druckt die folgende Meldung, wenn sie erfolgreich gestartet wurde.
```
Launched Nucleus successfully.
```
# Führen Sie die AWS IoT Greengrass Core-Software in einem Docker-Container aus
AWS IoT Greengrass kann für die Ausführung in einem Docker-Container konfiguriert werden. Docker ist eine Plattform, die Ihnen die Tools zum Erstellen, Ausführen, Testen und Bereitstellen von Anwendungen zur Verfügung stellt, die auf Linux-Containern basieren. Wenn Sie ein AWS IoT Greengrass Docker-Image ausführen, können Sie wählen, ob Sie Ihre AWS Anmeldeinformationen für den Docker-Container angeben und dem AWS IoT Greengrass Core-Softwareinstaller erlauben möchten, automatisch die AWS Ressourcen bereitzustellen, die ein Greengrass-Core-Gerät für den Betrieb benötigt. Wenn Sie keine AWS Anmeldeinformationen angeben möchten, können Sie AWS Ressourcen manuell bereitstellen und die AWS IoT Greengrass Core-Software im Docker-Container ausführen.
**Topics**
+ [Unterstützte Plattformen und Anforderungen](#greengrass-docker-supported-platforms)
+ [Software wird heruntergeladen](#greengrass-docker-downloads)
+ [Wählen Sie aus, wie Ressourcen bereitgestellt werden AWS](#greengrass-docker-resource-provisioning)
+ [Erstellen Sie das AWS IoT Greengrass Image aus einem Dockerfile](build-greengrass-dockerfile.md)
+ [AWS IoT Greengrass In Docker mit automatischer Bereitstellung ausführen](run-greengrass-docker-automatic-provisioning.md)
+ [AWS IoT Greengrass In Docker mit manueller Bereitstellung ausführen](run-greengrass-docker-manual-provisioning.md)
+ [Fehlerbehebung AWS IoT Greengrass in einem Docker-Container](docker-troubleshooting.md)
## Unterstützte Plattformen und Anforderungen
Hostcomputer müssen die folgenden Mindestanforderungen erfüllen, um die AWS IoT Greengrass Core-Software in einem Docker-Container zu installieren und auszuführen:
+ Ein Linux-basiertes Betriebssystem mit einer Internetverbindung.
+ [Docker Engine](https://docs.docker.com/engine/install/) Version 18.09 oder höher.
+ (Optional) [Docker Compose](https://docs.docker.com/compose/install/) Version 1.22 oder höher. Docker Compose ist nur erforderlich, wenn Sie die Docker Compose-CLI zum Ausführen Ihrer Docker-Images verwenden möchten.
Um Lambda-Funktionskomponenten innerhalb des Docker-Containers auszuführen, müssen Sie den Container so konfigurieren, dass er zusätzliche Anforderungen erfüllt. Weitere Informationen finden Sie unter [Anforderungen an die Lambda-Funktion](setting-up.md#greengrass-v2-lambda-requirements).
### Komponenten im Prozessmodus ausführen
AWS IoT Greengrass unterstützt nicht die Ausführung von Lambda-Funktionen oder AWS-bereitgestellten Komponenten in einer isolierten Laufzeitumgebung innerhalb des AWS IoT Greengrass Docker-Containers. Sie müssen diese Komponenten im Prozessmodus ohne jegliche Isolierung ausführen.
Wenn Sie eine Lambda-Funktionskomponente konfigurieren, setzen Sie den Isolationsmodus auf **Kein Container**. Weitere Informationen finden Sie unter [AWS Lambda Funktionen ausführen](run-lambda-functions.md).
Wenn Sie eine der folgenden Komponenten AWS bereitstellen, aktualisieren Sie die Konfiguration für jede Komponente, auf die der `containerMode` Parameter gesetzt werden soll. `NoContainer` Weitere Informationen zu Konfigurationsupdates finden Sie unter[Komponentenkonfigurationen aktualisieren](update-component-configurations.md).
+ [CloudWatch Metriken](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Modbus-RTU-Protokolladapter](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass Docker-Software wird heruntergeladen
AWS IoT Greengrass stellt ein Dockerfile bereit, um ein Container-Image zu erstellen, auf dem AWS IoT Greengrass Core-Software und Abhängigkeiten auf einem Amazon Linux 2 (x86\$164) -Basis-Image installiert sind. Sie können das Basis-Image im Dockerfile so ändern, dass es auf einer anderen Plattformarchitektur ausgeführt wird. AWS IoT Greengrass
Laden Sie das Dockerfile-Paket von herunter. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker)
Das Dockerfile verwendet eine ältere Version von Greengrass. Sie sollten die Datei aktualisieren, um die gewünschte Version von Greengrass zu verwenden. Informationen zum Erstellen des AWS IoT Greengrass Container-Images aus dem Dockerfile finden Sie unter. [Erstellen Sie das AWS IoT Greengrass Container-Image aus einem Dockerfile](build-greengrass-dockerfile.md)
## Wählen Sie aus, wie Ressourcen bereitgestellt werden AWS
Wenn Sie die AWS IoT Greengrass Core-Software in einem Docker-Container installieren, können Sie wählen, ob Sie die AWS Ressourcen, die ein Greengrass-Core-Gerät für den Betrieb benötigt, automatisch bereitstellen oder Ressourcen verwenden möchten, die Sie manuell bereitstellen.
+ **Automatische Ressourcenbereitstellung** — Das Installationsprogramm stellt das AWS IoT AWS IoT Ding, die Dinggruppe, die AWS IoT IAM-Rolle und den Rollenalias bereit, wenn Sie das AWS IoT Greengrass Container-Image zum ersten Mal ausführen. Das Installationsprogramm kann auch die lokalen Entwicklungstools auf dem Kerngerät bereitstellen, sodass Sie das Gerät verwenden können, um benutzerdefinierte Softwarekomponenten zu entwickeln und zu testen. Um diese Ressourcen automatisch bereitzustellen, müssen Sie AWS Anmeldeinformationen als Umgebungsvariablen für das Docker-Image angeben.
Um die automatische Bereitstellung zu verwenden, müssen Sie die Docker-Umgebungsvariable festlegen `PROVISION=true` und eine Anmeldeinformationsdatei bereitstellen, um Ihre AWS Anmeldeinformationen für den Container bereitzustellen.
+ **Manuelle Ressourcenbereitstellung** — Wenn Sie keine AWS Anmeldeinformationen für den Container bereitstellen möchten, können Sie die AWS Ressourcen manuell bereitstellen, bevor Sie das Container-Image ausführen. AWS IoT Greengrass Sie müssen eine Konfigurationsdatei erstellen, um Informationen zu diesen Ressourcen für das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container bereitzustellen.
Um die manuelle Bereitstellung zu verwenden, müssen Sie die Docker-Umgebungsvariable festlegen. `PROVISION=false` Manuelles Provisioning ist die Standardoption.
Weitere Informationen finden Sie unter [Erstellen Sie das AWS IoT Greengrass Container-Image aus einem Dockerfile](build-greengrass-dockerfile.md).
# Erstellen Sie das AWS IoT Greengrass Container-Image aus einem Dockerfile
AWS stellt ein Dockerfile bereit, das Sie herunterladen und verwenden können, um die AWS IoT Greengrass Core-Software in einem Docker-Container auszuführen. Dockerfiles enthalten Quellcode zum Erstellen von Container-Images. AWS IoT Greengrass
Bevor Sie ein AWS IoT Greengrass Container-Image erstellen, müssen Sie Ihr Dockerfile so konfigurieren, dass es die Version der AWS IoT Greengrass Core-Software auswählt, die Sie installieren möchten. Sie können auch Umgebungsvariablen konfigurieren, um festzulegen, wie Ressourcen während der Installation bereitgestellt werden, und andere Installationsoptionen anpassen. In diesem Abschnitt wird beschrieben, wie Sie ein AWS IoT Greengrass Docker-Image aus einer Docker-Datei konfigurieren und erstellen.
## Laden Sie das Dockerfile-Paket herunter
Sie können das AWS IoT Greengrass Dockerfile-Paket herunterladen von: GitHub
[AWS Greengrass Docker-Repository](https://github.com/aws-greengrass/aws-greengrass-docker)
Nachdem Sie das Paket heruntergeladen haben, extrahieren Sie den Inhalt in den `download-directory/aws-greengrass-docker-nucleus-version` Ordner auf Ihrem Computer. Das Dockerfile verwendet eine ältere Version von Greengrass. Sie sollten die Datei aktualisieren, um die gewünschte Version von Greengrass zu verwenden.
## Geben Sie die AWS IoT Greengrass Core-Softwareversion an
Verwenden Sie das folgende Build-Argument in der Docker-Datei, um die Version der AWS IoT Greengrass Core-Software anzugeben, die Sie im AWS IoT Greengrass Docker-Image verwenden möchten. Standardmäßig verwendet das Dockerfile die neueste Version der Core-Software. AWS IoT Greengrass
`GREENGRASS_RELEASE_VERSION`
Die Version der AWS IoT Greengrass Core-Software. Standardmäßig lädt das Dockerfile die neueste verfügbare Version des Greengrass-Nukleus herunter. Stellen Sie den Wert auf die Version des Nucleus ein, den Sie herunterladen möchten.
## Festlegen von Umgebungsvariablen
Mit Umgebungsvariablen können Sie anpassen, wie die AWS IoT Greengrass Core-Software im Docker-Container installiert wird. Sie können Umgebungsvariablen für Ihr AWS IoT Greengrass Docker-Image auf verschiedene Arten festlegen.
+ Um dieselben Umgebungsvariablen zum Erstellen mehrerer Images zu verwenden, legen Sie Umgebungsvariablen direkt im Dockerfile fest.
+ Wenn Sie Ihren Container `docker run` zum Starten verwenden, übergeben Sie Umgebungsvariablen als Argumente im Befehl oder legen Sie Umgebungsvariablen in einer Umgebungsvariablendatei fest und übergeben Sie dann die Datei als Argument. Weitere Informationen zum Setzen von Umgebungsvariablen in Docker finden Sie in den [Umgebungsvariablen](https://docs.docker.com/engine/reference/commandline/run/#env) in der Docker-Dokumentation.
+ Wenn Sie Ihren Container `docker-compose up` zum Starten verwenden, legen Sie Umgebungsvariablen in einer Umgebungsvariablendatei fest und übergeben Sie die Datei dann als Argument. Weitere Informationen zum Setzen von Umgebungsvariablen in Compose finden Sie in der [Docker-Dokumentation](https://docs.docker.com/compose/environment-variables/).
Sie können die folgenden Umgebungsvariablen für das AWS IoT Greengrass Docker-Image konfigurieren.
**Anmerkung**
Ändern Sie die `TINI_KILL_PROCESS_GROUP` Variable im Dockerfile nicht. Diese Variable ermöglicht die Weiterleitung `SIGTERM` PIDs an alle Mitglieder der PID-Gruppe, sodass die AWS IoT Greengrass Core-Software korrekt heruntergefahren werden kann, wenn der Docker-Container gestoppt wird.
`GGC_ROOT_PATH`
(Optional) Der Pfad zu dem Ordner innerhalb des Containers, der als Stammverzeichnis für die AWS IoT Greengrass Core-Software verwendet werden soll.
Standard: `/greengrass/v2`
`PROVISION`
(Optional) Legt fest, ob der AWS IoT Greengrass Core AWS Ressourcen bereitstellt.
+ Wenn Sie dies angeben`true`, registriert die AWS IoT Greengrass Core-Software das Container-Image als eine AWS IoT Sache und stellt die AWS Ressourcen bereit, die das Greengrass-Core-Gerät benötigt. Die AWS IoT Greengrass Core-Software stellt ein AWS IoT Ding, (optional) eine AWS IoT Dinggruppe, eine IAM-Rolle und einen AWS IoT Rollenalias bereit. Weitere Informationen finden Sie unter [AWS IoT Greengrass In einem Docker-Container mit automatischer Ressourcenbereitstellung ausführen](run-greengrass-docker-automatic-provisioning.md).
+ Wenn Sie dies angeben`false`, müssen Sie eine Konfigurationsdatei erstellen, die Sie dem AWS IoT Greengrass Core-Installationsprogramm zur Verfügung stellen, in der angegeben ist, dass die AWS Ressourcen und Zertifikate verwendet werden sollen, die Sie manuell erstellt haben. Weitere Informationen finden Sie unter [AWS IoT Greengrass In einem Docker-Container mit manueller Ressourcenbereitstellung ausführen](run-greengrass-docker-manual-provisioning.md).
Standard: `false`
`AWS_REGION`
(Optional) Die AWS-Region , die die AWS IoT Greengrass Core-Software verwendet, um die erforderlichen AWS Ressourcen abzurufen oder zu erstellen.
Standard: `us-east-1`.
`THING_NAME`
(Optional) Der Name des Geräts AWS IoT , das Sie als dieses Core-Gerät registrieren. Wenn das Ding mit diesem Namen in Ihrem nicht existiert AWS-Konto, wird es von der AWS IoT Greengrass Core-Software erstellt.
Sie müssen angeben`PROVISION=true`, ob dieses Argument angewendet werden soll.
Standard: `GreengrassV2IotThing_` plus eine zufällige UUID.
`THING_GROUP_NAME`
(Optional) Der Name der Dinggruppe AWS IoT , der Sie dieses Kerngerät hinzufügen. AWS IoT Wenn eine Bereitstellung auf diese Dinggruppe abzielt, erhalten dieses und andere Kerngeräte in dieser Gruppe diese Bereitstellung, wenn eine Verbindung hergestellt wird. AWS IoT Greengrass Wenn die Dinggruppe mit diesem Namen in Ihrer nicht existiert AWS-Konto, wird sie von der AWS IoT Greengrass Core-Software erstellt.
Sie müssen angeben`PROVISION=true`, ob dieses Argument angewendet werden soll.
`TES_ROLE_NAME`
(Optional) Der Name der IAM-Rolle, die zum Abrufen von AWS Anmeldeinformationen verwendet werden soll, die es dem Greengrass-Core-Gerät ermöglichen, mit AWS Diensten zu interagieren. Wenn die Rolle mit diesem Namen in Ihrer nicht vorhanden ist AWS-Konto, erstellt die AWS IoT Greengrass Core-Software sie anhand der `GreengrassV2TokenExchangeRoleAccess` Richtlinie. Diese Rolle hat keinen Zugriff auf Ihre S3-Buckets, in denen Sie Komponentenartefakte hosten. Daher müssen Sie den S3-Buckets und Objekten Ihrer Artefakte Berechtigungen hinzufügen, wenn Sie eine Komponente erstellen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
Standard: `GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
(Optional) Der Name des AWS IoT Rollenalias, der auf die IAM-Rolle verweist, die AWS Anmeldeinformationen für das Greengrass-Core-Gerät bereitstellt. Wenn der Rollenalias mit diesem Namen in Ihrem nicht vorhanden ist AWS-Konto, erstellt ihn die AWS IoT Greengrass Core-Software und verweist ihn auf die von Ihnen angegebene IAM-Rolle.
Standard: `GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
(Optional) Der Name oder die ID des Systembenutzers und der Gruppe, die die AWS IoT Greengrass Core-Software zum Ausführen von Komponenten verwendet. Geben Sie den Benutzer und die Gruppe an, getrennt durch einen Doppelpunkt. Die Gruppe ist optional. Sie können beispielsweise **ggc\$1user:ggc\$1group** oder **ggc\$1user** angeben.
+ Wenn Sie als Root ausführen, werden standardmäßig der Benutzer und die Gruppe verwendet, die in der Konfigurationsdatei definiert sind. Wenn die Konfigurationsdatei keinen Benutzer und keine Gruppe definiert, ist dies standardmäßig. `ggc_user:ggc_group` Wenn sie existieren `ggc_user` oder `ggc_group` nicht, erstellt die Software sie.
+ Wenn Sie die Software als Nicht-Root-Benutzer ausführen, verwendet die AWS IoT Greengrass Core-Software diesen Benutzer, um Komponenten auszuführen.
+ Wenn Sie keine Gruppe angeben, verwendet die AWS IoT Greengrass Core-Software die primäre Gruppe des Systembenutzers.
Weitere Informationen finden Sie unter [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](configure-greengrass-core-v2.md#configure-component-user).
`DEPLOY_DEV_TOOLS`
Definiert, ob die [Greengrass-CLI-Komponente](greengrass-cli-component.md) im Container-Image heruntergeladen und bereitgestellt werden soll. Sie können die Greengrass-CLI verwenden, um Komponenten lokal zu entwickeln und zu debuggen.
Wir empfehlen, diese Komponente nur in Entwicklungsumgebungen zu verwenden, nicht in Produktionsumgebungen. Diese Komponente bietet Zugriff auf Informationen und Operationen, die Sie in einer Produktionsumgebung normalerweise nicht benötigen. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie diese Komponente nur dort einsetzen, wo Sie sie benötigen.
Standard: `false`
`INIT_CONFIG`
(Optional) Der Pfad zur Konfigurationsdatei, die für die Installation der AWS IoT Greengrass Core-Software verwendet werden soll. Sie können diese Option verwenden, um beispielsweise neue Greengrass Core-Geräte mit einer bestimmten Nucleus-Konfiguration einzurichten oder um manuell bereitgestellte Ressourcen anzugeben. Sie müssen Ihre Konfigurationsdatei in den Pfad einhängen, den Sie in diesem Argument angeben.
`TRUSTED_PLUGIN`
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
(Optional) Der Pfad zu einer JAR-Datei, die als vertrauenswürdiges Plugin geladen werden soll. Verwenden Sie diese Option, um JAR-Dateien für das Provisioning-Plugin bereitzustellen, z. B. um sie zusammen mit der [Flottenbereitstellung oder der [benutzerdefinierten](custom-provisioning.md) Bereitstellung](fleet-provisioning.md) zu installieren.
`THING_POLICY_NAME`
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar.
(Optional) Der Name der AWS IoT Richtlinie, die an das Ding-Zertifikat dieses Kerngeräts angehängt werden soll. AWS IoT Wenn die AWS IoT Richtlinie mit diesem Namen in Ihrem System nicht vorhanden ist, wird sie von AWS-Konto der AWS IoT Greengrass Core-Software erstellt.
Sie müssen angeben`PROVISION=true`, ob dieses Argument angewendet werden soll.
Die AWS IoT Greengrass Core-Software erstellt standardmäßig eine permissive AWS IoT Richtlinie. Sie können den Geltungsbereich dieser Richtlinie einschränken oder eine benutzerdefinierte Richtlinie erstellen, mit der Sie die Berechtigungen 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).
## Geben Sie die zu installierenden Abhängigkeiten an
Die RUN-Anweisung im AWS IoT Greengrass Dockerfile bereitet die Containerumgebung für die Ausführung des AWS IoT Greengrass Core-Softwareinstallers vor. Sie können die Abhängigkeiten anpassen, die installiert werden, bevor das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container ausgeführt wird.
## Erstellen Sie das Image AWS IoT Greengrass
Verwenden Sie das AWS IoT Greengrass Dockerfile, um ein AWS IoT Greengrass Container-Image zu erstellen. Sie können die Docker-CLI oder die Docker Compose-CLI verwenden, um das Image zu erstellen und den Container zu starten. Sie können das Image auch mit der Docker-CLI erstellen und dann Docker Compose verwenden, um Ihren Container von diesem Image aus zu starten.
------
#### [ Docker ]
1. Führen Sie auf dem Host-Computer den folgenden Befehl aus, um zu dem Verzeichnis zu wechseln, das das konfigurierte Dockerfile enthält.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Führen Sie den folgenden Befehl aus, um das AWS IoT Greengrass Container-Image aus dem Dockerfile zu erstellen.
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. Führen Sie auf dem Hostcomputer den folgenden Befehl aus, um zu dem Verzeichnis zu wechseln, das die Dockerfile- und die Compose-Datei enthält.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Führen Sie den folgenden Befehl aus, um die Compose-Datei zum Erstellen des AWS IoT Greengrass Container-Images zu verwenden.
```
docker-compose -f docker-compose.yml build
```
------
Sie haben das AWS IoT Greengrass Container-Image erfolgreich erstellt. Auf dem Docker-Image ist die AWS IoT Greengrass Core-Software installiert. Sie können die AWS IoT Greengrass Core-Software jetzt in einem Docker-Container ausführen.
# AWS IoT Greengrass In einem Docker-Container mit automatischer Ressourcenbereitstellung ausführen
Dieses Tutorial zeigt Ihnen, wie Sie die AWS IoT Greengrass Core-Software in einem Docker-Container mit automatisch bereitgestellten AWS Ressourcen und lokalen Entwicklungstools installieren und ausführen. Sie können diese Entwicklungsumgebung verwenden, um AWS IoT Greengrass Funktionen in einem Docker-Container zu erkunden. Die Software benötigt AWS Anmeldeinformationen, um diese Ressourcen bereitzustellen und die lokalen Entwicklungstools bereitzustellen.
Wenn Sie keine AWS Anmeldeinformationen für den Container angeben können, können Sie die AWS Ressourcen bereitstellen, die das Kerngerät für den Betrieb benötigt. Sie können die Entwicklungstools auch auf einem Kerngerät bereitstellen, um es als Entwicklungsgerät zu verwenden. Auf diese Weise können Sie dem Gerät weniger Berechtigungen gewähren, wenn Sie den Container ausführen. Weitere Informationen finden Sie unter [AWS IoT Greengrass In einem Docker-Container mit manueller Ressourcenbereitstellung ausführen](run-greengrass-docker-manual-provisioning.md).
## Voraussetzungen
Um dieses Tutorial abzuschließen, benötigen Sie Folgendes.
+ 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 IAM-Benutzer mit Berechtigungen zur Bereitstellung der AWS IoT und der IAM-Ressourcen für ein Greengrass-Core-Gerät. Das AWS IoT Greengrass Core-Softwareinstallationsprogramm verwendet Ihre AWS Anmeldeinformationen, um diese Ressourcen automatisch bereitzustellen. Informationen zur IAM-Mindestrichtlinie für die automatische Bereitstellung von Ressourcen finden Sie unter[Minimale IAM-Richtlinie für das Installationsprogramm zur Bereitstellung von Ressourcen](provision-minimal-iam-policy.md).
+ Ein AWS IoT Greengrass Docker-Image. Sie können [ein Image aus dem AWS IoT Greengrass Dockerfile erstellen](build-greengrass-dockerfile.md).
+ Der Host-Computer, auf dem Sie den Docker-Container ausführen, muss die folgenden Anforderungen erfüllen:
+ Ein Linux-basiertes Betriebssystem mit einer Internetverbindung.
+ [Docker Engine](https://docs.docker.com/engine/install/) Version 18.09 oder höher.
+ (Optional) [Docker Compose](https://docs.docker.com/compose/install/) Version 1.22 oder höher. Docker Compose ist nur erforderlich, wenn Sie die Docker Compose-CLI zum Ausführen Ihrer Docker-Images verwenden möchten.
## Konfigurieren Sie Ihre Anmeldedaten AWS
In diesem Schritt erstellen Sie eine Anmeldeinformationsdatei auf dem Host-Computer, die Ihre AWS Sicherheitsanmeldeinformationen enthält. Wenn Sie das AWS IoT Greengrass Docker-Image ausführen, müssen Sie den Ordner, der diese Anmeldeinformationsdatei enthält, `/root/.aws/` im Docker-Container bereitstellen. Das AWS IoT Greengrass Installationsprogramm verwendet diese Anmeldeinformationen, um Ressourcen in Ihrem bereitzustellen. AWS-Konto Informationen zu den minimalen IAM-Richtlinien, die das Installationsprogramm für die automatische Bereitstellung von Ressourcen benötigt, finden Sie unter[Minimale IAM-Richtlinie für das Installationsprogramm zur Bereitstellung von Ressourcen](provision-minimal-iam-policy.md).
1. Rufen Sie eine der folgenden Optionen ab.
+ Langfristige Anmeldeinformationen für einen IAM-Benutzer. 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*.
+ (Empfohlen) Temporäre Anmeldeinformationen für eine IAM-Rolle. Informationen zum Abrufen temporärer Anmeldeinformationen finden Sie unter [Verwenden temporärer Sicherheitsanmeldedaten mit dem AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli) im *IAM-Benutzerhandbuch*.
1. Erstellen Sie einen Ordner, in dem Sie Ihre Anmeldeinformationsdatei ablegen.
```
mkdir ./greengrass-v2-credentials
```
1. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `credentials` des `./greengrass-v2-credentials` Ordners zu erstellen.
Sie können beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen der `credentials` Datei zu verwenden.
```
nano ./greengrass-v2-credentials/credentials
```
1. Fügen Sie der `credentials` Datei Ihre AWS Anmeldeinformationen im folgenden Format hinzu.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
Nur `aws_session_token` für temporäre Anmeldeinformationen einbeziehen.
**Wichtig**
Entfernen Sie die Anmeldeinformationsdatei vom Host-Computer, nachdem Sie den AWS IoT Greengrass Container gestartet haben. Wenn Sie die Anmeldeinformationsdatei nicht entfernen, bleiben Ihre AWS Anmeldeinformationen im Container gespeichert. Weitere Informationen finden Sie unter [Führen Sie die AWS IoT Greengrass Core-Software in einem Container aus](#run-greengrass-image-automatic-provisioning).
## Erstellen Sie eine Umgebungsdatei
In diesem Tutorial werden mithilfe einer Umgebungsdatei die Umgebungsvariablen festgelegt, die an das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container übergeben werden. Sie können auch [das `--env` Argument `-e` oder](https://docs.docker.com/engine/reference/commandline/run/#env) in Ihrem `docker run` Befehl verwenden, um Umgebungsvariablen im Docker-Container festzulegen, oder Sie können die Variablen in [einem `environment` Block](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) in der `docker-compose.yml` Datei festlegen.
1. Verwenden Sie einen Texteditor, um eine Umgebungsdatei mit dem Namen `.env` zu erstellen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um mithilfe von GNU Nano die Datei `.env` im aktuellen Verzeichnis zu erstellen.
```
nano .env
```
1. Kopieren Sie den folgenden Inhalt in die Datei.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
Ersetzen Sie dann die folgenden Werte.
+ `/greengrass/v2`. Der Greengrass-Stammordner, den Sie für die Installation verwenden möchten. Sie verwenden die `GGC_ROOT` Umgebungsvariable, um diesen Wert festzulegen.
+ *region*. Der AWS-Region Ort, an dem Sie die Ressourcen erstellt haben.
+ *MyGreengrassCore*. Der Name der AWS IoT Sache. 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.
+ *MyGreengrassCoreGroup*. Der Name der AWS IoT Dinggruppe. 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.
+ *GreengrassV2TokenExchangeRole*. Ersetzen Sie durch den Namen der IAM-Token-Austauschrolle, 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 eine Richtlinie mit dem Namen Access und fügt sie an. *GreengrassV2TokenExchangeRole* Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
+ *GreengrassCoreTokenExchangeRoleAlias*. Der Alias der Token-Exchange-Rolle. Wenn der Rollenalias nicht existiert, erstellt ihn das Installationsprogramm und verweist ihn auf die von Ihnen angegebene IAM-Token-Exchange-Rolle. Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).
**Anmerkung**
Sie können die `DEPLOY_DEV_TOOLS` Umgebungsvariable auf setzen, `true` um die [Greengrass-CLI-Komponente](greengrass-cli-component.md) bereitzustellen, mit der Sie benutzerdefinierte Komponenten innerhalb des Docker-Containers entwickeln können. Wir empfehlen, diese Komponente nur in Entwicklungsumgebungen zu verwenden, nicht in Produktionsumgebungen. Diese Komponente bietet Zugriff auf Informationen und Operationen, die Sie in einer Produktionsumgebung normalerweise nicht benötigen. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie diese Komponente nur dort einsetzen, wo Sie sie benötigen.
## Führen Sie die AWS IoT Greengrass Core-Software in einem Container aus
Dieses Tutorial zeigt Ihnen, wie Sie das Docker-Image starten, das Sie in einem Docker-Container erstellt haben. Sie können die Docker-CLI oder die Docker Compose-CLI verwenden, um das AWS IoT Greengrass Core-Software-Image in einem Docker-Container auszuführen.
------
#### [ Docker ]
1. Führen Sie den folgenden Befehl aus, um den Docker-Container zu starten.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Dieser Beispielbefehl verwendet die folgenden Argumente für [docker run](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Reinigt den Behälter, wenn er austritt.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Verwendet einen Init-Prozess im Container.
**Anmerkung**
Das `--init` Argument ist erforderlich, um die AWS IoT Greengrass Core-Software herunterzufahren, wenn Sie den Docker-Container beenden.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Optional) Führt den Docker-Container im Vordergrund als interaktiven Prozess aus. Sie können dies durch das `-d` Argument ersetzen, den Docker-Container stattdessen im getrennten Modus auszuführen. Weitere Informationen finden Sie unter [Separated vs Foreground](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) in der Docker-Dokumentation.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Führt einen Container mit dem Namen aus `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Hängt ein Volume in den Docker-Container ein, um die Konfigurationsdatei und die Zertifikatsdateien für die AWS IoT Greengrass Ausführung innerhalb des Containers verfügbar zu machen.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Optional) Gibt die Umgebungsdatei an, um die Umgebungsvariablen festzulegen, die an das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container übergeben werden. Dieses Argument ist nur erforderlich, wenn Sie eine [Umgebungsdatei](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) zum Setzen von Umgebungsvariablen erstellt haben. Wenn Sie keine Umgebungsdatei erstellt haben, können Sie `--env` Argumente verwenden, um Umgebungsvariablen direkt in Ihrem Docker-Run-Befehl festzulegen.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Optional) Veröffentlicht den 8883-Container-Port auf dem Host-Computer. Dieses Argument ist erforderlich, wenn Sie eine Verbindung herstellen und über MQTT kommunizieren möchten, da Port 8883 für MQTT-Verkehr AWS IoT Greengrass verwendet wird. Verwenden Sie zusätzliche Argumente, um andere Ports zu öffnen. `-p`
**Anmerkung**
Um Ihren Docker-Container mit erhöhter Sicherheit auszuführen, können Sie die `--cap-add` Argumente `--cap-drop` und verwenden, um Linux-Funktionen für Ihren Container selektiv zu aktivieren. Weitere Informationen finden Sie in der [Docker-Dokumentation unter Runtime-Rechte und Linux-Funktionen](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities).
1. Entfernen Sie die Anmeldeinformationen `./greengrass-v2-credentials` vom Host-Gerät.
```
rm -rf ./greengrass-v2-credentials
```
**Wichtig**
Sie entfernen diese Anmeldeinformationen, da sie umfassende Berechtigungen bieten, die das Kerngerät nur während der Einrichtung benötigt. Wenn Sie diese Anmeldeinformationen nicht entfernen, können Greengrass-Komponenten und andere Prozesse, die im Container ausgeführt werden, darauf zugreifen. Wenn Sie AWS Anmeldeinformationen für eine Greengrass-Komponente angeben müssen, verwenden Sie den Token-Austauschdienst. Weitere Informationen finden Sie unter [Interagieren Sie mit AWS Diensten](interact-with-aws-services.md).
------
#### [ Docker Compose ]
1. Verwenden Sie einen Texteditor, um eine Docker Compose-Datei mit dem Namen zu erstellen. `docker-compose.yml`
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um mithilfe von GNU Nano die Datei `docker-compose.yml` im aktuellen Verzeichnis zu erstellen.
```
nano docker-compose.yml
```
**Anmerkung**
Sie können auch die neueste Version der AWS bereitgestellten Compose-Datei von herunterladen und verwenden. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Fügen Sie der Compose-Datei den folgenden Inhalt hinzu. Die Datei sollte ähnlich wie im folgenden Beispiel aussehen. *docker-image*Ersetzen Sie es durch den Namen Ihres Docker-Images.
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
Die folgenden Parameter in dieser Compose-Beispieldatei sind optional:
+ `ports`— Veröffentlicht die 8883 Container-Ports auf dem Host-Computer. Dieser Parameter ist erforderlich, wenn Sie eine Verbindung herstellen und über MQTT kommunizieren möchten, da Port 8883 für MQTT-Verkehr AWS IoT Greengrass verwendet wird.
+ `env_file`— Gibt die Umgebungsdatei an, um die Umgebungsvariablen festzulegen, die an das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container übergeben werden. Dieser Parameter ist nur erforderlich, wenn Sie eine [Umgebungsdatei zum Setzen von Umgebungsvariablen](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) erstellt haben. Wenn Sie keine Umgebungsdatei erstellt haben, können Sie den [Umgebungsparameter](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) verwenden, um die Variablen direkt in Ihrer Compose-Datei festzulegen.
**Anmerkung**
Um Ihren Docker-Container mit erhöhter Sicherheit auszuführen, können Sie `cap_drop` und `cap_add` in Ihrer Compose-Datei verwenden, um selektiv Linux-Funktionen für Ihren Container zu aktivieren. Weitere Informationen finden Sie unter [Runtime-Rechte und Linux-Funktionen](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in der Docker-Dokumentation.
1. Führen Sie den folgenden Befehl aus, um den Docker-Container zu starten.
```
docker-compose -f docker-compose.yml up
```
1. Entfernen Sie die Anmeldeinformationen `./greengrass-v2-credentials` vom Host-Gerät.
```
rm -rf ./greengrass-v2-credentials
```
**Wichtig**
Sie entfernen diese Anmeldeinformationen, da sie umfassende Berechtigungen bieten, die das Kerngerät nur während der Einrichtung benötigt. Wenn Sie diese Anmeldeinformationen nicht entfernen, können Greengrass-Komponenten und andere Prozesse, die im Container ausgeführt werden, darauf zugreifen. Wenn Sie AWS Anmeldeinformationen für eine Greengrass-Komponente angeben müssen, verwenden Sie den Token-Austauschdienst. Weitere Informationen finden Sie unter [Interagieren Sie mit AWS Diensten](interact-with-aws-services.md).
------
## Nächste Schritte
AWS IoT Greengrass Die Kernsoftware läuft jetzt in einem Docker-Container. Führen Sie den folgenden Befehl aus, um die Container-ID für den aktuell laufenden Container abzurufen.
```
docker ps
```
Anschließend können Sie den folgenden Befehl ausführen, um auf den Container zuzugreifen und die im Container ausgeführte AWS IoT Greengrass Core-Software zu erkunden.
```
docker exec -it container-id /bin/bash
```
Informationen zum Erstellen einer einfachen Komponente finden Sie [Schritt 4: Entwickeln und testen Sie eine Komponente auf Ihrem Gerät](create-first-component.md) unter [Tutorial: Erste Schritte mit AWS IoT Greengrass V2](getting-started.md)
**Anmerkung**
Wenn Sie `docker exec` Befehle innerhalb des Docker-Containers ausführen, werden diese Befehle nicht in den Docker-Protokollen protokolliert. Um Ihre Befehle in den Docker-Protokollen zu protokollieren, fügen Sie dem Docker-Container eine interaktive Shell hinzu. Weitere Informationen finden Sie unter [Hängen Sie eine interaktive Shell an den Docker-Container an](docker-troubleshooting.md#debugging-docker-attach-shell).
Die AWS IoT Greengrass Core-Protokolldatei wird aufgerufen `greengrass.log` und befindet sich in. `/greengrass/v2/logs` Die Protokolldateien der Komponenten befinden sich ebenfalls im selben Verzeichnis. Um Greengrass-Logs in ein temporäres Verzeichnis auf dem Host zu kopieren, führen Sie den folgenden Befehl aus:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Wenn Sie Protokolle beibehalten möchten, nachdem ein Container beendet oder entfernt wurde, empfehlen wir, dass Sie nur das Verzeichnis an das temporäre `/greengrass/v2/logs` Protokollverzeichnis auf dem Host binden, anstatt das gesamte Greengrass-Verzeichnis zu mounten. Weitere Informationen finden Sie unter [Greengrass-Logs außerhalb des Docker-Containers beibehalten](docker-troubleshooting.md#debugging-docker-persist-logs).
Um einen laufenden AWS IoT Greengrass Docker-Container zu beenden, führen Sie oder aus. `docker stop` `docker-compose -f docker-compose.yml stop` Diese Aktion sendet `SIGTERM` an den Greengrass-Prozess und beendet alle zugehörigen Prozesse, die im Container gestartet wurden. Der Docker-Container wird mit der `docker-init` ausführbaren Datei als Prozess-PID 1 initialisiert, was beim Entfernen aller übrig gebliebenen Zombie-Prozesse hilft. Weitere Informationen finden Sie unter [Spezifizieren Sie einen Init-Prozess](https://docs.docker.com/engine/reference/run/#specify-an-init-process) in der Docker-Dokumentation.
Informationen zur Behebung von Problemen bei der Ausführung AWS IoT Greengrass in einem Docker-Container finden Sie unter. [Fehlerbehebung AWS IoT Greengrass in einem Docker-Container](docker-troubleshooting.md)
# AWS IoT Greengrass In einem Docker-Container mit manueller Ressourcenbereitstellung ausführen
Dieses Tutorial zeigt Ihnen, wie Sie die AWS IoT Greengrass Core-Software im Docker-Container mit manuell bereitgestellten Ressourcen installieren und ausführen. AWS
**Topics**
+ [Voraussetzungen](#docker-manual-provisioning-prereqs)
+ [Endpunkte abrufen AWS IoT](#retrieve-iot-endpoints)
+ [Erstelle ein Ding AWS IoT](#create-iot-thing)
+ [Erstellen Sie das Ding-Zertifikat](#create-thing-certificate-mp)
+ [Erstellen Sie eine Token-Austausch-Rolle](#create-token-exchange-role)
+ [Laden Sie Zertifikate auf das Gerät herunter](#download-thing-certificates)
+ [Erstellen Sie eine Konfigurationsdatei](#create-docker-install-configuration-file)
+ [Erstellen Sie eine Umgebungsdatei](#create-env-file-manual-provisioning)
+ [Führen Sie die AWS IoT Greengrass Core-Software in einem Container aus](#run-greengrass-image-manual-provisioning)
+ [Nächste Schritte](#run-greengrass-docker-next-steps)
## Voraussetzungen
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 IoT Greengrass Docker-Image. Sie können [ein Image aus dem AWS IoT Greengrass Dockerfile erstellen](build-greengrass-dockerfile.md).
+ Der Host-Computer, auf dem Sie den Docker-Container ausführen, muss die folgenden Anforderungen erfüllen:
+ Ein Linux-basiertes Betriebssystem mit einer Internetverbindung.
+ [Docker Engine](https://docs.docker.com/engine/install/) Version 18.09 oder höher.
+ (Optional) [Docker Compose](https://docs.docker.com/compose/install/) Version 1.22 oder höher. Docker Compose ist nur erforderlich, wenn Sie die Docker Compose-CLI zum Ausführen Ihrer Docker-Images verwenden möchten.
## Endpunkte abrufen AWS IoT
Holen Sie sich die AWS IoT Endpunkte für Sie und speichern Sie sie AWS-Konto, um sie später zu verwenden. Ihr Gerät verwendet diese Endpunkte, um eine Verbindung herzustellen. AWS IoT Gehen Sie wie folgt vor:
1. Holen Sie sich den AWS IoT Datenendpunkt für Ihren AWS-Konto.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Rufen Sie den Endpunkt der AWS IoT Anmeldeinformationen für Ihren AWS-Konto ab.
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Erstelle ein Ding AWS IoT
AWS IoT *Dinge* stehen für Geräte und logische Entitäten, mit denen eine Verbindung hergestellt wird AWS IoT. Greengrass-Core-Geräte sind AWS IoT Dinge. Wenn Sie ein Gerät als Objekt registrieren AWS IoT , kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS
In diesem Abschnitt erstellen Sie eine AWS IoT Sache, die Ihr Gerät repräsentiert.
**Um AWS IoT etwas zu erschaffen**
1. Erstelle AWS IoT etwas für dein Gerät. Führen Sie auf Ihrem Entwicklungscomputer den folgenden Befehl aus.
+ *MyGreengrassCore*Ersetzen Sie es durch den Namen des zu verwendenden Dings. Dieser Name ist auch der Name Ihres Greengrass-Core-Geräts.
**Anmerkung**
Der Name der Sache darf keine Doppelpunkte (`:`) enthalten.
```
aws iot create-thing --thing-name MyGreengrassCore
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Optional) Fügen Sie das AWS IoT Ding einer neuen oder vorhandenen Dinggruppe hinzu. Sie verwenden Dinggruppen, um Flotten von Greengrass-Kerngeräten zu verwalten. Wenn Sie Softwarekomponenten auf Ihren Geräten bereitstellen, können Sie einzelne Geräte oder Gerätegruppen gezielt ansprechen. Sie können ein Gerät zu einer Dinggruppe mit einer aktiven Greengrass-Bereitstellung hinzufügen, um die Softwarekomponenten dieser Dinggruppe auf dem Gerät bereitzustellen. Gehen Sie wie folgt vor:
1. (Optional) Erstellen Sie eine AWS IoT Dinggruppe.
+ *MyGreengrassCoreGroup*Ersetzen Sie durch den Namen der zu erstellenden Dinggruppe.
**Anmerkung**
Der Name der Dinggruppe darf keine Doppelpunkte (`:`) enthalten.
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Fügt das AWS IoT Ding einer Dinggruppe hinzu.
+ Ersetze es *MyGreengrassCore* durch den Namen deines AWS IoT Dings.
+ Ersetze es *MyGreengrassCoreGroup* durch den Namen der Dinggruppe.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
## Erstellen Sie das Ding-Zertifikat
Wenn Sie ein Gerät als AWS IoT Ding registrieren, kann dieses Gerät ein digitales Zertifikat zur Authentifizierung verwenden. AWS Dieses Zertifikat ermöglicht dem Gerät die Kommunikation mit AWS IoT und AWS IoT Greengrass.
In diesem Abschnitt erstellen und laden Sie Zertifikate herunter, mit denen Ihr Gerät eine Verbindung herstellen kann AWS.
**Um das Ding-Zertifikat zu erstellen**
1. Erstellen Sie einen Ordner, in den Sie die Zertifikate für das AWS IoT Ding herunterladen.
```
mkdir greengrass-v2-certs
```
1. Erstellen Sie die Zertifikate für das AWS IoT Ding und laden Sie sie herunter.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Speichern Sie den Amazon-Ressourcennamen (ARN) des Zertifikats, um das Zertifikat später zu konfigurieren.
Als Nächstes konfigurieren Sie das Ding-Zertifikat. Weitere Informationen finden Sie unter [Konfigurieren Sie das Ding-Zertifikat](manual-installation.md#configure-thing-certificate).
## Erstellen Sie eine Token-Austausch-Rolle
Greengrass-Core-Geräte verwenden eine IAM-Servicerolle, die so genannte *Token-Exchange-Rolle*, um Aufrufe von Diensten zu autorisieren. AWS Das Gerät verwendet den AWS IoT Anmeldeinformationsanbieter, um temporäre AWS Anmeldeinformationen für diese Rolle abzurufen. Dadurch kann das Gerät mit Amazon Logs interagieren AWS IoT, Protokolle an Amazon CloudWatch Logs senden und benutzerdefinierte Komponentenartefakte von Amazon S3 herunterladen. Weitere Informationen finden Sie unter [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md).
Sie verwenden einen AWS IoT *Rollenalias*, um die Token-Austauschrolle für Greengrass-Core-Geräte zu konfigurieren. Rollenaliase ermöglichen es Ihnen, die Token-Austauschrolle für ein Gerät zu ändern, aber die Gerätekonfiguration beizubehalten. Weitere Informationen finden Sie im [*AWS IoT Core Entwicklerhandbuch* unter Autorisieren von direkten Aufrufen von AWS Diensten](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html).
In diesem Abschnitt erstellen Sie eine Token-Exchange-IAM-Rolle und einen AWS IoT Rollenalias, der auf die Rolle verweist. Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen Token-Austauschrolle und seinen Rollenalias verwenden, anstatt neue zu erstellen. Anschließend konfigurieren Sie das Gerät so, dass es AWS IoT diese Rolle und diesen Alias verwendet.
**Um eine Token-Exchange-IAM-Rolle zu erstellen**
1. Erstellen Sie eine IAM-Rolle, die Ihr Gerät als Token-Austauschrolle verwenden kann. Gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei, die das Dokument mit der Vertrauensrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-trust-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Erstellen Sie die Token-Austauschrolle mit dem Dokument zur Vertrauensrichtlinie.
+ *GreengrassV2TokenExchangeRole*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Rolle.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Erstellen Sie eine Datei, die das Dokument mit der Zugriffsrichtlinie enthält, das für die Token-Austauschrolle erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano device-role-access-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**Anmerkung**
Diese Zugriffsrichtlinie erlaubt keinen Zugriff auf Komponentenartefakte in S3-Buckets. Um benutzerdefinierte Komponenten bereitzustellen, die Artefakte in Amazon S3 definieren, müssen Sie der Rolle Berechtigungen hinzufügen, damit Ihr Kerngerät Komponentenartefakte abrufen kann. Weitere Informationen finden Sie unter [Erlauben Sie den Zugriff auf S3-Buckets für Komponentenartefakte](device-service-role.md#device-service-role-access-s3-bucket).
Wenn Sie noch keinen S3-Bucket für Komponentenartefakte haben, können Sie diese Berechtigungen später hinzufügen, nachdem Sie einen Bucket erstellt haben.
1. Erstellen Sie die IAM-Richtlinie anhand des Richtliniendokuments.
+ *GreengrassV2TokenExchangeRoleAccess*Ersetzen Sie es durch den Namen der zu erstellenden IAM-Richtlinie.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Hängen Sie die IAM-Richtlinie an die Token-Exchange-Rolle an.
+ Ersetzen Sie *GreengrassV2TokenExchangeRole* durch den Namen der IAM-Rolle.
+ Ersetzen Sie den Richtlinien-ARN durch den ARN der IAM-Richtlinie, die Sie im vorherigen Schritt erstellt haben.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
1. Erstellen Sie einen AWS IoT Rollenalias, der auf die Token-Exchange-Rolle verweist.
+ *GreengrassCoreTokenExchangeRoleAlias*Ersetzen Sie ihn durch den Namen des Rollenalias, den Sie erstellen möchten.
+ Ersetzen Sie den Rollen-ARN durch den ARN der IAM-Rolle, die Sie im vorherigen Schritt erstellt haben.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**Anmerkung**
Um einen Rollenalias zu erstellen, benötigen Sie die Berechtigung, die Token-Exchange-IAM-Rolle zu übergeben. AWS IoT Wenn Sie beim Versuch, einen Rollenalias zu erstellen, eine Fehlermeldung erhalten, überprüfen Sie, ob Ihr AWS Benutzer über diese Berechtigung verfügt. *Weitere Informationen finden Sie im [Benutzerhandbuch unter Erteilen von Benutzerberechtigungen zur Übergabe einer Rolle an einen AWS Dienst](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html).AWS Identity and Access Management *
1. Erstellen und fügen Sie eine AWS IoT Richtlinie hinzu, die es Ihrem Greengrass-Core-Gerät ermöglicht, den Rollenalias zu verwenden, um die Token-Austauschrolle zu übernehmen. Wenn Sie bereits ein Greengrass-Core-Gerät eingerichtet haben, können Sie dessen AWS IoT Rollenalias-Richtlinie anhängen, anstatt eine neue zu erstellen. Gehen Sie wie folgt vor:
1. (Optional) Erstellen Sie eine Datei, die das AWS IoT Richtliniendokument enthält, das für den Rollenalias erforderlich ist.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu erstellen.
```
nano greengrass-v2-iot-role-alias-policy.json
```
Kopieren Sie den folgenden JSON-Code in die Datei.
+ Ersetzen Sie den Ressourcen-ARN durch den ARN Ihres Rollenalias.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Erstellen Sie eine AWS IoT Richtlinie aus dem Richtliniendokument.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Ersetzen Sie es durch den Namen der zu erstellenden AWS IoT Richtlinie.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Hängen Sie die AWS IoT Richtlinie an das Zertifikat der AWS IoT Sache an.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Ersetzen Sie es durch den Namen der AWS IoT Rollenalias-Richtlinie.
+ Ersetzen Sie den Ziel-ARN durch den ARN des Zertifikats für Ihr AWS IoT Ding.
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
Der Befehl hat keine Ausgabe, wenn die Anfrage erfolgreich ist.
## Laden Sie Zertifikate auf das Gerät herunter
Zuvor haben Sie das Zertifikat Ihres Geräts auf Ihren Entwicklungscomputer heruntergeladen. In diesem Abschnitt laden Sie das Zertifikat der Amazon Root Certificate Authority (CA) herunter. Wenn Sie dann planen, die AWS IoT Greengrass Core-Software in Docker auf einem anderen Computer als Ihrem Entwicklungscomputer auszuführen, kopieren Sie die Zertifikate auf diesen Host-Computer. Die AWS IoT Greengrass Core-Software verwendet diese Zertifikate, um eine Verbindung zum AWS IoT Cloud-Dienst herzustellen.
**Um Zertifikate auf das Gerät herunterzuladen**
1. Laden Sie das Zertifikat der Amazon Root Certificate Authority (CA) auf Ihren Entwicklungscomputer herunter. AWS IoT Zertifikate sind standardmäßig dem Root-CA-Zertifikat von Amazon zugeordnet.
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. Wenn Sie die AWS IoT Greengrass Core-Software in Docker auf einem anderen Gerät als Ihrem Entwicklungscomputer ausführen möchten, kopieren Sie die Zertifikate auf den Host-Computer. Wenn SSH und SCP auf dem Entwicklungscomputer und dem Hostcomputer aktiviert sind, können Sie den `scp` Befehl auf Ihrem Entwicklungscomputer verwenden, um die Zertifikate zu übertragen. *device-ip-address*Ersetzen Sie es durch die IP-Adresse Ihres Host-Computers.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## Erstellen Sie eine Konfigurationsdatei
1. Erstellen Sie auf dem Host-Computer einen Ordner, in dem Sie Ihre Konfigurationsdatei ablegen.
```
mkdir ./greengrass-v2-config
```
1. Verwenden Sie einen Texteditor, um eine Konfigurationsdatei mit dem Namen `config.yaml` im `./greengrass-v2-config` Ordner zu erstellen.
Sie können beispielsweise den folgenden Befehl ausführen, um GNU Nano zum Erstellen des `config.yaml` zu verwenden.
```
nano ./greengrass-v2-config/config.yaml
```
1. Kopieren Sie den folgenden YAML-Inhalt in die Datei. Diese Teilkonfigurationsdatei spezifiziert Systemparameter und Greengrass-Nukleus-Parameter.
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
Ersetzen Sie dann die folgenden Werte:
+ */tmp/certs*. Das Verzeichnis im Docker-Container, in das Sie die heruntergeladenen Zertifikate mounten, wenn Sie den Container starten.
+ `/greengrass/v2`. Der Greengrass-Stammordner, den Sie für die Installation verwenden möchten. Sie verwenden die `GGC_ROOT` Umgebungsvariable, um diesen Wert festzulegen.
+ *MyGreengrassCore*. Der Name der AWS IoT Sache.
+ *nucleus-version*. Die Version der zu AWS IoT Greengrass installierenden Core-Software. Dieser Wert muss mit der Version des Docker-Images oder der Docker-Datei übereinstimmen, die Sie heruntergeladen haben. Wenn Sie das Greengrass Docker-Image mit dem `latest` Tag heruntergeladen haben, verwenden Sie es, um die Image-Version ****docker inspect *image-id***** zu sehen.
+ *region*. Der AWS-Region Ort, an dem Sie Ihre AWS IoT Ressourcen erstellt haben. Sie müssen auch denselben Wert für die `AWS_REGION` Umgebungsvariable in Ihrer [Umgebungsdatei](#create-env-file-manual-provisioning) angeben.
+ *GreengrassCoreTokenExchangeRoleAlias*. Der Alias der Token-Exchange-Rolle.
+ *device-data-prefix*. Das Präfix für Ihren AWS IoT Datenendpunkt.
+ *device-credentials-prefix*. Das Präfix für den Endpunkt Ihrer AWS IoT Anmeldeinformationen.
## Erstellen Sie eine Umgebungsdatei
In diesem Tutorial werden mithilfe einer Umgebungsdatei die Umgebungsvariablen festgelegt, die an das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container übergeben werden. Sie können auch [das `--env` Argument `-e` oder](https://docs.docker.com/engine/reference/commandline/run/#env) in Ihrem `docker run` Befehl verwenden, um Umgebungsvariablen im Docker-Container festzulegen, oder Sie können die Variablen in [einem `environment` Block](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) in der `docker-compose.yml` Datei festlegen.
1. Verwenden Sie einen Texteditor, um eine Umgebungsdatei mit dem Namen `.env` zu erstellen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um mithilfe von GNU Nano die Datei `.env` im aktuellen Verzeichnis zu erstellen.
```
nano .env
```
1. Kopieren Sie den folgenden Inhalt in die Datei.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
Ersetzen Sie dann die folgenden Werte.
+ `/greengrass/v2`. Der Pfad zum Stammordner, der für die Installation der AWS IoT Greengrass Core-Software verwendet werden soll.
+ *region*. Der AWS-Region Ort, an dem Sie Ihre AWS IoT Ressourcen erstellt haben. Sie müssen denselben Wert für den `awsRegion` Konfigurationsparameter in Ihrer [Konfigurationsdatei](#create-docker-install-configuration-file) angeben.
+ */tmp/config/*. Der Ordner, in den Sie die Konfigurationsdatei mounten, wenn Sie den Docker-Container starten.
**Anmerkung**
Sie können die `DEPLOY_DEV_TOOLS` Umgebungsvariable auf setzen, `true` um die [Greengrass-CLI-Komponente](greengrass-cli-component.md) bereitzustellen, mit der Sie benutzerdefinierte Komponenten innerhalb des Docker-Containers entwickeln können. Wir empfehlen, diese Komponente nur in Entwicklungsumgebungen zu verwenden, nicht in Produktionsumgebungen. Diese Komponente bietet Zugriff auf Informationen und Operationen, die Sie in einer Produktionsumgebung normalerweise nicht benötigen. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie diese Komponente nur dort einsetzen, wo Sie sie benötigen.
## Führen Sie die AWS IoT Greengrass Core-Software in einem Container aus
Dieses Tutorial zeigt Ihnen, wie Sie das Docker-Image starten, das Sie in einem Docker-Container erstellt haben. Sie können die Docker-CLI oder die Docker Compose-CLI verwenden, um das AWS IoT Greengrass Core-Software-Image in einem Docker-Container auszuführen.
------
#### [ Docker ]
+ Dieses Tutorial zeigt Ihnen, wie Sie das Docker-Image starten, das Sie in einem Docker-Container erstellt haben.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Dieser Beispielbefehl verwendet die folgenden Argumente für [docker run](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Reinigt den Behälter, wenn er austritt.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Verwendet einen Init-Prozess im Container.
**Anmerkung**
Das `--init` Argument ist erforderlich, um die AWS IoT Greengrass Core-Software herunterzufahren, wenn Sie den Docker-Container beenden.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Optional) Führt den Docker-Container im Vordergrund als interaktiven Prozess aus. Sie können dies durch das `-d` Argument ersetzen, den Docker-Container stattdessen im getrennten Modus auszuführen. Weitere Informationen finden Sie unter [Separated vs Foreground](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) in der Docker-Dokumentation.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Führt einen Container mit dem Namen aus `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Hängt ein Volume in den Docker-Container ein, um die Konfigurationsdatei und die Zertifikatsdateien für die AWS IoT Greengrass Ausführung innerhalb des Containers verfügbar zu machen.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Optional) Gibt die Umgebungsdatei an, um die Umgebungsvariablen festzulegen, die an das AWS IoT Greengrass Core-Softwareinstallationsprogramm im Docker-Container übergeben werden. Dieses Argument ist nur erforderlich, wenn Sie eine [Umgebungsdatei](#create-env-file-manual-provisioning) zum Setzen von Umgebungsvariablen erstellt haben. Wenn Sie keine Umgebungsdatei erstellt haben, können Sie `--env` Argumente verwenden, um Umgebungsvariablen direkt in Ihrem Docker-Run-Befehl festzulegen.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Optional) Veröffentlicht den 8883-Container-Port auf dem Host-Computer. Dieses Argument ist erforderlich, wenn Sie eine Verbindung herstellen und über MQTT kommunizieren möchten, da Port 8883 für MQTT-Verkehr AWS IoT Greengrass verwendet wird. Verwenden Sie zusätzliche Argumente, um andere Ports zu öffnen. `-p`
**Anmerkung**
Um Ihren Docker-Container mit erhöhter Sicherheit auszuführen, können Sie die `--cap-add` Argumente `--cap-drop` und verwenden, um selektiv Linux-Funktionen für Ihren Container zu aktivieren. Weitere Informationen finden Sie in der [Docker-Dokumentation unter Runtime-Rechte und Linux-Funktionen](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities).
------
#### [ Docker Compose ]
1. Verwenden Sie einen Texteditor, um eine Docker Compose-Datei mit dem Namen zu erstellen. `docker-compose.yml`
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um mithilfe von GNU Nano die Datei `docker-compose.yml` im aktuellen Verzeichnis zu erstellen.
```
nano docker-compose.yml
```
**Anmerkung**
Sie können auch die neueste Version der AWS bereitgestellten Compose-Datei von herunterladen und verwenden. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Fügen Sie der Compose-Datei den folgenden Inhalt hinzu. Die Datei sollte ähnlich wie im folgenden Beispiel aussehen. *your-container-name:version*Ersetzen Sie es durch den Namen Ihres Docker-Images.
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
Die folgenden Parameter in dieser Compose-Beispieldatei sind optional:
+ `ports`— Veröffentlicht die 8883 Container-Ports auf dem Host-Computer. Dieser Parameter ist erforderlich, wenn Sie eine Verbindung herstellen und über MQTT kommunizieren möchten, da Port 8883 für MQTT-Verkehr AWS IoT Greengrass verwendet wird.
+ `env_file`— Gibt die Umgebungsdatei an, um die Umgebungsvariablen festzulegen, die an das AWS IoT Greengrass Core-Software-Installationsprogramm im Docker-Container übergeben werden. Dieser Parameter ist nur erforderlich, wenn Sie eine [Umgebungsdatei zum Setzen von Umgebungsvariablen](#create-env-file-manual-provisioning) erstellt haben. Wenn Sie keine Umgebungsdatei erstellt haben, können Sie den [Umgebungsparameter](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) verwenden, um die Variablen direkt in Ihrer Compose-Datei festzulegen.
**Anmerkung**
Um Ihren Docker-Container mit erhöhter Sicherheit auszuführen, können Sie `cap_drop` und `cap_add` in Ihrer Compose-Datei verwenden, um selektiv Linux-Funktionen für Ihren Container zu aktivieren. Weitere Informationen finden Sie unter [Runtime-Rechte und Linux-Funktionen](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in der Docker-Dokumentation.
1. Führen Sie den folgenden Befehl aus, um den Container zu starten.
```
docker-compose -f docker-compose.yml up
```
------
## Nächste Schritte
AWS IoT Greengrass Die Kernsoftware läuft jetzt in einem Docker-Container. Führen Sie den folgenden Befehl aus, um die Container-ID für den aktuell laufenden Container abzurufen.
```
docker ps
```
Anschließend können Sie den folgenden Befehl ausführen, um auf den Container zuzugreifen und die im Container ausgeführte AWS IoT Greengrass Core-Software zu erkunden.
```
docker exec -it container-id /bin/bash
```
Informationen zum Erstellen einer einfachen Komponente finden Sie [Schritt 4: Entwickeln und testen Sie eine Komponente auf Ihrem Gerät](create-first-component.md) unter [Tutorial: Erste Schritte mit AWS IoT Greengrass V2](getting-started.md)
**Anmerkung**
Wenn Sie `docker exec` Befehle innerhalb des Docker-Containers ausführen, werden diese Befehle nicht in den Docker-Protokollen protokolliert. Um Ihre Befehle in den Docker-Protokollen zu protokollieren, fügen Sie dem Docker-Container eine interaktive Shell hinzu. Weitere Informationen finden Sie unter [Hängen Sie eine interaktive Shell an den Docker-Container an](docker-troubleshooting.md#debugging-docker-attach-shell).
Die AWS IoT Greengrass Core-Protokolldatei wird aufgerufen `greengrass.log` und befindet sich in. `/greengrass/v2/logs` Die Protokolldateien der Komponenten befinden sich ebenfalls im selben Verzeichnis. Um Greengrass-Logs in ein temporäres Verzeichnis auf dem Host zu kopieren, führen Sie den folgenden Befehl aus:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Wenn Sie Protokolle beibehalten möchten, nachdem ein Container beendet oder entfernt wurde, empfehlen wir, dass Sie nur das Verzeichnis an das temporäre `/greengrass/v2/logs` Protokollverzeichnis auf dem Host binden, anstatt das gesamte Greengrass-Verzeichnis zu mounten. Weitere Informationen finden Sie unter [Greengrass-Logs außerhalb des Docker-Containers beibehalten](docker-troubleshooting.md#debugging-docker-persist-logs).
Um einen laufenden AWS IoT Greengrass Docker-Container zu beenden, führen Sie oder aus. `docker stop` `docker-compose -f docker-compose.yml stop` Diese Aktion sendet `SIGTERM` an den Greengrass-Prozess und beendet alle zugehörigen Prozesse, die im Container gestartet wurden. Der Docker-Container wird mit der `docker-init` ausführbaren Datei als Prozess-PID 1 initialisiert, was beim Entfernen aller übrig gebliebenen Zombie-Prozesse hilft. Weitere Informationen finden Sie unter [Spezifizieren Sie einen Init-Prozess](https://docs.docker.com/engine/reference/run/#specify-an-init-process) in der Docker-Dokumentation.
Informationen zur Behebung von Problemen bei der Ausführung AWS IoT Greengrass in einem Docker-Container finden Sie unter. [Fehlerbehebung AWS IoT Greengrass in einem Docker-Container](docker-troubleshooting.md)
# Fehlerbehebung AWS IoT Greengrass in einem Docker-Container
Verwenden Sie die folgenden Informationen, um Probleme bei der Ausführung AWS IoT Greengrass in einem Docker-Container zu beheben und Probleme AWS IoT Greengrass im Docker-Container zu debuggen.
**Topics**
+ [Behebung von Problemen beim Ausführen des Docker-Containers](#troubleshooting-container-errors)
+ [Debuggen AWS IoT Greengrass in einem Docker-Container](#debugging-greengrass-in-docker)
## Behebung von Problemen beim Ausführen des Docker-Containers
Verwenden Sie die folgenden Informationen, um Probleme bei der Ausführung AWS IoT Greengrass in einem Docker-Container zu beheben.
**Topics**
+ [Fehler: Interaktive Anmeldung von einem Nicht-TTY-Gerät aus nicht möglich](#docker-troubleshootin-ecr-get-login-password)
+ [Fehler: Unbekannte Optionen: - no-include-email](#docker-troubleshooting-cli-version)
+ [Fehler: Eine Firewall blockiert die Freigabe von Dateien zwischen Fenstern und den Containern.](#docker-troubleshooting-firewall)
+ [Fehler: Beim Aufrufen der GetAuthorizationToken Operation ist ein Fehler aufgetreten (AccessDeniedException): User: arn:aws:iam: :user/ *account-id* ist nicht berechtigt,: ecr: on resource: \$1 auszuführen GetAuthorizationToken](#docker-troubleshooting-ecr-perms)
+ [Fehler: Sie haben Ihr Pull-Rate-Limit erreicht](#docker-troubleshooting-too-many-requests)
### Fehler: Interaktive Anmeldung von einem Nicht-TTY-Gerät aus nicht möglich
Dieser Fehler kann auftreten, wenn Sie den `aws ecr get-login-password` Befehl ausführen. Stellen Sie sicher, dass Sie die neueste AWS CLI Version 2 oder Version 1 installiert haben. Wir empfehlen Ihnen, die AWS CLI Version 2 zu verwenden. Weitere Informationen finden Sie unter [Installieren der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im *AWS Command Line Interface -Benutzerhandbuch*.
### Fehler: Unbekannte Optionen: - no-include-email
Dieser Fehler kann auftreten, wenn Sie den `aws ecr get-login` Befehl ausführen. Stellen Sie sicher, dass Sie die neueste AWS CLI Version installiert haben (z. B. Run:`pip install awscli --upgrade --user`). Weitere Informationen finden Sie im *AWS Command Line Interface Benutzerhandbuch AWS Command Line Interface * [unter Installation von unter Microsoft Windows](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html).
### Fehler: Eine Firewall blockiert die Freigabe von Dateien zwischen Fenstern und den Containern.
Möglicherweise erhalten Sie diesen Fehler oder eine `Firewall Detected` Meldung, wenn Sie Docker auf einem Windows-Computer ausführen. Dies kann auch auftreten, wenn Sie an einem Virtual Private Network (VPN) angemeldet sind und Ihre Netzwerkeinstellungen die Bereitstellung des freigegebenen Laufwerks verhindern. Deaktivieren Sie in diesem Fall das VPN und führen Sie den Docker-Container erneut aus.
### Fehler: Beim Aufrufen der GetAuthorizationToken Operation ist ein Fehler aufgetreten (AccessDeniedException): User: arn:aws:iam: :user/ *account-id* ist nicht berechtigt,: ecr: on resource: \$1 auszuführen GetAuthorizationToken
Möglicherweise erhalten Sie diesen Fehler, wenn Sie den `aws ecr get-login-password` Befehl ausführen, wenn Sie nicht über ausreichende Berechtigungen für den Zugriff auf ein Amazon ECR-Repository verfügen. Weitere Informationen finden Sie unter [Beispiele für Amazon ECR Repository-Richtlinien](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html) und [Zugriff auf ein Amazon ECR-Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html) im *Amazon ECR-Benutzerhandbuch*.
### Fehler: Sie haben Ihr Pull-Rate-Limit erreicht
Docker Hub begrenzt die Anzahl der Pull-Anfragen, die anonyme und kostenlose Docker Hub-Benutzer stellen können. Wenn du die Ratenlimits für anonyme oder kostenlose Benutzer-Pull-Requests überschreitest, erhältst du einen der folgenden Fehler:
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
Um diese Fehler zu beheben, kannst du einige Stunden warten, bevor du einen weiteren Pull-Request versuchst. Wenn Sie planen, regelmäßig eine große Anzahl von Pull-Requests einzureichen, finden Sie auf der [Docker Hub-Website](https://www.docker.com/increase-rate-limits) Informationen zu Ratenbegrenzungen und Optionen für die Authentifizierung und Aktualisierung Ihres Docker-Kontos.
## Debuggen AWS IoT Greengrass in einem Docker-Container
Zum Debuggen von Problemen mit einem Docker-Container können Sie die Greengrass-Laufzeitprotokolle erhalten oder eine interaktive Shell an den Docker-Container anfügen.
### Greengrass-Logs außerhalb des Docker-Containers beibehalten
Nachdem Sie einen AWS IoT Greengrass Container gestoppt haben, können Sie den folgenden `docker cp ` Befehl verwenden, um die Greengrass-Protokolle aus dem Docker-Container in ein temporäres Protokollverzeichnis zu kopieren.
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Um Protokolle auch nach dem Beenden oder Entfernen eines Containers beizubehalten, müssen Sie den AWS IoT Greengrass Docker-Container nach dem Bind-Mounten des Verzeichnisses ausführen. `/greengrass/v2/logs`
Um das `/greengrass/v2/logs` Verzeichnis per Bind-Mount zu mounten, führen Sie einen der folgenden Schritte aus, wenn Sie einen neuen Docker-Container ausführen. AWS IoT Greengrass
+ In Ihren Befehl aufnehmen`-v /tmp/logs:/greengrass/v2/logs:ro`. `docker run`
Ändern Sie den `volumes` Block in der Compose-Datei so, dass er die folgende Zeile enthält, bevor Sie Ihren `docker-compose up` Befehl ausführen.
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
Sie können dann Ihre Logs `/tmp/logs` auf Ihrem Host überprüfen, um Greengrass-Logs zu sehen, während AWS IoT Greengrass es im Docker-Container läuft.
Hinweise zum Ausführen von Greengrass-Docker-Containern finden Sie unter und [ AWS IoT Greengrass In Docker mit manueller Bereitstellung ausführen](run-greengrass-docker-manual-provisioning.md) [ AWS IoT Greengrass In Docker mit automatischer Bereitstellung ausführen](run-greengrass-docker-automatic-provisioning.md)
### Hängen Sie eine interaktive Shell an den Docker-Container an
Wenn Sie `docker exec` Befehle innerhalb des Docker-Containers ausführen, werden diese Befehle nicht in den Docker-Protokollen erfasst. Wenn Sie Ihre Befehle in den Docker-Protokollen protokollieren, können Sie den Status des Greengrass Docker-Containers untersuchen. Führen Sie eine der folgenden Aktionen aus:
+ Führen Sie den folgenden Befehl in einem separaten Terminal aus, um die Standardeingabe, -ausgabe und -fehler Ihres Terminals an den laufenden Container anzuhängen. Auf diese Weise können Sie den Docker-Container von Ihrem aktuellen Terminal aus anzeigen und steuern.
```
docker attach container-id
```
+ Führen Sie den folgenden Befehl in einem separaten Terminal aus. Auf diese Weise können Sie Ihre Befehle im interaktiven Modus ausführen, auch wenn der Container nicht angehängt ist.
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
Allgemeine Informationen AWS IoT Greengrass zur Problembehandlung finden Sie unter[Problembehebung AWS IoT Greengrass V2](troubleshooting.md).
# Konfiguration der AWS IoT Greengrass Core-Software
Die AWS IoT Greengrass Core-Software bietet Optionen, mit denen Sie die Software konfigurieren können. Sie können Bereitstellungen erstellen, um die AWS IoT Greengrass Core-Software auf jedem Core-Gerät zu konfigurieren.
**Topics**
+ [Stellen Sie die Greengrass Nucleus-Komponente bereit](#configure-nucleus-component)
+ [Den Greengrass Nucleus als Systemdienst konfigurieren](#configure-system-service)
+ [Steuern Sie die Speicherzuweisung mit JVM-Optionen](#jvm-tuning)
+ [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](#configure-component-user)
+ [Konfigurieren Sie die Systemressourcenlimits für Komponenten](#configure-component-system-resource-limits)
+ [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#configure-alpn-network-proxy)
+ [Verwenden Sie ein Gerätezertifikat, das von einer privaten Zertifizierungsstelle signiert wurde](#configure-nucleus-private-ca)
+ [Konfigurieren Sie MQTT-Timeouts und Cache-Einstellungen](#configure-mqtt)
+ [Greengrass Nucleus im Netzwerk IPv6 konfigurieren](#configure-ipv6)
## Stellen Sie die Greengrass Nucleus-Komponente bereit
AWS IoT Greengrass stellt die AWS IoT Greengrass Core-Software als Komponente bereit, die Sie auf Ihren Greengrass-Core-Geräten bereitstellen können. Sie können eine Bereitstellung erstellen, um dieselbe Konfiguration auf mehrere Greengrass-Core-Geräte anzuwenden. Weitere Informationen erhalten Sie unter [Grüngraskern](greengrass-nucleus-component.md) und [Aktualisieren Sie die AWS IoT Greengrass Core-Software (OTA)](update-greengrass-core-v2.md).
## Den Greengrass Nucleus als Systemdienst konfigurieren
Sie müssen die AWS IoT Greengrass Core-Software als Systemdienst im Init-System Ihres Geräts konfigurieren, um Folgendes zu tun:
+ Starten Sie die AWS IoT Greengrass Core-Software, wenn das Gerät bootet. Dies ist eine gute Methode, wenn Sie große Geräteflotten verwalten.
+ Installieren und starten Sie die Plugin-Komponenten. Bei mehreren der AWS bereitgestellten Komponenten handelt es sich um Plugin-Komponenten, sodass sie direkt mit dem Greengrass-Nucleus verbunden werden können. Weitere Informationen zu Komponententypen finden Sie unter. [Komponententypen](develop-greengrass-components.md#component-types)
+ Wenden Sie over-the-air (OTA) -Updates auf die Core-Software des AWS IoT Greengrass Kerngeräts an. Weitere Informationen finden Sie unter [Aktualisieren Sie die AWS IoT Greengrass Core-Software (OTA)](update-greengrass-core-v2.md).
+ Ermöglichen Sie es den Komponenten, die AWS IoT Greengrass Core-Software oder das Kerngerät neu zu starten, wenn eine Bereitstellung die Komponente auf eine neue Version aktualisiert oder bestimmte Konfigurationsparameter aktualisiert. Weitere Informationen finden Sie im [Schritt zum Bootstrap-Lebenszyklus](component-recipe-reference.md#bootstrap-lifecycle-definition).
**Wichtig**
Auf Windows Core-Geräten müssen Sie die AWS IoT Greengrass Core-Software als Systemdienst einrichten.
**Topics**
+ [Konfigurieren Sie den Nucleus als Systemdienst (Linux)](#configure-system-service-linux)
+ [Konfigurieren Sie den Nucleus als Systemdienst (Windows)](#configure-system-service-windows)
### Konfigurieren Sie den Nucleus als Systemdienst (Linux)
Linux-Geräte unterstützen verschiedene Init-Systeme wie initd, systemd und SystemV. Sie verwenden das `--setup-system-service true` Argument bei der Installation der AWS IoT Greengrass Core-Software, um den Nucleus als Systemdienst zu starten und ihn so zu konfigurieren, dass er beim Booten des Geräts gestartet wird. Das Installationsprogramm konfiguriert die AWS IoT Greengrass Core-Software als Systemdienst mit systemd.
Sie können den Nucleus auch manuell so konfigurieren, dass er als Systemdienst ausgeführt wird. Das folgende Beispiel ist eine Servicedatei für systemd.
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
Nachdem Sie den Systemdienst konfiguriert haben, können Sie die folgenden Befehle ausführen, um das Starten des Geräts beim Systemstart und das Starten oder Beenden der AWS IoT Greengrass Core-Software zu konfigurieren.
+ Um den Status des Dienstes zu überprüfen (systemd)
```
sudo systemctl status greengrass.service
```
+ Damit der Nucleus beim Booten des Geräts starten kann.
```
sudo systemctl enable greengrass.service
```
+ Um zu verhindern, dass der Nucleus beim Booten des Geräts startet.
```
sudo systemctl disable greengrass.service
```
+ Um die AWS IoT Greengrass Core-Software zu starten.
```
sudo systemctl start greengrass.service
```
+ Um die AWS IoT Greengrass Core-Software zu beenden.
```
sudo systemctl stop greengrass.service
```
### Konfigurieren Sie den Nucleus als Systemdienst (Windows)
Sie verwenden das `--setup-system-service true` Argument bei der Installation der AWS IoT Greengrass Core-Software, um den Nucleus als Windows-Dienst zu starten und ihn so zu konfigurieren, dass er beim Booten des Geräts gestartet wird.
Nachdem Sie den Dienst konfiguriert haben, können Sie die folgenden Befehle ausführen, um das Starten des Geräts beim Systemstart und das Starten oder Beenden der AWS IoT Greengrass Core-Software zu konfigurieren. Sie müssen die Befehlszeile oder PowerShell als Administrator ausführen, um diese Befehle ausführen zu können.
------
#### [ Windows Command Prompt (CMD) ]
+ Um den Status des Dienstes zu überprüfen
```
sc query "greengrass"
```
+ Damit der Nucleus beim Booten des Geräts starten kann.
```
sc config "greengrass" start=auto
```
+ Um zu verhindern, dass der Nucleus beim Booten des Geräts startet.
```
sc config "greengrass" start=disabled
```
+ Um die AWS IoT Greengrass Core-Software zu starten.
```
sc start "greengrass"
```
+ Um die AWS IoT Greengrass Core-Software zu beenden.
```
sc stop "greengrass"
```
**Anmerkung**
Auf Windows-Geräten ignoriert die AWS IoT Greengrass Core-Software dieses Abschaltsignal, während sie die Prozesse der Greengrass-Komponenten herunterfährt. Wenn die AWS IoT Greengrass Core-Software das Signal zum Herunterfahren ignoriert, wenn Sie diesen Befehl ausführen, warten Sie einige Sekunden und versuchen Sie es erneut.
------
#### [ PowerShell ]
+ Um den Status des Dienstes zu überprüfen
```
Get-Service -Name "greengrass"
```
+ Damit der Nucleus beim Booten des Geräts starten kann.
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ Um zu verhindern, dass der Nucleus beim Booten des Geräts startet.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ Um die AWS IoT Greengrass Core-Software zu starten.
```
Start-Service -Name "greengrass"
```
+ Um die AWS IoT Greengrass Core-Software zu beenden.
```
Stop-Service -Name "greengrass"
```
**Anmerkung**
Auf Windows-Geräten ignoriert die AWS IoT Greengrass Core-Software dieses Abschaltsignal, während sie die Prozesse der Greengrass-Komponenten herunterfährt. Wenn die AWS IoT Greengrass Core-Software das Signal zum Herunterfahren ignoriert, wenn Sie diesen Befehl ausführen, warten Sie einige Sekunden und versuchen Sie es erneut.
------
## Steuern Sie die Speicherzuweisung mit JVM-Optionen
Wenn Sie AWS IoT Greengrass auf einem Gerät mit begrenztem Arbeitsspeicher arbeiten, können Sie die Optionen der Java Virtual Machine (JVM) verwenden, um die maximale Heap-Größe, die Garbage-Collection-Modi und die Compiler-Optionen zu steuern, mit denen die Speichermenge gesteuert wird, die die Core-Software verwendet. AWS IoT Greengrass Die Heap-Größe in der JVM bestimmt, wie viel Speicher eine Anwendung verwenden kann, bevor die [Speicherbereinigung erfolgt](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html) oder bevor der Anwendung der Arbeitsspeicher ausgeht. Die maximale Heap-Größe gibt die maximale Größe des Arbeitsspeichers an, die bei einer großen Auslastung von der JVM für die Heap-Erweiterung zugewiesen werden kann.
[Um die Speicherzuweisung zu steuern, erstellen Sie eine neue Bereitstellung oder überarbeiten Sie eine bestehende Bereitstellung, die die Nucleus-Komponente enthält, und geben Sie Ihre JVM-Optionen im `jvmOptions` Konfigurationsparameter in der Nucleus-Komponentenkonfiguration an.](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options)
Je nach Ihren Anforderungen können Sie die AWS IoT Greengrass Core-Software mit reduzierter Speicherzuweisung oder mit minimaler Speicherzuweisung ausführen.
**Reduzierte Speicherzuweisung**
Um die AWS IoT Greengrass Core-Software mit reduzierter Speicherzuweisung auszuführen, empfehlen wir Ihnen, das folgende Beispiel für ein Update zur Zusammenführung von Konfigurationen zu verwenden, um die JVM-Optionen in Ihrer Nucleus-Konfiguration festzulegen:
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**Minimale Speicherzuweisung**
Um die AWS IoT Greengrass Core-Software mit minimaler Speicherzuweisung auszuführen, empfehlen wir Ihnen, das folgende Beispiel für ein Update zur Zusammenführung von Konfigurationen zu verwenden, um die JVM-Optionen in Ihrer Nucleus-Konfiguration festzulegen:
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**Wichtig**
Die Ausführung der AWS IoT Greengrass Core-Software mit minimaler Speicherzuweisung kann sich auf Systemen mit niedrigen Spezifikationen erheblich auf die Leistung auswirken, da die JVM bei geringerem Speicherverbrauch mehr Rechenleistung erbringt. Wir empfehlen, die Optionen so zu optimieren, dass sie Ihren Speicher- und Leistungsanforderungen entsprechen.
Diese Beispielupdates zur Zusammenführung von Konfigurationen verwenden die folgenden JVM-Optionen:
`-XX:+UseSerialGC`
Gibt an, dass die serielle Garbage-Collection für den JVM-Heap-Speicherplatz verwendet werden soll. Der serielle Garbage-Collector ist langsamer, verbraucht aber weniger Speicher als andere JVM-Garbage-Collection-Implementierungen.
`-XX:TieredStopAtLevel=1`
Weist die JVM an, den Java just-in-time (JIT) -Compiler einmal zu verwenden. Da JIT-kompilierter Code Speicherplatz im Gerätespeicher beansprucht, verbraucht die mehrfache Verwendung des JIT-Compilers mehr Speicher als eine einzelne Kompilierung.
`-XmxNNm`
Legt die maximale JVM-Heap-Größe fest.
Wenn die maximale Heap-Größe zu niedrig eingestellt wird, kann dies zu einer langsameren Leistung oder zu Fehlern führen. out-of-memory Wir empfehlen, Ihre aktuelle Heap-Nutzung zu messen, bevor Sie mit der `-XmxNNm` Option eine maximale Größe festlegen. Konfigurieren Sie Ihre JVM mit der `-XX:NativeMemoryTracking=detail` JVM-Option. [Messen Sie dann Ihre aktuelle Heap-Nutzung, indem Sie die `VM.native_memory` Befehlsanfrage im jcmd Utility verwenden.](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html)
Wenn die Messung des Heaps keine Option ist, verwenden Sie ihn `-Xmx64m` als Startwert, um die Heap-Größe auf 64 MB zu begrenzen. Von dort aus können Sie dann die maximale Heap-Größe schrittweise verringern. Verwenden Sie für eine minimale Speicherzuweisung den Wert `-Xmx32m` als Startwert, um die Heap-Größe auf 32 MB zu begrenzen.
Sie können den `-Xmx` Wert je nach Ihren tatsächlichen Anforderungen erhöhen oder verringern. Es wird jedoch dringend empfohlen, die maximale Heap-Größe nicht unter 16 MB festzulegen. Die Menge der benötigten JVM-Heap-Größe kann auch im Laufe der Zeit variieren, je nachdem, welche Plugin-Komponenten auf dem Kerngerät bereitgestellt werden. Wenn die maximale Heap-Größe für Ihre Umgebung zu niedrig ist, kann die AWS IoT Greengrass Core-Software aufgrund unzureichenden Speichers auf unerwartete Fehler stoßen. Wenn Sie eine langsamere Leistung oder Fehler aufgrund unzureichenden Speichers feststellen, kehren Sie zu einer zweifelsfrei funktionierenden Einstellung zurück. Wenn Ihre normale Größe des festgeschriebenen Heaps beispielsweise ist`41428KB`, verwenden Sie diese Option, `-Xmx40m` um die Heap-Nutzung leicht einzuschränken.
`-Xint`
Weist die JVM an, den just-in-time (JIT-) Compiler nicht zu verwenden. Stattdessen wird die JVM nur im interpretierten Modus ausgeführt. Dieser Modus ist langsamer (möglicherweise 20-mal langsamer für Bereitstellungen auf Low-End-Systemen) als das Ausführen von JIT-kompiliertem Code. Der kompilierte Code belegt jedoch keinen Speicherplatz.
Informationen zum Erstellen von Updates zur Zusammenführung von Konfigurationen finden Sie unter. [Komponentenkonfigurationen aktualisieren](update-component-configurations.md)
## Konfigurieren Sie den Benutzer, der die Komponenten ausführt
Die AWS IoT Greengrass Core-Software kann Komponentenprozesse als Systembenutzer und Gruppe ausführen, die sich von der Gruppe unterscheiden, die die Software ausführt. Dies erhöht die Sicherheit, da Sie die AWS IoT Greengrass Core-Software als Root-Benutzer oder als Administratorbenutzer ausführen können, ohne Komponenten, die auf dem Kerngerät ausgeführt werden, diese Berechtigungen zu erteilen.
In der folgenden Tabelle ist angegeben, welche Komponententypen die AWS IoT Greengrass Core-Software als von Ihnen angegebener Benutzer ausführen kann. Weitere Informationen finden Sie unter [Komponententypen](develop-greengrass-components.md#component-types).
| Komponententyp | Konfigurieren Sie den Komponentenbenutzer |
| --- | --- |
| Nucleus | ![\[No\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-no.png) Nein |
| Plug-In | ![\[No\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-no.png) Nein |
| Generisch | ![\[Yes\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-yes.png) Ja |
| Lambda (nicht containerisiert) | ![\[Yes\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-yes.png) Ja |
| Lambda (containerisiert) | ![\[Yes\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-yes.png) Ja |
Sie müssen den Komponentenbenutzer erstellen, bevor Sie ihn in einer Bereitstellungskonfiguration angeben können. Auf Windows-Geräten müssen Sie außerdem den Benutzernamen und das Kennwort für den Benutzer in der Credential Manager-Instanz des Kontos speichern. LocalSystem Weitere Informationen finden Sie unter [Richten Sie einen Komponentenbenutzer auf Windows-Geräten ein](#create-component-user-windows).
Wenn Sie den Komponentenbenutzer auf einem Linux-basierten Gerät konfigurieren, können Sie optional auch eine Gruppe angeben. Sie geben den Benutzer und die Gruppe, getrennt durch einen Doppelpunkt (`:`), im folgenden Format an:`user:group`. Wenn Sie keine Gruppe angeben, verwendet die AWS IoT Greengrass Core-Software standardmäßig die primäre Gruppe des Benutzers. Sie können entweder den Namen oder die ID verwenden, um den Benutzer und die Gruppe zu identifizieren.
Auf Linux-basierten Geräten können Sie Komponenten auch als Systembenutzer ausführen, der nicht existiert (auch als unbekannter Benutzer bezeichnet), um die Sicherheit zu erhöhen. Ein Linux-Prozess kann jeden anderen Prozess signalisieren, der von demselben Benutzer ausgeführt wird. Ein unbekannter Benutzer führt keine anderen Prozesse aus. Sie können also Komponenten als unbekannter Benutzer ausführen, um zu verhindern, dass Komponenten andere Komponenten auf dem Kerngerät signalisieren. Um Komponenten als unbekannter Benutzer auszuführen, geben Sie eine Benutzer-ID an, die auf dem Kerngerät nicht existiert. Sie können auch eine Gruppen-ID angeben, die nicht existiert, um sie als unbekannte Gruppe auszuführen.
Sie können den Benutzer für jede Komponente und für jedes Kerngerät konfigurieren.
+ **Für eine Komponente konfigurieren**
Sie können jede Komponente so konfigurieren, dass sie mit einem für diese Komponente spezifischen Benutzer ausgeführt wird. Wenn Sie eine Einrichtung erstellen, können Sie den Benutzer für jede Komponente in der `runWith` Konfiguration für diese Komponente angeben. Die AWS IoT Greengrass Core-Software führt Komponenten als der angegebene Benutzer aus, wenn Sie sie konfigurieren. Andernfalls werden Komponenten standardmäßig als Standardbenutzer ausgeführt, den Sie für das Kerngerät konfigurieren. Weitere Informationen zur Angabe des Komponentenbenutzers in der Bereitstellungskonfiguration finden Sie unter dem [`runWith`](create-deployments.md#component-run-with-config)Konfigurationsparameter unter[Erstellen von Bereitstellungen](create-deployments.md).
+ **Konfigurieren Sie den Standardbenutzer für ein Kerngerät**
Sie können einen Standardbenutzer konfigurieren, den die AWS IoT Greengrass Core-Software zum Ausführen von Komponenten verwendet. Wenn die AWS IoT Greengrass Core-Software eine Komponente ausführt, prüft sie, ob Sie einen Benutzer für diese Komponente angegeben haben, und verwendet ihn, um die Komponente auszuführen. Wenn in der Komponente kein Benutzer angegeben ist, führt die AWS IoT Greengrass Core-Software die Komponente als Standardbenutzer aus, den Sie für das Kerngerät konfiguriert haben. Weitere Informationen finden Sie unter [Konfigurieren Sie den Standardkomponentenbenutzer](#configure-default-component-user).
**Anmerkung**
Auf Windows-basierten Geräten müssen Sie mindestens einen Standardbenutzer angeben, um Komponenten auszuführen.
Auf Linux-basierten Geräten gelten die folgenden Überlegungen, wenn Sie einen Benutzer nicht für die Ausführung von Komponenten konfigurieren:
Wenn Sie die AWS IoT Greengrass Core-Software als Root-Benutzer ausführen, führt die Software keine Komponenten aus. Sie müssen einen Standardbenutzer für die Ausführung von Komponenten angeben, wenn Sie sie als Root ausführen.
Wenn Sie die AWS IoT Greengrass Core-Software als Benutzer ausführen, der kein Root-Benutzer ist, führt die Software die Komponenten als dieser Benutzer aus.
**Topics**
+ [Richten Sie einen Komponentenbenutzer auf Windows-Geräten ein](#create-component-user-windows)
+ [Konfigurieren Sie den Standardkomponentenbenutzer](#configure-default-component-user)
### Richten Sie einen Komponentenbenutzer auf Windows-Geräten ein
**So richten Sie einen Komponentenbenutzer auf einem Windows-basierten Gerät ein**
1. Erstellen Sie den Komponentenbenutzer im LocalSystem Konto auf dem Gerät.
```
net user /add component-user password
```
1. Verwenden Sie [das PsExec Microsoft-Hilfsprogramm](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec), um den Benutzernamen und das Passwort für den Komponentenbenutzer in der Credential Manager-Instanz für das LocalSystem Konto zu speichern.
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**Anmerkung**
Auf Windows-basierten Geräten wird auf dem LocalSystem Konto der Greengrass-Nucleus ausgeführt, und Sie müssen das PsExec Hilfsprogramm verwenden, um die Benutzerinformationen der Komponente im Konto zu speichern. LocalSystem Wenn Sie die Credential Manager-Anwendung verwenden, werden diese Informationen nicht im Konto, sondern im Windows-Konto des aktuell angemeldeten Benutzers gespeichert. LocalSystem
### Konfigurieren Sie den Standardkomponentenbenutzer
Sie können eine Bereitstellung verwenden, um den Standardbenutzer auf einem Kerngerät zu konfigurieren. In dieser Bereitstellung aktualisieren Sie die [Nucleus-Komponentenkonfiguration](greengrass-nucleus-component.md).
**Anmerkung**
Mit der `--component-default-user` Option können Sie auch den Standardbenutzer festlegen, wenn Sie die AWS IoT Greengrass Core-Software installieren. Weitere Informationen finden Sie unter [Installieren Sie die AWS IoT Greengrass Core-Software](install-greengrass-core-v2.md).
[Erstellen Sie eine Bereitstellung](create-deployments.md), die das folgende Konfigurationsupdate für die `aws.greengrass.Nucleus` Komponente angibt.
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**Anmerkung**
Der von Ihnen angegebene Benutzer muss existieren, und der Benutzername und das Kennwort für diesen Benutzer müssen in der Credential Manager-Instanz des LocalSystem Kontos auf Ihrem Windows-Gerät gespeichert sein. Weitere Informationen finden Sie unter [Richten Sie einen Komponentenbenutzer auf Windows-Geräten ein](#create-component-user-windows).
------
Das folgende Beispiel definiert eine Bereitstellung für ein Linux-basiertes Gerät, das als Standardbenutzer und `ggc_user` `ggc_group` als Standardgruppe konfiguriert wird. Das `merge` Konfigurationsupdate erfordert ein serialisiertes JSON-Objekt.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## Konfigurieren Sie die Systemressourcenlimits für Komponenten
**Anmerkung**
Diese Funktion ist für Version 2.4.0 und höher der [Greengrass](greengrass-nucleus-component.md) Nucleus-Komponente verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten.
Sie können die maximale CPU- und RAM-Auslastung konfigurieren, die die Prozesse der einzelnen Komponenten auf dem Kerngerät verwenden können.
Die folgende Tabelle zeigt die Komponententypen, die Systemressourcenlimits unterstützen. Weitere Informationen finden Sie unter [Komponententypen](develop-greengrass-components.md#component-types).
| Komponententyp | Konfigurieren Sie Systemressourcenlimits |
| --- | --- |
| Nucleus | ![\[No\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-no.png) Nein |
| Plug-In | ![\[No\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-no.png) Nein |
| Generisch | ![\[Yes\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-yes.png) Ja |
| Lambda (nicht containerisiert) | ![\[Yes\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-yes.png) Ja |
| Lambda (containerisiert) | ![\[No\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/icon-no.png) Nein |
**Wichtig**
Systemressourcenlimits werden nicht unterstützt, wenn Sie die [AWS IoT Greengrass Core-Software in einem Docker-Container ausführen](run-greengrass-docker.md).
Sie können Systemressourcenlimits für jede Komponente und für jedes Kerngerät konfigurieren.
+ **Für eine Komponente konfigurieren**
Sie können jede Komponente mit spezifischen Systemressourcenlimits für diese Komponente konfigurieren. Wenn Sie eine Bereitstellung erstellen, können Sie die Systemressourcenlimits für jede Komponente in der Bereitstellung angeben. Wenn die Komponente Systemressourcenlimits unterstützt, wendet die AWS IoT Greengrass Core-Software die Grenzwerte auf die Prozesse der Komponente an. Wenn Sie keine Systemressourcenlimits für eine Komponente angeben, verwendet die AWS IoT Greengrass Core-Software alle Standardeinstellungen, die Sie für das Kerngerät konfiguriert haben. Weitere Informationen finden Sie unter [Erstellen von Bereitstellungen](create-deployments.md).
+ **Konfigurieren Sie die Standardeinstellungen für ein Kerngerät**
Sie können die Standardgrenzwerte für Systemressourcen konfigurieren, die die AWS IoT Greengrass Core-Software für Komponenten anwendet, die diese Grenzwerte unterstützen. Wenn die AWS IoT Greengrass Core-Software eine Komponente ausführt, wendet sie die Systemressourcenlimits an, die Sie für diese Komponente angeben. Wenn diese Komponente keine Systemressourcenlimits festlegt, wendet die AWS IoT Greengrass Core-Software die standardmäßigen Systemressourcenlimits an, die Sie für das Kerngerät konfigurieren. Wenn Sie keine standardmäßigen Systemressourcenlimits angeben, wendet die AWS IoT Greengrass Core-Software standardmäßig keine Systemressourcenlimits an. Weitere Informationen finden Sie unter [Konfigurieren Sie die Standardgrenzwerte für Systemressourcen](#configure-default-component-system-resource-limits).
### Konfigurieren Sie die Standardgrenzwerte für Systemressourcen
Sie können die [Greengrass Nucleus-Komponente](greengrass-nucleus-component.md) einsetzen, um die standardmäßigen Systemressourcenlimits für ein Kerngerät zu konfigurieren. Um die standardmäßigen Systemressourcenlimits zu konfigurieren, [erstellen Sie eine Bereitstellung](create-deployments.md), die das folgende Konfigurationsupdate für die `aws.greengrass.Nucleus` Komponente spezifiziert.
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
Das folgende Beispiel definiert eine Bereitstellung, bei der das CPU-Zeitlimit auf konfiguriert wird`2`, was einer Auslastung von 50% auf einem Gerät mit 4 CPU-Kernen entspricht. In diesem Beispiel wird auch die Speichernutzung auf 100 MB konfiguriert.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy
AWS IoT Greengrass Kerngeräte kommunizieren über das MQTT-Messaging-Protokoll mit TLS-Client-Authentifizierung mit. AWS IoT Core Standardmäßig verwendet MQTT über TLS den Port 8883. Doch als Sicherheitsmaßnahme können restriktive Umgebungen den ein- und ausgehenden Datenverkehr auf einen kleinen Bereich von TCP-Ports einschränken. Zum Beispiel könnte eine Unternehmens-Firewall Port 443 für HTTPS-Datenverkehr öffnen, andere Ports, die für weniger geläufige Protokolle genutzt werden, wie z. B. Port 8883, für MQTT-Datenverkehr schließen. In anderen restriktiven Umgebungen muss der gesamte Datenverkehr möglicherweise über einen Proxy geleitet werden, bevor eine Verbindung zum Internet hergestellt wird.
**Anmerkung**
Greengrass-Core-Geräte, auf denen [Greengrass Nucleus Component](greengrass-nucleus-component.md) v2.0.3 und früher ausgeführt wird, verwenden Port 8443, um eine Verbindung zum Datenebenen-Endpunkt herzustellen. AWS IoT Greengrass Diese Geräte müssen in der Lage sein, über Port 8443 eine Verbindung zu diesem Endpunkt herzustellen. Weitere Informationen finden Sie unter [Geräteverkehr über einen Proxy oder eine Firewall zulassen](allow-device-traffic.md).
AWS IoT Greengrass Stellt die folgenden Konfigurationsoptionen zur Verfügung, um die Kommunikation in diesen Szenarien zu ermöglichen:
+ **MQTT-Kommunikation über Port 443**. Wenn Ihr Netzwerk Verbindungen zu Port 443 zulässt, können Sie das Greengrass-Core-Gerät so konfigurieren, dass es Port 443 für MQTT-Verkehr anstelle des Standardports 8883 verwendet. Dabei kann es sich um eine direkte Verbindung mit Port 443 oder eine Verbindung über einen Netzwerk-Proxy-Server handeln. [Im Gegensatz zur Standardkonfiguration, die eine zertifikatsbasierte Client-Authentifizierung verwendet, verwendet MQTT auf Port 443 die Gerätedienstrolle für die Authentifizierung.](device-service-role.md)
Weitere Informationen finden Sie unter [Konfigurieren Sie MQTT über Port 443](#configure-mqtt-port-443).
+ **HTTPS-Kommunikation über Port 443.** Die AWS IoT Greengrass Core-Software sendet standardmäßig HTTPS-Verkehr über Port 8443, aber Sie können sie so konfigurieren, dass Port 443 verwendet wird. AWS IoT Greengrass verwendet die TLS-Erweiterung [Application Layer Protocol Network](https://tools.ietf.org/html/rfc7301) (ALPN), um diese Verbindung zu aktivieren. Wie bei der Standardkonfiguration verwendet HTTPS auf Port 443 die zertifikatsbasierte Clientauthentifizierung.
**Wichtig**
Um ALPN zu verwenden und die HTTPS-Kommunikation über Port 443 zu aktivieren, muss auf Ihrem Kerngerät Java 8 Update 252 oder höher ausgeführt werden. Alle Updates von Java Version 9 und höher unterstützen auch ALPN.
Weitere Informationen finden Sie unter [Konfigurieren Sie HTTPS über Port 443](#configure-https-port-443).
+ **Verbindung über einen Netzwerk-Proxy**. Sie können einen Netzwerk-Proxyserver so konfigurieren, dass er als Vermittler für die Verbindung zum Greengrass-Core-Gerät fungiert. AWS IoT Greengrass unterstützt die Standardauthentifizierung für HTTP- und HTTPS-Proxys.
Greengrass-Core-Geräte müssen [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 oder höher ausführen, um HTTPS-Proxys verwenden zu können.
Die AWS IoT Greengrass Core-Software übergibt die Proxykonfiguration über die Umgebungsvariablen`ALL_PROXY`,, `HTTP_PROXY` und an die Komponenten. `HTTPS_PROXY` `NO_PROXY` Komponenten müssen diese Einstellungen verwenden, um eine Verbindung über den Proxy herzustellen. Komponenten verwenden gängige Bibliotheken (wie boto3, cURL und das `requests` Python-Paket), die normalerweise diese Umgebungsvariablen standardmäßig verwenden, um Verbindungen herzustellen. Wenn eine Komponente auch diese Umgebungsvariablen spezifiziert, überschreibt AWS IoT Greengrass sie sie nicht.
Weitere Informationen finden Sie unter [Konfigurieren Sie einen Netzwerk-Proxy](#configure-network-proxy).
### Konfigurieren Sie MQTT über Port 443
Sie können MQTT über Port 443 auf vorhandenen Kerngeräten konfigurieren oder wenn Sie die AWS IoT Greengrass Core-Software auf einem neuen Kerngerät installieren.
**Topics**
+ [Konfigurieren Sie MQTT über Port 443 auf vorhandenen Kerngeräten](#configure-mqtt-port-443-deployment)
+ [Konfigurieren Sie MQTT während der Installation über Port 443](#configure-mqtt-port-443-installer)
#### Konfigurieren Sie MQTT über Port 443 auf vorhandenen Kerngeräten
Sie können eine Bereitstellung verwenden, um MQTT über Port 443 auf einem einzelnen Core-Gerät oder einer Gruppe von Core-Geräten zu konfigurieren. In dieser Bereitstellung aktualisieren Sie die [Nucleus-Komponentenkonfiguration](greengrass-nucleus-component.md). Der Nucleus wird neu gestartet, wenn Sie seine `mqtt` Konfiguration aktualisieren.
Um MQTT über Port 443 zu konfigurieren, [erstellen Sie ein Deployment](create-deployments.md), das das folgende Konfigurationsupdate für die `aws.greengrass.Nucleus` Komponente spezifiziert.
```
{
"mqtt": {
"port": 443
}
}
```
Das folgende Beispiel definiert eine Bereitstellung, die MQTT über Port 443 konfiguriert. Das `merge` Konfigurationsupdate erfordert ein serialisiertes JSON-Objekt.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### Konfigurieren Sie MQTT während der Installation über Port 443
Sie können MQTT über Port 443 konfigurieren, wenn Sie die AWS IoT Greengrass Core-Software auf einem Core-Gerät installieren. Verwenden Sie das `--init-config` Installer-Argument, um MQTT über Port 443 zu konfigurieren. [Sie können dieses Argument angeben, wenn Sie die Installation mit [manueller Bereitstellung](manual-installation.md), [Flottenbereitstellung oder benutzerdefinierter Bereitstellung](fleet-provisioning.md) durchführen.](custom-provisioning.md)
### Konfigurieren Sie HTTPS über Port 443
Für diese Funktion ist Version [Grüngraskern](greengrass-nucleus-component.md) 2.0.4 oder höher erforderlich.
Sie können HTTPS über Port 443 auf vorhandenen Core-Geräten oder bei der Installation der AWS IoT Greengrass Core-Software auf einem neuen Core-Gerät konfigurieren.
**Topics**
+ [Konfigurieren Sie HTTPS über Port 443 auf vorhandenen Core-Geräten](#configure-https-port-443-deployment)
+ [Konfigurieren Sie HTTPS während der Installation über Port 443](#configure-https-port-443-installer)
#### Konfigurieren Sie HTTPS über Port 443 auf vorhandenen Core-Geräten
Sie können eine Bereitstellung verwenden, um HTTPS über Port 443 auf einem einzelnen Core-Gerät oder einer Gruppe von Core-Geräten zu konfigurieren. In dieser Bereitstellung aktualisieren Sie die [Nucleus-Komponentenkonfiguration](greengrass-nucleus-component.md).
Um HTTPS über Port 443 zu konfigurieren, [erstellen Sie eine Bereitstellung](create-deployments.md), die das folgende Konfigurationsupdate für die `aws.greengrass.Nucleus` Komponente spezifiziert.
```
{
"greengrassDataPlanePort": 443
}
```
Das folgende Beispiel definiert eine Bereitstellung, die HTTPS über Port 443 konfiguriert. Das `merge` Konfigurationsupdate erfordert ein serialisiertes JSON-Objekt.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### Konfigurieren Sie HTTPS während der Installation über Port 443
Sie können HTTPS über Port 443 konfigurieren, wenn Sie die AWS IoT Greengrass Core-Software auf einem Core-Gerät installieren. Verwenden Sie das `--init-config` Installer-Argument, um HTTPS über Port 443 zu konfigurieren. Sie können dieses Argument angeben, wenn Sie die Installation mit [manueller Bereitstellung](manual-installation.md), [Flottenbereitstellung oder [benutzerdefinierter](custom-provisioning.md) Bereitstellung](fleet-provisioning.md) durchführen.
### Konfigurieren Sie einen Netzwerk-Proxy
Gehen Sie wie in diesem Abschnitt beschrieben vor, um Greengrass-Core-Geräte so zu konfigurieren, dass sie sich über einen HTTP- oder HTTPS-Netzwerk-Proxy mit dem Internet verbinden. Weitere Informationen zu den Endpunkten und Anschlüssen, die Kerngeräte verwenden, finden Sie unter. [Geräteverkehr über einen Proxy oder eine Firewall zulassen](allow-device-traffic.md)
**Wichtig**
Wenn auf Ihrem Kerngerät eine Version von [Greengrass Nucleus](greengrass-nucleus-component.md) vor v2.4.0 ausgeführt wird, muss die Rolle Ihres Geräts die folgenden Berechtigungen für die Verwendung eines Netzwerk-Proxys zulassen:
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
Dies ist notwendig, da das Gerät AWS Anmeldeinformationen vom Token-Austauschdienst verwendet, um MQTT-Verbindungen zu authentifizieren. AWS IoT Das Gerät verwendet MQTT, um Bereitstellungen vom zu empfangen und zu installieren. Ihr Gerät funktioniert also nur AWS Cloud, wenn Sie diese Berechtigungen für seine Rolle definieren. Geräte verwenden normalerweise X.509-Zertifikate, um MQTT-Verbindungen zu authentifizieren, aber Geräte können dies nicht tun, um sich zu authentifizieren, wenn sie einen Proxy verwenden.
Weitere Informationen zur Konfiguration der Geräterolle finden Sie unter. [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md)
**Topics**
+ [Konfigurieren Sie einen Netzwerk-Proxy auf vorhandenen Core-Geräten](#configure-network-proxy-deployment)
+ [Konfigurieren Sie während der Installation einen Netzwerk-Proxy](#configure-network-proxy-installer)
+ [Ermöglichen Sie dem Kerngerät, einem HTTPS-Proxy zu vertrauen](#https-proxy-certificate-trust)
+ [Das NetworkProxy-Objekt](#network-proxy-object)
#### Konfigurieren Sie einen Netzwerk-Proxy auf vorhandenen Core-Geräten
Sie können eine Bereitstellung verwenden, um einen Netzwerk-Proxy auf einem einzelnen Core-Gerät oder einer Gruppe von Core-Geräten zu konfigurieren. In dieser Bereitstellung aktualisieren Sie die [Nucleus-Komponentenkonfiguration](greengrass-nucleus-component.md). Der Nucleus wird neu gestartet, wenn Sie seine `networkProxy` Konfiguration aktualisieren.
Um einen Netzwerk-Proxy zu konfigurieren, [erstellen Sie ein Deployment](create-deployments.md) für die `aws.greengrass.Nucleus` Komponente, die das folgende Konfigurationsupdate zusammenführt. Dieses Konfigurationsupdate enthält das [NetworkProxy-Objekt](#network-proxy-object).
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
Das folgende Beispiel definiert eine Bereitstellung, die einen Netzwerk-Proxy konfiguriert. Das `merge` Konfigurationsupdate erfordert ein serialisiertes JSON-Objekt.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### Konfigurieren Sie während der Installation einen Netzwerk-Proxy
Sie können einen Netzwerk-Proxy konfigurieren, wenn Sie die AWS IoT Greengrass Core-Software auf einem Core-Gerät installieren. Verwenden Sie das `--init-config` Installer-Argument, um den Netzwerk-Proxy zu konfigurieren. Sie können dieses Argument angeben, wenn Sie die Installation mit [manueller Bereitstellung](manual-installation.md), [Flottenbereitstellung oder [benutzerdefinierter](custom-provisioning.md) Bereitstellung](fleet-provisioning.md) durchführen.
#### Ermöglichen Sie dem Kerngerät, einem HTTPS-Proxy zu vertrauen
Wenn Sie ein Kerngerät für die Verwendung eines HTTPS-Proxys konfigurieren, müssen Sie die Zertifikatskette des Proxyservers zu der Zertifikatskette des Kerngeräts hinzufügen, damit es dem HTTPS-Proxy vertrauen kann. Andernfalls könnten auf dem Kerngerät Fehler auftreten, wenn es versucht, den Verkehr über den Proxy weiterzuleiten. Fügen Sie das Proxy-Server-CA-Zertifikat zur Amazon-Root-CA-Zertifikatsdatei des Kerngeräts hinzu.
**Um dem Kerngerät zu ermöglichen, dem HTTPS-Proxy zu vertrauen**
1. Suchen Sie die Amazon-Root-CA-Zertifikatsdatei auf dem Kerngerät.
+ Wenn Sie die AWS IoT Greengrass Core-Software mit [automatischer Bereitstellung installiert haben, befindet](quick-installation.md) sich die Amazon-Root-CA-Zertifikatsdatei unter`/greengrass/v2/rootCA.pem`.
+ Wenn Sie die AWS IoT Greengrass Core-Software mit [manueller](manual-installation.md) oder [Flottenbereitstellung](fleet-provisioning.md) installiert haben, befindet sich die Amazon-Root-CA-Zertifikatsdatei möglicherweise unter`/greengrass/v2/AmazonRootCA1.pem`.
Wenn das Amazon-Root-CA-Zertifikat an diesen Standorten nicht vorhanden ist, überprüfen Sie die `system.rootCaPath` Immobilie unter, `/greengrass/v2/config/effectiveConfig.yaml` um den Speicherort zu ermitteln.
1. Fügen Sie den Inhalt der Proxyserver-CA-Zertifikatsdatei zur Amazon-Root-CA-Zertifikatsdatei hinzu.
Das folgende Beispiel zeigt ein Proxyserver-CA-Zertifikat, das der Amazon-Root-CA-Zertifikatsdatei hinzugefügt wurde.
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### Das NetworkProxy-Objekt
Geben Sie mithilfe des `networkProxy`-Objekts Informationen zum Netzwerk-Proxy an. Dieses Objekt enthält die folgenden Informationen:
`noProxyAddresses`
(Optional) Eine durch Kommas getrennte Liste von IP-Adressen oder Hostnamen, die vom Proxy ausgenommen sind.
`proxy`
Der Proxy, zu dem eine Verbindung hergestellt werden soll. Dieses Objekt enthält die folgenden Informationen:
`url`
Die URL des Proxyservers im Format`scheme://userinfo@host:port`.
+ `scheme`— Das Schema, das `http` oder sein muss`https`.
**Wichtig**
Greengrass-Core-Geräte müssen [Greengrass Nucleus](greengrass-nucleus-component.md) v2.5.0 oder höher ausführen, um HTTPS-Proxys verwenden zu können.
Wenn Sie einen HTTPS-Proxy konfigurieren, müssen Sie das Proxy-Server-CA-Zertifikat zum Amazon-Root-CA-Zertifikat des Kerngeräts hinzufügen. Weitere Informationen finden Sie unter [Ermöglichen Sie dem Kerngerät, einem HTTPS-Proxy zu vertrauen](#https-proxy-certificate-trust).
+ `userinfo`— (Optional) Der Benutzername und das Passwort. Wenn Sie diese Informationen in der angeben`url`, ignoriert das Greengrass-Core-Gerät die Felder `username` und`password`.
+ `host`— Der Hostname oder die IP-Adresse des Proxyservers.
+ `port`— (Optional) Die Portnummer. Wenn Sie den Port nicht angeben, verwendet das Greengrass-Core-Gerät die folgenden Standardwerte:
+ `http`— 80
+ `https`— 443
`username`
(Optional) Der Benutzername, der den Proxyserver authentifiziert.
`password`
(Optional) Das Passwort, das den Proxyserver authentifiziert.
## Verwenden Sie ein Gerätezertifikat, das von einer privaten Zertifizierungsstelle signiert wurde
Wenn Sie eine benutzerdefinierte private Zertifizierungsstelle (CA) verwenden, müssen Sie die Greengrass-Kerne auf setzen. **greengrassDataPlaneEndpoint** **iotdata** Sie können diese Option während der Bereitstellung oder Installation mithilfe des **--init-config** [Installer-Arguments](configure-installer.md) festlegen.
Sie können den Endpunkt der Greengrass-Datenebene anpassen, an den das Gerät eine Verbindung herstellt. Sie können diese Konfigurationsoption auf einstellen, **iotdata** um den Endpunkt der Greengrass-Datenebene auf denselben Endpunkt wie den IoT-Datenendpunkt festzulegen, den Sie mit dem **iotDataEndpoint** angeben können.
## Konfigurieren Sie MQTT-Timeouts und Cache-Einstellungen
In der AWS IoT Greengrass Umgebung können Komponenten MQTT verwenden, um mit ihnen zu kommunizieren. AWS IoT Core Die AWS IoT Greengrass Core-Software verwaltet MQTT-Nachrichten für Komponenten. Wenn das Kerngerät die Verbindung zum verliert AWS Cloud, speichert die Software MQTT-Nachrichten im Cache, um es später erneut zu versuchen, wenn die Verbindung wiederhergestellt ist. Sie können Einstellungen wie Nachrichten-Timeouts und die Größe des Caches konfigurieren. Weitere Informationen finden Sie in den `mqtt` und den `mqtt.spooler` Konfigurationsparametern der [Greengrass Nucleus-Komponente](greengrass-nucleus-component.md).
AWS IoT Core legt seinem MQTT-Nachrichtenbroker Dienstkontingente fest. Diese Kontingente gelten möglicherweise für Nachrichten, die Sie zwischen Kerngeräten und senden. AWS IoT Core Weitere Informationen finden Sie unter [Kontingente für den AWS IoT Core Message Broker-Service](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits) in der *Allgemeine AWS-Referenz*.
## Greengrass Nucleus im Netzwerk IPv6 konfigurieren
Greengrass Nucleus spricht AWS IoT Core über [ APIsGreengrass](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) mit. APIs Greengrass-Unterstützung in einer IPv6 Dual-Stack-Umgebung.
Um Dual-Stack-Endpunkte zu aktivieren für: IPv6
+ Fügen Sie Systemeigenschaften `aws.useDualstackEndpoint=true` hinzu und zu `java.net.preferIPv6Addresses=true` `jvmOptions`
+ Setzen Sie `s3EndpointType` auf `DUALSTACK`
Legen Sie diese Option während der [Bereitstellung](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) fest, oder stellen Sie sie manuell mit dem `--init-config` [Installer-Argument bereit](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html). Weitere Informationen finden Sie [unter Verwenden von Amazon S3 S3-Dual-Stack-Endpunkten](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html).
**Example Code für die Bereitstellung:**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example `config.yaml`durch manuelle Bereitstellung:**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# Aktualisieren Sie die AWS IoT Greengrass Core-Software (OTA)
Die AWS IoT Greengrass Core-Software besteht aus der [Greengrass Nucleus-Komponente](greengrass-nucleus-component.md) und anderen optionalen Komponenten, die Sie auf Ihren Geräten bereitstellen können, um over-the-air (OTA) -Updates der Software durchzuführen. Diese Funktion ist in die AWS IoT Greengrass Core-Software integriert.
OTA-Updates machen Folgendes effizienter:
+ Schließen von Sicherheitslücken.
+ Behebung von Software-Stabilitätsproblemen.
+ Bereitstellung neuer oder verbesserter Funktionen.
**Topics**
+ [Voraussetzungen](#ota-update-requirements)
+ [Überlegungen zu Kerngeräten](#ota-update-considerations)
+ [Aktualisierungsverhalten von Greengrass Nucleus](#ota-update-behavior-nucleus)
+ [Führen Sie ein OTA-Update durch](#create-ota-update)
## Voraussetzungen
Für die Bereitstellung von OTA-Updates der AWS IoT Greengrass Core-Software gelten die folgenden Anforderungen:
+ Das Greengrass-Core-Gerät muss über eine Verbindung zum verfügen, AWS Cloud um die Bereitstellung zu empfangen.
+ Das Greengrass-Core-Gerät muss korrekt konfiguriert und mit Zertifikaten und Schlüsseln für die Authentifizierung mit AWS IoT Core und ausgestattet sein. AWS IoT Greengrass
+ Die AWS IoT Greengrass Core-Software muss als Systemdienst eingerichtet und ausgeführt werden. OTA-Updates funktionieren nicht, wenn Sie den Nucleus über die JAR-Datei ausführen,`Greengrass.jar`. Weitere Informationen finden Sie unter [Den Greengrass Nucleus als Systemdienst konfigurieren](configure-greengrass-core-v2.md#configure-system-service).
## Überlegungen zu Kerngeräten
Bevor Sie ein OTA-Update durchführen, sollten Sie sich der Auswirkungen auf die Kerngeräte, die Sie aktualisieren, und deren verbundene Client-Geräte bewusst sein:
+ Der Greengrass-Kern wird abgeschaltet.
+ Alle Komponenten, die auf dem Kerngerät laufen, werden ebenfalls heruntergefahren. Wenn diese Komponenten auf lokale Ressourcen schreiben, können sie diese Ressourcen in einem falschen Zustand belassen, sofern sie nicht ordnungsgemäß heruntergefahren werden. Komponenten können die [Interprozesskommunikation](interprocess-communication.md) verwenden, um der Nucleus-Komponente mitzuteilen, dass sie die Aktualisierung zurückstellen soll, bis sie die von ihnen verwendeten Ressourcen bereinigt haben.
+ Während die Nucleus-Komponente heruntergefahren wird, verliert das Core-Gerät seine Verbindungen zu den AWS Cloud und den lokalen Geräten. Das Kerngerät leitet während des Herunterfahrens keine Nachrichten von Client-Geräten weiter.
+ Langlebige Lambda-Funktionen, die als Komponenten ausgeführt werden, verlieren ihre dynamischen Statusinformationen und verwerfen alle ausstehenden Aufgaben.
## Aktualisierungsverhalten von Greengrass Nucleus
Wenn Sie eine Komponente bereitstellen, werden die neuesten unterstützten Versionen aller Abhängigkeiten dieser Komponente AWS IoT Greengrass installiert. Aus diesem Grund werden neue Patch-Versionen von AWS bereitgestellten öffentlichen Komponenten möglicherweise automatisch auf Ihren Kerngeräten bereitgestellt, wenn Sie einer Dinggruppe neue Geräte hinzufügen oder wenn Sie die Bereitstellung aktualisieren, die auf diese Geräte abzielt. Einige automatische Updates, wie z. B. ein Nucleus-Update, können dazu führen, dass Ihre Geräte unerwartet neu gestartet werden.
Wenn sich die Version der [Greengrass Nucleus-Komponente](greengrass-nucleus-component.md) ändert, wird die AWS IoT Greengrass Core-Software — die den Nucleus und alle anderen Komponenten auf Ihrem Gerät umfasst — neu gestartet, um die Änderungen zu übernehmen. Aufgrund der [Auswirkungen auf die Kerngeräte](#ota-update-considerations), wenn die Nucleus-Komponente aktualisiert wird, möchten Sie möglicherweise kontrollieren, wann eine neue Nucleus-Patch-Version auf Ihren Geräten bereitgestellt wird. Dazu müssen Sie die Greengrass Nucleus-Komponente direkt in Ihre Bereitstellung aufnehmen. Das direkte Einbeziehen einer Komponente bedeutet, dass Sie eine bestimmte Version dieser Komponente in Ihre Bereitstellungskonfiguration aufnehmen und sich nicht auf Komponentenabhängigkeiten verlassen, um diese Komponente auf Ihren Geräten bereitzustellen. Weitere Informationen zur Definition von Abhängigkeiten in Ihren Komponentenrezepten finden Sie unter[Rezeptformat](component-recipe-reference.md#recipe-format).
Sehen Sie sich die folgende Tabelle an, um das Aktualisierungsverhalten für die Greengrass Nucleus-Komponente auf der Grundlage Ihrer Aktionen und Bereitstellungskonfigurationen zu verstehen.
| Aktion | Bereitstellungskonfiguration | Verhalten beim Update von Nucleus |
| --- | --- | --- |
| Fügen Sie neue Geräte zu einer Dinggruppe hinzu, auf die eine bestehende Bereitstellung abzielt, ohne die Bereitstellung zu überarbeiten. | Die Bereitstellung umfasst nicht direkt den Greengrass-Nukleus.Die Bereitstellung umfasst direkt mindestens eine von AWS-bereitgestellte Komponente oder eine benutzerdefinierte Komponente, die von einer von AWS-bereitgestellten Komponente oder vom Greengrass-Kern abhängt. | Installiert auf neuen Geräten die neueste Patch-Version von Nucleus, die alle Anforderungen an die Abhängigkeit von Komponenten erfüllt.Auf vorhandenen Geräten wird die installierte Version von Nucleus nicht aktualisiert. |
| Fügen Sie neue Geräte zu einer Dinggruppe hinzu, auf die eine bestehende Bereitstellung abzielt, ohne die Bereitstellung zu überarbeiten. | Die Bereitstellung umfasst direkt eine bestimmte Version des Greengrass-Kerns. | Installiert auf neuen Geräten die angegebene Nucleus-Version.Auf vorhandenen Geräten wird die installierte Version von Nucleus nicht aktualisiert. |
| Erstellen Sie ein neues Deployment oder überarbeiten Sie ein bestehendes Deployment. | Die Bereitstellung umfasst nicht direkt den Greengrass-Nukleus.Die Bereitstellung umfasst direkt mindestens eine von AWS-bereitgestellte Komponente oder eine benutzerdefinierte Komponente, die von einer von AWS-bereitgestellten Komponente oder vom Greengrass-Kern abhängt. | Installiert auf allen Zielgeräten die neueste Patch-Version des Nucleus, die alle Anforderungen an die Abhängigkeit von Komponenten erfüllt, auch auf allen neuen Geräten, die Sie der Zielgruppe hinzufügen. |
| Erstellen Sie ein neues Deployment oder überarbeiten Sie ein bestehendes Deployment. | Die Bereitstellung umfasst direkt eine bestimmte Version des Greengrass-Kerns. | Installiert auf allen Zielgeräten die angegebene Nucleus-Version, einschließlich aller neuen Geräte, die Sie der Ziel-Dinggruppe hinzufügen. |
## Führen Sie ein OTA-Update durch
Um ein OTA-Update durchzuführen, [erstellen Sie eine Bereitstellung](create-deployments.md), die die [Nucleus-Komponente](greengrass-nucleus-component.md) und die zu installierende Version enthält.
# Deinstallieren Sie die AWS IoT Greengrass Core-Software
Sie können die AWS IoT Greengrass Core-Software deinstallieren, um sie von einem Gerät zu entfernen, das Sie nicht als Greengrass-Core-Gerät verwenden möchten. Sie können diese Schritte auch verwenden, um eine fehlgeschlagene Installation zu bereinigen.
**Um die AWS IoT Greengrass Core-Software zu deinstallieren**
1. Wenn Sie die Software als Systemdienst ausführen, müssen Sie den Dienst beenden, deaktivieren und entfernen. Führen Sie die folgenden Befehle entsprechend Ihrem Betriebssystem aus.
------
#### [ Linux ]
1. Stoppen Sie den Service .
```
sudo systemctl stop greengrass.service
```
1. Deaktivieren Sie den Dienst.
```
sudo systemctl disable greengrass.service
```
1. Entfernen Sie den Dienst.
```
sudo rm /etc/systemd/system/greengrass.service
```
1. Stellen Sie sicher, dass der Dienst gelöscht wurde.
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**Anmerkung**
Sie müssen die Eingabeaufforderung als Administrator ausführen, um diese Befehle auszuführen.
1. Stoppen Sie den Service .
```
sc stop "greengrass"
```
1. Deaktivieren Sie den Dienst.
```
sc config "greengrass" start=disabled
```
1. Entfernen Sie den Dienst.
```
sc delete "greengrass"
```
1. Starten Sie das Gerät neu.
------
#### [ Windows (PowerShell) ]
**Anmerkung**
Sie müssen PowerShell als Administrator ausführen, um diese Befehle ausführen zu können.
1. Stoppen Sie den Service .
```
Stop-Service -Name "greengrass"
```
1. Deaktivieren Sie den Dienst.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. Entfernen Sie den Dienst.
+ Für PowerShell 6.0 und höher:
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ Für PowerShell Versionen vor 6.0:
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. Starten Sie das Gerät neu.
------
1. Entfernen Sie den Stammordner vom Gerät. Ersetzen Sie `/greengrass/v2` oder *C:\$1greengrass\$1v2* durch den Pfad zum Stammordner.
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. Löschen Sie das Kerngerät aus dem AWS IoT Greengrass Dienst. Dieser Schritt entfernt die Statusinformationen des Kerngeräts aus dem AWS Cloud. Schließen Sie diesen Schritt unbedingt ab, wenn Sie die AWS IoT Greengrass Core-Software auf einem Kerngerät mit demselben Namen erneut installieren möchten.
+ Gehen Sie wie folgt vor, um ein Core-Gerät von der AWS IoT Greengrass Konsole zu löschen:
1. Navigieren Sie zur [AWS IoT Greengrass -Konsole](https://console.aws.amazon.com/greengrass).
1. Wählen Sie **Core-Geräte**.
1. Wählen Sie das zu löschende Kerngerät aus.
1. Wählen Sie **Löschen**.
1. Wählen Sie im Bestätigungsmodus die Option **Löschen** aus.
+ Verwenden Sie den [DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html)Vorgang AWS Command Line Interface, um ein Kerngerät mit dem zu löschen. Führen Sie den folgenden Befehl aus und *MyGreengrassCore* ersetzen Sie ihn durch den Namen des Kerngeräts.
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```