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.
# Schritt 2: Richten Sie Ihre Umgebung ein
**Anmerkung**
Diese Schritte gelten nicht für Nucleus Lite.
Folgen Sie den Schritten in diesem Abschnitt, um ein Linux- oder Windows-Gerät einzurichten, das als Ihr AWS IoT Greengrass Kerngerät verwendet werden soll.
## Richten Sie ein Linux-Gerät (Raspberry Pi) ein
Bei diesen Schritten wird davon ausgegangen, dass Sie einen Raspberry Pi mit Raspberry Pi OS verwenden. Wenn Sie ein anderes Gerät oder Betriebssystem verwenden, schlagen Sie in der entsprechenden Dokumentation für Ihr Gerät nach.
**Um einen Raspberry Pi einzurichten für AWS IoT Greengrass V2**
1. Aktivieren Sie SSH auf Ihrem Raspberry Pi, um eine Remoteverbindung herzustellen. Weitere Informationen finden Sie unter [SSH (Secure Shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) in der *Raspberry Pi-Dokumentation*.
1. Suchen Sie die IP-Adresse Ihres Raspberry Pi, um eine Verbindung mit ihm über SSH herzustellen. Dazu können Sie den folgenden Befehl auf Ihrem Raspberry Pi ausführen.
```
hostname -I
```
1. Stellen Sie mit SSH Connect zu Ihrem Raspberry Pi her.
Führen Sie auf Ihrem Entwicklungscomputer den folgenden Befehl aus. *username*Ersetzen Sie ihn durch den Namen des Benutzers, der sich anmelden soll, und *pi-ip-address* ersetzen Sie ihn durch die IP-Adresse, die Sie im vorherigen Schritt gefunden haben.
```
ssh username@pi-ip-address
```
**Wichtig**
Wenn Ihr Entwicklungscomputer eine frühere Version von Windows verwendet, verfügen Sie möglicherweise nicht über den `ssh` Befehl, oder Sie haben möglicherweise keine Verbindung zu Ihrem Raspberry Pi hergestellt, können `ssh` aber keine Verbindung herstellen. Um eine Verbindung zu Ihrem Raspberry Pi herzustellen, können Sie [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) installieren und konfigurieren, einen kostenlosen Open-Source-SSH-Client. Konsultieren Sie die [PuTTY-Dokumentation](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs), um eine Verbindung zu Ihrem Raspberry Pi herzustellen.
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Verwenden Sie auf Ihrem Raspberry Pi die folgenden Befehle, um Java 11 zu installieren.
```
sudo apt install default-jdk
```
Wenn die Installation abgeschlossen ist, führen Sie den folgenden Befehl aus, um zu überprüfen, ob Java auf Ihrem Raspberry Pi ausgeführt wird.
```
java -version
```
Der Befehl druckt die Version von Java, die auf dem Gerät ausgeführt wird. Die Ausgabe könnte dem folgenden Beispiel ähneln.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Tipp: Stellen Sie die Kernel-Parameter auf einem Raspberry Pi ein**
Wenn es sich bei Ihrem Gerät um einen Raspberry Pi handelt, können Sie die folgenden Schritte ausführen, um die Linux-Kernel-Parameter anzuzeigen und zu aktualisieren:
Öffnen Sie die `/boot/cmdline.txt` Datei. Diese Datei spezifiziert die Linux-Kernel-Parameter, die beim Booten des Raspberry Pi angewendet werden sollen.
Auf einem Linux-basierten System können Sie beispielsweise den folgenden Befehl ausführen, um die Datei mit GNU Nano zu öffnen.
```
sudo nano /boot/cmdline.txt
```
Stellen Sie sicher, dass die `/boot/cmdline.txt` Datei die folgenden Kernel-Parameter enthält. Der `systemd.unified_cgroup_hierarchy=0` Parameter gibt an, dass cgroups v1 statt cgroups v2 verwendet werden soll.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Wenn die `/boot/cmdline.txt` Datei diese Parameter nicht oder diese Parameter mit unterschiedlichen Werten enthält, aktualisieren Sie die Datei, sodass sie diese Parameter und Werte enthält.
Wenn Sie die `/boot/cmdline.txt` Datei aktualisiert haben, starten Sie den Raspberry Pi neu, um die Änderungen zu übernehmen.
```
sudo reboot
```
## Richten Sie ein Linux-Gerät ein (anderes)
**Um ein Linux-Gerät einzurichten für AWS IoT Greengrass V2**
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Wir empfehlen, dass Sie die [Langzeit-Support-Versionen von Amazon Corretto](https://aws.amazon.com/corretto/) oder [OpenJDK](https://openjdk.java.net/) verwenden. Version 8 oder höher ist erforderlich. Die folgenden Befehle zeigen Ihnen, wie Sie OpenJDK auf Ihrem Gerät installieren.
+ Für Debian- oder Ubuntu-basierte Distributionen:
```
sudo apt install default-jdk
```
+ Für Red Hat-basierte Distributionen:
```
sudo yum install java-11-openjdk-devel
```
+ Für Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Für Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Führen Sie nach Abschluss der Installation den folgenden Befehl aus, um zu überprüfen, ob Java auf Ihrem Linux-Gerät ausgeführt wird.
```
java -version
```
Der Befehl druckt die Version von Java, die auf dem Gerät ausgeführt wird. Bei einer Debian-basierten Distribution könnte die Ausgabe beispielsweise dem folgenden Beispiel ähneln.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Optional) Erstellen Sie den Standardsystembenutzer und die Standardgruppe, die Komponenten auf dem Gerät ausführen. Sie können auch festlegen, dass der AWS IoT Greengrass Core-Software-Installer diesen Benutzer und diese Gruppe während der Installation mit dem `--component-default-user` Installer-Argument erstellt. Weitere Informationen finden Sie unter [Argumente des Installers](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Stellen Sie sicher, dass der Benutzer, der die AWS IoT Greengrass Core-Software ausführt (normalerweise`root`), über die erforderlichen Rechte verfügt, die Software `sudo` mit jedem beliebigen Benutzer und jeder Gruppe auszuführen.
1. Führen Sie den folgenden Befehl aus, um die `/etc/sudoers` Datei zu öffnen.
```
sudo visudo
```
1. Stellen Sie sicher, dass die Berechtigung für den Benutzer wie im folgenden Beispiel aussieht.
```
root ALL=(ALL:ALL) ALL
```
1. *(Optional) Um [containerisierte Lambda-Funktionen auszuführen](run-lambda-functions.md), müssen Sie [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 aktivieren und Sie müssen die *Speicher* - und Geräte-Cgroups aktivieren und mounten.* Wenn Sie nicht vorhaben, containerisierte Lambda-Funktionen auszuführen, können Sie diesen Schritt überspringen.
Um diese Cgroups-Optionen zu aktivieren, starten Sie das Gerät mit den folgenden Linux-Kernelparametern.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Informationen zum Anzeigen und Einstellen der Kernel-Parameter für Ihr Gerät finden Sie in der Dokumentation zu Ihrem Betriebssystem und Bootloader. Folgen Sie den Anweisungen, um die Kernel-Parameter dauerhaft einzustellen.
1. Installieren Sie alle anderen erforderlichen Abhängigkeiten auf Ihrem Gerät, wie in der Liste der Anforderungen unter angegeben[Anforderungen an Speichergeräte](greengrass-nucleus-component.md#greengrass-v2-requirements).
## Richten Sie ein Windows-Gerät ein
**Um ein Windows-Gerät einzurichten für AWS IoT Greengrass V2**
1. Installieren Sie die Java-Runtime, die für die Ausführung der AWS IoT Greengrass Core-Software erforderlich ist. Wir empfehlen, dass Sie die [Langzeit-Support-Versionen von Amazon Corretto](https://aws.amazon.com/corretto/) oder [OpenJDK](https://openjdk.java.net/) verwenden. Version 8 oder höher ist erforderlich.
1. Prüfen Sie, ob Java in der Systemvariablen [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) verfügbar ist, und fügen Sie es hinzu, falls nicht. Auf dem LocalSystem Konto wird die AWS IoT Greengrass Core-Software ausgeführt, sodass Sie der Systemvariablen PATH statt der Benutzervariablen PATH für Ihren Benutzer Java hinzufügen müssen. Gehen Sie wie folgt vor:
1. Drücken Sie die Windows-Taste, um das Startmenü zu öffnen.
1. Geben Sie **environment variables** ein, um im Startmenü nach den Systemoptionen zu suchen.
1. Wählen Sie in den Suchergebnissen des Startmenüs **die Option Systemumgebungsvariablen bearbeiten** aus, um das Fenster mit den **Systemeigenschaften** zu öffnen.
1. Wählen Sie **Umgebungsvariablen...** um das Fenster **Umgebungsvariablen** zu öffnen.
1. Wählen Sie unter **Systemvariablen** die Option **Pfad** und dann **Bearbeiten** aus. Im Fenster **Umgebungsvariable bearbeiten** können Sie jeden Pfad in einer separaten Zeile anzeigen.
1. Überprüfen Sie, ob der Pfad zum `bin` Ordner der Java-Installation vorhanden ist. Der Pfad könnte dem folgenden Beispiel ähneln.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Wenn der `bin` Ordner der Java-Installation in **Path** fehlt, wählen Sie **Neu**, um ihn hinzuzufügen, und **klicken Sie dann auf OK**.
1. Öffnen Sie die Windows-Eingabeaufforderung (`cmd.exe`) als Administrator.
1. Erstellen Sie den Standardbenutzer für das LocalSystem Konto auf dem Windows-Gerät. *password*Durch ein sicheres Passwort ersetzen.
```
net user /add ggc_user password
```
**Tipp**
Abhängig von Ihrer Windows-Konfiguration ist das Benutzerkennwort möglicherweise so eingestellt, dass es an einem Datum in der future abläuft. Um sicherzustellen, dass Ihre Greengrass-Anwendungen weiterhin funktionieren, verfolgen Sie, wann das Passwort abläuft, und aktualisieren Sie es, bevor es abläuft. Sie können das Benutzerkennwort auch so einrichten, dass es niemals abläuft.
Führen Sie den folgenden Befehl aus, um zu überprüfen, wann ein Benutzer und sein Passwort ablaufen.
```
net user ggc_user | findstr /C:expires
```
Führen Sie den folgenden Befehl aus, um das Passwort eines Benutzers so einzustellen, dass es nie abläuft.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Wenn Sie Windows 10 oder höher verwenden und der [`wmic`Befehl veraltet ist](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), führen Sie den folgenden PowerShell Befehl aus.
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Laden Sie das [PsExecProgramm](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) von Microsoft herunter und installieren Sie es auf dem Gerät.
1. Verwenden Sie das PsExec Hilfsprogramm, um den Benutzernamen und das Passwort für den Standardbenutzer in der Credential Manager-Instanz für das LocalSystem Konto zu speichern. *password*Ersetzen Sie es durch das zuvor festgelegte Benutzerkennwort.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Wenn das **PsExec License Agreement**geöffnet wird, stimmen Sie **Accept**der Lizenz zu und führen Sie den Befehl aus.
**Anmerkung**
Auf Windows-Geräten wird auf dem LocalSystem Konto der Greengrass-Nucleus ausgeführt, und Sie müssen das PsExec Hilfsprogramm verwenden, um die Standardbenutzerinformationen im LocalSystem Konto zu speichern. Wenn Sie die Credential Manager-Anwendung verwenden, werden diese Informationen nicht im Konto, sondern im Windows-Konto des aktuell angemeldeten Benutzers gespeichert. LocalSystem