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.
# 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.17.0"
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.17.0*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.17.0"
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.