Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS wird der Support für eingestellt. AWS IoT Greengrass Version 1 Nach dem 7. Oktober 2026 können Sie nicht mehr auf die Ressourcen zugreifen. AWS IoT Greengrass V1 Weitere Informationen finden Sie unter [Migrieren von AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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.
# Den AWS IoT Greengrass Kern konfigurieren
Ein AWS IoT Greengrass Kern ist ein AWS IoT Ding (Gerät), das in Edge-Umgebungen als Hub oder Gateway fungiert. Wie andere AWS IoT Geräte ist auch ein Core in der Registrierung vorhanden, hat einen Geräteshadow und verwendet ein Gerätezertifikat, um sich mit AWS IoT Core und AWS IoT Greengrass zu authentifizieren. Das Core-Gerät führt die AWS IoT Greengrass -Core-Software aus. So kann es die lokalen Prozesse für Greengrass-Gruppen verwalten, z. B. Kommunikation, Schattensynchronisierung und Austausch des Tokens.
Die AWS IoT Greengrass Core-Software bietet die folgenden Funktionen:
+ Bereitstellung und lokale Ausführung von Konnektoren und Lambda-Funktionen.
+ Verarbeiten Sie Datenströme lokal mit automatischen Exporten in die AWS Cloud.
+ MQTT-Messaging über das lokale Netzwerk zwischen Geräten, Konnektoren und Lambda-Funktionen mithilfe verwalteter Abonnements.
+ MQTT-Messaging zwischen AWS IoT Geräten, Konnektoren und Lambda-Funktionen mithilfe verwalteter Abonnements.
+ Sichere Verbindungen zwischen Geräten und AWS Cloud Nutzung der Geräteauthentifizierung und -autorisierung.
+ Lokale Shadow-Synchronisierung von Geräten. Shadows können so konfiguriert werden, dass sie mit dem synchronisiert werden AWS Cloud.
+ Kontrollierter Zugriff auf lokale Geräte- und Volume-Ressourcen.
+ Bereitstellung von Modellen für das maschinelle Lernen, die in der Cloud geschult werden, für die Ausführung lokaler Inferenzen.
+ Automatische Erkennung von IP-Adressen, die Geräte in die Lage versetzt, das Greengrass Core-Gerät zu erkennen.
+ Zentrale Bereitstellung neuer oder aktualisierter Gruppenkonfigurationen. Nach dem Download der Konfigurationsdaten wird das Core-Gerät automatisch neu gestartet.
+ Sichere over-the-air (OTA) Softwareupdates von benutzerdefinierten Lambda-Funktionen.
+ Sichere, verschlüsselte Speicherung lokaler Geheimnisse und kontrollierter Zugriff durch Konnektoren und Lambda-Funktionen.
## AWS IoT Greengrass Kernkonfigurationsdatei
Die Konfigurationsdatei für die AWS IoT Greengrass Core-Software ist`config.json`. Sie befindet sich im Verzeichnis `/greengrass-root/config`.
**Anmerkung**
*greengrass-root*steht für den Pfad, in dem die AWS IoT Greengrass Core-Software auf Ihrem Gerät installiert ist. Normalerweise ist dies das Verzeichnis `/greengrass`.
Wenn Sie die Option **Standardgruppenerstellung** von der AWS IoT Greengrass Konsole aus verwenden, wird die `config.json` Datei in einem funktionierenden Zustand auf dem Core-Gerät bereitgestellt.
Sie können den Inhalt dieser Datei mit folgendem Befehl überprüfen:
```
cat /greengrass-root/config/config.json
```
Im Folgenden sehen Sie ein Beispiel für eine `config.json`-Datei. Dies ist die Version, die generiert wird, wenn Sie den Core von der AWS IoT Greengrass Konsole aus erstellen.
------
#### [ GGC v1.11 ]
```
{
"coreThing": {
"caPath": "root.ca.pem",
"certPath": "hash.cert.pem",
"keyPath": "hash.private.key",
"thingArn": "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix-ats.iot.region.amazonaws.com",
"ggHost": "greengrass-ats.iot.region.amazonaws.com",
"keepAlive": 600,
"ggDaemonPort": 8000,
"systemComponentAuthTimeout": 5000
},
"runtime": {
"maxWorkItemCount": 1024,
"maxConcurrentLimit": 25,
"lruSize": 25,
"mountAllBlockDevices": "no",
"cgroup": {
"useSystemd": "yes"
}
},
"managedRespawn": false,
"crypto": {
"principals": {
"SecretsManager": {
"privateKeyPath": "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate": {
"privateKeyPath": "file:///greengrass/certs/hash.private.key",
"certificatePath": "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath": "file:///greengrass/certs/root.ca.pem"
},
"writeDirectory": "/var/snap/aws-iot-greengrass/current/ggc-write-directory",
"pidFileDirectory": "/var/snap/aws-iot-greengrass/current/pidFileDirectory"
}
```
Die `config.json`-Datei unterstützt die folgenden Eigenschaften:
**coreThing**
| Feld | Description | Hinweise |
| --- | --- | --- |
| caPath | Der Pfad zur AWS IoT Stammzertifizierungsstelle relativ zum `/greengrass-root/certs` Verzeichnis. | Aus Gründen der Abwärtskompatibilität mit Versionen vor 1.7.0. Diese Eigenschaft wird ignoriert, wenn das `crypto` Objekt vorhanden ist. Stellen Sie sicher, dass Ihre [Endpunkte Ihrem Zertifikatstyp entsprechen](#certificate-endpoints). |
| certPath | Der Pfad zum Core-Gerätezertifikat, relativ zum Verzeichnis `/greengrass-root/certs`. | Aus Gründen der Abwärtskompatibilität mit Versionen vor 1.7.0. Diese Eigenschaft wird ignoriert, wenn das crypto Objekt vorhanden ist. |
| keyPath | Der Pfad zum privaten Core-Schlüssel, relativ zum Verzeichnis /greengrass-root/certs. | Aus Gründen der Abwärtskompatibilität mit Versionen vor 1.7.0. Diese Eigenschaft wird ignoriert, wenn das crypto Objekt vorhanden ist. |
| thingArn | Der Amazon-Ressourcenname (ARN) des AWS IoT Dings, das das AWS IoT Greengrass Kerngerät darstellt. | Suchen Sie den ARN für Ihren Core in der AWS IoT Greengrass Konsole unter Cores oder indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-core-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-core-definition-version.html)CLI-Befehl ausführen. |
| iotHost | Ihr AWS IoT Endpunkt. | Suchen Sie den Endpunkt in der AWS IoT Konsole unter **Einstellungen** oder indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html)CLI-Befehl ausführen. Dieser Befehl gibt den Amazon Trust Services (ATS) Endpunkt zurück. Weitere Informationen finden Sie in der Dokumentation [Server-Authentifizierung](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html). Stellen Sie sicher, dass Ihre [Endpunkte Ihrem Zertifikatstyp entsprechen](#certificate-endpoints). Stellen Sie sicher, dass Ihre [Endpunkte Ihren entsprechen](https://docs.aws.amazon.com/general/latest/gr/greengrass.html). AWS-Region |
| ggHost | Ihr AWS IoT Greengrass Endpunkt. | Das ist Ihr `iotHost`-Endpunkt mit dem durch *greengrass* ersetzten Host-Präfix (z. B. `greengrass-ats.iot.region.amazonaws.com`). Verwenden Sie dasselbe AWS-Region wie`iotHost`. Stellen Sie sicher, dass Ihre [Endpunkte Ihrem Zertifikatstyp entsprechen](#certificate-endpoints). Stellen Sie sicher, dass Ihre [Endpunkte Ihren entsprechen](https://docs.aws.amazon.com/general/latest/gr/greengrass.html). AWS-Region |
| iotMqttPort | Optional. Die Portnummer, mit AWS IoT der für die MQTT-Kommunikation verwendet werden soll. | Gültige Werte sind 8883 oder 443. Der Standardwert ist 8883. Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#alpn-network-proxy). |
| iotHttpPort | Optional. Die zum Erstellen von HTTPS-Verbindungen mit AWS IoT verwendete Portnummer. | Gültige Werte sind 8443 oder 443. Der Standardwert ist 8443. Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#alpn-network-proxy). |
| ggMqttPort | Optional. Die Portnummer, die für die MQTT-Kommunikation über das lokale Netzwerk verwendet werden soll. | Gültige Werte sind 1024 bis 65535. Der Standardwert ist 8883. Weitere Informationen finden Sie unter [Konfigurieren des MQTT-Ports für lokales Messaging](#config-local-mqtt-port). |
| ggHttpPort | Optional. Die zum Erstellen von HTTPS-Verbindungen mit dem AWS IoT Greengrass -Service verwendete Portnummer. | Gültige Werte sind 8443 oder 443. Der Standardwert ist 8443. Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#alpn-network-proxy). |
| keepAlive | Optional. Der MQTT-Zeitraum KeepAlive in Sekunden. | Der gültige Bereich liegt zwischen 30 und 1200 Sekunden. Der Standardwert ist 600. |
| networkProxy | Optional. Ein Objekt, das einen Proxy-Server definiert, mit dem eine Verbindung hergestellt werden soll. | Der Proxyserver kann HTTP oder HTTPS sein. Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#alpn-network-proxy). |
| mqttOperationTimeout | Optional. Die Zeit (in Sekunden), für die es dem Greengrass-Core möglich ist, einen Veröffentlichungs-, Abonnement- oder Abmeldevorgang in MQTT-Verbindungen zu AWS IoT Core abzuschließen. | Der Standardwert ist 5. Der Mindestwert ist 5. |
| ggDaemonPort | Optional. Die Greengrass-Kern-IPC-Portnummer. | Diese Eigenschaft ist in AWS IoT Greengrass Version 1.11.0 oder höher verfügbar. Gültige Werte liegen zwischen 1024 und 65535. Der Standardwert ist 8000. |
| systemComponentAuthTimeout | Optional. Die Zeit (in Millisekunden), bis der Greengrass-Core-IPC die Authentifizierung abschließen kann. | Diese Eigenschaft ist in Version 1.11.0 oder höher verfügbar. AWS IoT Greengrass Gültige Werte liegen zwischen 500 und 5000. Der Standardwert ist 5000. |
**runtime**
| Feld | Description | Hinweise |
| --- |--- |--- |
| maxWorkItemCount | Optional. Die maximale Anzahl von Arbeitselementen, die der Greengrass-Daemon gleichzeitig verarbeiten kann. Arbeitselemente, die diesen Grenzwert überschreiten, werden ignoriert. Die Warteschlange für Arbeitsaufgaben wird von Systemkomponenten, benutzerdefinierten Lambda-Funktionen und Konnektoren gemeinsam genutzt. | Der Standardwert lautet 1024. Der Maximalwert wird durch Ihre Gerätehardware begrenzt. Wenn Sie diesen Wert erhöhen, erhöht sich der Speicherverbrauch. AWS IoT Greengrass Sie können diesen Wert erhöhen, wenn Sie erwarten, dass Ihr Core einen hohen MQTT-Nachrichtenverkehr empfängt. |
| maxConcurrentLimit | Optional. Die maximale Anzahl an gleichzeitigen Lambda-Workern ohne Pin, die der Greengrass-Daemon haben kann. Sie können eine andere Ganzzahl angeben, um diesen Parameter zu überschreiben. | Der Standardwert ist 25. Der Mindestwert ist definiert durch`lruSize`. |
| lruSize | Optional. Definiert den Mindestwert fürmaxConcurrentLimit. | Der Standardwert ist 25. |
| mountAllBlockDevices | Optional. Ermöglicht AWS IoT Greengrass die Verwendung von Bind-Mounts, um alle Blockgeräte nach der Einrichtung von OverlayFS in einen Container einzuhängen. | Diese Eigenschaft ist in AWS IoT Greengrass Version 1.11.0 oder höher verfügbar. Gültige Werte sind `yes` und `no`. Der Standardwert ist `no`. Setzen Sie diesen Wert auf, `yes` wenn sich Ihr `/usr` Verzeichnis nicht in der `/` Hierarchie befindet. |
| postStartHealthCheckTimeout | Optional. Die Zeit (in Millisekunden) nach dem Start, die der Greengrass-Daemon wartet, bis die Zustandsprüfung beendet ist. | Das Standard-Timeout beträgt 30 Sekunden (30.000 ms). |
| `cgroup` |
| --- |
| useSystemd | Gibt an, ob Ihr Gerät [https://en.wikipedia.org/wiki/Systemd](https://en.wikipedia.org/wiki/Systemd) verwendet. | Gültige Werte sind yes oder no. Führen Sie das check\$1ggc\$1dependencies-Skript in [Modul 1](module1.md) aus, um festzustellen, ob Ihr Gerät systemd verwendet. |
**crypto**
Das `crypto`-Objekt enthält Eigenschaften, die die Speicherung privater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS\$111 und lokale geheime Speicher unterstützen. Weitere Informationen finden Sie unter [AWS IoT Greengrass zentrale Sicherheitsprinzipale](gg-sec.md#gg-principals), [Integration von Hardware-Sicherheit](hardware-security.md) und [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.
| Feld | Description | Hinweise |
| --- |--- |--- |
| caPath | Der absolute Pfad zur AWS IoT Stammzertifizierungsstelle. | Muss ein Datei-URI im folgenden Format sein: `file:///absolute/path/to/file`. Stellen Sie sicher, dass Ihre [Endpunkte Ihrem Zertifikatstyp entsprechen](#certificate-endpoints). |
| `PKCS11` |
| --- |
| OpenSSLEngine | Optional. Der absolute Pfad zur OpenSSL-Engine `.so`-Datei, um die PKCS\$111-Unterstützung unter OpenSSL zu aktivieren. | Muss ein Pfad zu einer Datei im Dateisystem sein. Diese Eigenschaft ist erforderlich, wenn Sie den Greengrass OTA Update Agent mit Hardwaresicherheit verwenden. Weitere Informationen finden Sie unter [Konfigurieren Sie die Unterstützung für Updates over-the-air](hardware-security.md#hardware-security-ota-updates). |
| P11Provider | Der absolute Pfad zur libdl-ladbaren Bibliothek der PKCS\$111-Implementierung. | Muss ein Pfad zu einer Datei im Dateisystem sein. |
| slotLabel | Das Slot-Label, das zur Identifizierung des Hardwaremoduls verwendet wird. | Muss den PKCS\$111 Label-Spezifikationen entsprechen. |
| slotUserPin | Die Benutzer-PIN, die zur Authentifizierung des Greengrass-Kerns gegenüber dem Modul verwendet wird. | Muss über ausreichende Berechtigungen verfügen, um C\$1Sign mit den konfigurierten privaten Schlüsseln auszuführen. |
| `principals` |
| --- |
| IoTCertificate | Das Zertifikat und der private Schlüssel, die Core verwendet, um Anfragen AWS IoT zu stellen. |
| IoTCertificate .privateKeyPath | Der Pfad zum privaten Core-Schlüssel. | Muss für den Dateisystemspeicher ein Datei-URI im folgenden Format sein: `file:///absolute/path/to/file`. Muss für einen HSM-Speicher ein [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512)-Pfad sein, der eine Objektbezeichnung angibt. |
| IoTCertificate .certificatePath | Der absolute Pfad zum Core-Gerätezertifikat. | Muss ein Datei-URI im folgenden Format sein: `file:///absolute/path/to/file`. |
| MQTTServerCertificate | Optional. Der private Schlüssel, den der Kern in Kombination mit dem Zertifikat verwendet, um als MQTT-Server oder Gateway zu fungieren. |
| MQTTServerCertificate .privateKeyPath | Der Pfad zum privaten Schlüssel des lokalen MQTT-Servers. | Verwenden Sie diesen Wert, um einen eigenen privaten Schlüssel für den lokalen MQTT-Server anzugeben. Muss für den Dateisystemspeicher ein Datei-URI im folgenden Format sein: `file:///absolute/path/to/file`. Muss für einen HSM-Speicher ein [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512)-Pfad sein, der eine Objektbezeichnung angibt. Wenn diese Eigenschaft weggelassen wird, wird der Schlüssel auf der Grundlage Ihrer AWS IoT Greengrass Rotationseinstellungen rotiert. Sofern angegeben, ist der Kunde für das Rotieren des Schlüssels verantwortlich. |
| SecretsManager | Der private Schlüssel, der den für die Verschlüsselung verwendeten Datenschlüssel schützt. Weitere Informationen finden Sie unter [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). |
| SecretsManager .privateKeyPath | Der Pfad zum privaten Schlüssel des lokalen Secrets Managers. | Nur ein RSA-Schlüssel wird unterstützt. Muss für den Dateisystemspeicher ein Datei-URI im folgenden Format sein: `file:///absolute/path/to/file`. Muss für einen HSM-Speicher ein [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512)-Pfad sein, der eine Objektbezeichnung angibt. Der private Schlüssel muss erstellt werden, indem Sie den [PKCS\$11 v1.5](https://tools.ietf.org/html/rfc2313)-Padding-Mechanismus verwenden. |
Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt:
****
| Feld | Description | Hinweise |
| --- | --- | --- |
| mqttMaxConnectionRetryInterval | Optional. Das Maximalintervall (in Sekunden) zwischen MQTT-Verbindungsversuchen, wenn die Verbindung getrennt wird. | Geben Sie diesen Wert als Ganzzahl ohne Vorzeichen an. Der Standardwert ist `60`. |
| managedRespawn | Optional. Gibt an, dass der OTA-Agent vor einem Update einen benutzerdefinierten Code ausführen muss. | Gültige Werte sind `true` oder `false`. Weitere Informationen finden Sie unter [OTA-Updates der AWS IoT Greengrass Core-Software](core-ota-update.md). |
| writeDirectory | Optional. Das Schreibverzeichnis, in dem alle read/write Ressourcen AWS IoT Greengrass erstellt werden. | Weitere Informationen finden Sie unter [Konfigurieren Sie ein Schreibverzeichnis für AWS IoT Greengrass](#write-directory). |
| pidFileDirectory | Fakultativ. AWS IoT Greengrass speichert seine Prozess-ID (PID) in diesem Verzeichnis. | Der Standardwert ist `/var/run`. |
------
#### [ Extended life versions ]
Die folgenden Versionen der AWS IoT Greengrass Core-Software befinden sich in der [erweiterten Lebensphase](maintenance-policy.md). Diese Informationen dienen lediglich Referenzzwecken.
GGC v1.10
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600,
"systemComponentAuthTimeout": 5000
},
"runtime" : {
"maxWorkItemCount" : 1024,
"maxConcurrentLimit" : 25,
"lruSize": 25,
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
Die `config.json`-Datei unterstützt die folgenden Eigenschaften:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**crypto**
Das `crypto`-Objekt enthält Eigenschaften, die die Speicherung privater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS\$111 und lokale geheime Speicher unterstützen. Weitere Informationen finden Sie unter [AWS IoT Greengrass zentrale Sicherheitsprinzipale](gg-sec.md#gg-principals), [Integration von Hardware-Sicherheit](hardware-security.md) und [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
GGC v1.9
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
Die `config.json`-Datei unterstützt die folgenden Eigenschaften:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**crypto**
Das `crypto`-Objekt wurde in v1.7.0 hinzugefügt. Es führt Eigenschaften ein, die die Speicherung privater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS\$111 und lokale geheime Speicher unterstützen. Weitere Informationen finden Sie unter [AWS IoT Greengrass zentrale Sicherheitsprinzipale](gg-sec.md#gg-principals), [Integration von Hardware-Sicherheit](hardware-security.md) und [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.8**
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
Die `config.json` Datei unterstützt die folgenden Eigenschaften.
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**crypto**
Das `crypto`-Objekt wurde in v1.7.0 hinzugefügt. Es führt Eigenschaften ein, die die Speicherung privater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS\$111 und lokale geheime Speicher unterstützen. Weitere Informationen finden Sie unter [AWS IoT Greengrass zentrale Sicherheitsprinzipale](gg-sec.md#gg-principals), [Integration von Hardware-Sicherheit](hardware-security.md) und [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.7**
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
Die `config.json`-Datei unterstützt die folgenden Eigenschaften:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**crypto**
Das in v1.7.0 hinzugefügte `crypto`-Objekt führt Eigenschaften ein, die die Speicherung privater Schlüssel auf einem Hardware-Sicherheitsmodul (HSM) über PKCS\$111 und lokale geheime Speicher unterstützen. Weitere Informationen erhalten Sie unter [Integration von Hardware-Sicherheit](hardware-security.md) und [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md). Konfigurationen für die Speicherung privater Schlüssel auf HSMs oder im Dateisystem werden unterstützt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
Die folgenden Konfigurationseigenschaften werden ebenfalls unterstützt:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.6**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600,
"mqttMaxConnectionRetryInterval": 60
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true,
"writeDirectory": "/write-directory"
}
```
Wenn Sie die Option **zur Erstellung von Standardgruppen** von der AWS IoT Greengrass Konsole aus verwenden, wird die `config.json` Datei in einem funktionierenden Zustand, der die Standardkonfiguration angibt, auf dem Kerngerät bereitgestellt.
Die `config.json`-Datei unterstützt die folgenden Eigenschaften:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.5**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true
}
```
Die Datei `config.json` befindet sich in `/greengrass-root/config` und enthält die folgenden Parameter:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.3**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true
}
```
Die Datei `config.json` befindet sich in `/greengrass-root/config` und enthält die folgenden Parameter:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.1**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
}
}
```
Die Datei `config.json` befindet sich in `/greengrass-root/config` und enthält die folgenden Parameter:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
**GGC v1.0**
In AWS IoT Greengrass Core v1.0 `config.json` wird es für bereitgestellt. `greengrass-root/configuration`
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
}
}
```
Die Datei `config.json` befindet sich in `/greengrass-root/configuration` und enthält die folgenden Parameter:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html)
------
## Dienstendpunkte müssen dem Zertifikatstyp der Stammzertifizierungsstelle entsprechen
Ihr AWS IoT Core und Ihre AWS IoT Greengrass Endpunkte müssen dem Zertifikatstyp des Root-CA-Zertifikats auf Ihrem Gerät entsprechen. Wenn die Endpunkte und der Zertifikatstyp nicht übereinstimmen, schlagen Authentifizierungsversuche zwischen dem Gerät und AWS IoT Core oder fehl. AWS IoT Greengrass Weitere Informationen finden Sie unter [Serverauthentifizierung](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) im *AWS IoT -Entwicklerhandbuch*.
Wenn Ihr Gerät ein Root-CA-Zertifikat von Amazon Trust Services (ATS) verwendet, was die bevorzugte Methode ist, muss es auch ATS-Endpunkte für die Geräteverwaltung und den Betrieb der Discovery-Datenebene verwenden. ATS-Endpunkte enthalten das `ats` Segment, wie in der folgenden Syntax für den AWS IoT Core Endpunkt dargestellt.
```
prefix-ats.iot.region.amazonaws.com
```
**Anmerkung**
Aus Gründen der Abwärtskompatibilität werden AWS IoT Greengrass derzeit in einigen Fällen ältere VeriSign Root-CA-Zertifikate und Endpunkte unterstützt. AWS-Region Wenn Sie ein veraltetes VeriSign Root-CA-Zertifikat verwenden, empfehlen wir Ihnen, einen ATS-Endpunkt zu erstellen und stattdessen ein ATS-Root-CA-Zertifikat zu verwenden. Andernfalls stellen Sie sicher, dass Sie die entsprechenden Legacy-Endpunkte verwenden. Weitere Informationen finden Sie unter [Unterstützte Legacy-Endpunkte](https://docs.aws.amazon.com/general/latest/gr/greengrass.html#greengrass-legacy-endpoints) im *Allgemeine Amazon Web Services-Referenz*.
### Endpunkte in config.json
Auf einem Greengrass Core-Gerät sind Endpunkte im Objekt `coreThing` in der Datei [`config.json`](#config-json) angegeben. Die `iotHost` Eigenschaft stellt den AWS IoT Core Endpunkt dar. Die `ggHost` Eigenschaft stellt den AWS IoT Greengrass Endpunkt dar. Im folgenden Beispiel für einen Ausschnitt legen diese Eigenschaften ATS-Endpunkte fest.
```
{
"coreThing" : {
...
"iotHost" : "abcde1234uwxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
...
},
```
**AWS IoT Core Endpunkt**
Sie können Ihren AWS IoT Core Endpunkt abrufen, indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html)CLI-Befehl mit dem entsprechenden `--endpoint-type` Parameter ausführen.
+ Um einen ATS-signierten Endpunkt zurückzugeben, führen Sie Folgendes aus.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
+ Führen Sie Folgendes aus, um einen VeriSign signierten Legacy-Endpunkt zurückzugeben:
```
aws iot describe-endpoint --endpoint-type iot:Data
```
**AWS IoT Greengrass Endpunkt**
Ihr AWS IoT Greengrass Endpunkt ist Ihr `iotHost` Endpunkt, wobei das Host-Präfix durch *Greengrass* ersetzt wird. Zum Beispiel lautet der signierte ATS-Endpunkt `greengrass-ats.iot.region.amazonaws.com`. Dies verwendet dieselbe Region wie Ihr AWS IoT Core Endpunkt.
## Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy
Diese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.
Greengrass-Kerne kommunizieren AWS IoT Core mit dem MQTT-Messaging-Protokoll mit TLS-Client-Authentifizierung. 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. Bei anderen restriktiven Umgebungen muss der gesamte Datenverkehr möglicherweise über einen HTTP-Proxy laufen, der mit dem Internet verbunden ist.
Um die Kommunikation in diesen Szenarien zu AWS IoT Greengrass ermöglichen, sind die folgenden Konfigurationen möglich:
+ **MQTT mit TLS-Client-Authentifizierung über Port 443**. Wenn Ihr Netzwerk Verbindungen über Port 443 zulässt, können Sie den Core so konfigurieren, dass er anstelle des Standard-Ports 8883 Port 443 für MQTT-Datenverkehr verwendet. Dabei kann es sich um eine direkte Verbindung mit Port 443 oder eine Verbindung über einen Netzwerk-Proxy-Server handeln.
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 MQTT über TLS auf Port 443 eine zertifikatbasierte Client-Authentifizierung.
Wenn der Core für die Verwendung einer direkten Verbindung zu Port 443 konfiguriert ist, unterstützt er [AWS IoT Greengrass Softwareupdates over-the-air (OTA)](core-ota-update.md). Für diese Unterstützung ist AWS IoT Greengrass Core v1.9.3 oder höher erforderlich.
+ **HTTPS-Kommunikation über Port 443**. AWS IoT Greengrass sendet standardmäßig HTTPS-Verkehr über Port 8443, aber Sie können ihn so konfigurieren, dass Port 443 verwendet wird.
+ **Verbindung über einen Netzwerk-Proxy**. Sie können einen Netzwerk-Proxy-Server so konfigurieren, dass er als Vermittler beim Herstellen der Verbindung mit dem Greengrass-Core fungiert. Nur grundlegende Authentifizierung und HTTP- und HTTPS-Proxys werden unterstützt.
Die Proxykonfiguration wird über die `no_proxy` Umgebungsvariablen`http_proxy`, `https_proxy` und an benutzerdefinierte Lambda-Funktionen übergeben. Benutzerdefinierte Lambda-Funktionen müssen diese übergebenen Einstellungen verwenden, um eine Verbindung über den Proxy herzustellen. Gängige Bibliotheken, die von Lambda-Funktionen zum Herstellen von Verbindungen verwendet werden (wie Boto3- oder cURL- und `requests` Python-Pakete), verwenden diese Umgebungsvariablen normalerweise standardmäßig. Wenn eine Lambda-Funktion auch dieselben Umgebungsvariablen spezifiziert, überschreibt sie sie AWS IoT Greengrass nicht.
**Wichtig**
Greengrass-Cores, die für die Verwendung eines Netzwerk-Proxys konfiguriert wurden, unterstützen keine [OTA-Aktualisierungen](core-ota-update.md).
**So konfigurieren Sie MQTT über Port 443**
Für diese Funktion ist AWS IoT Greengrass Core v1.7 oder höher erforderlich.
Dieses Verfahren ermöglicht es dem Greengrass-Core, Port 443 für MQTT-Messaging mit AWS IoT Core zu verwenden.
1. Führen Sie den folgenden Befehl aus, um den Greengrass-Daemon zu beenden:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie `greengrass-root/config/config.json` zur Bearbeitung als su-Benutzer.
1. Fügen Sie im Objekt `coreThing` die Eigenschaft `iotMqttPort` hinzu und setzen Sie den Wert auf **443**, wie im folgenden Beispiel gezeigt.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"iotMqttPort" : 443,
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"keepAlive" : 600
},
...
}
```
1. Starten Sie den -Daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**So konfigurieren Sie HTTPS über Port 443**
Für diese Funktion ist AWS IoT Greengrass Core v1.8 oder höher erforderlich.
Dieses Verfahren konfiguriert den Kern so, dass er Port 443 für die HTTPS-Kommunikation verwendet.
1. Führen Sie den folgenden Befehl aus, um den Greengrass-Daemon zu beenden:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie `greengrass-root/config/config.json` zur Bearbeitung als su-Benutzer.
1. Fügen Sie im Objekt `coreThing` die Eigenschaften `iotHttpPort` und `ggHttpPort` hinzu, wie im folgenden Beispiel dargestellt.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"iotHttpPort" : 443,
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"ggHttpPort" : 443,
"keepAlive" : 600
},
...
}
```
1. Starten Sie den -Daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**So konfigurieren Sie einen Netzwerk-Proxy**
Für diese Funktion ist AWS IoT Greengrass Core v1.7 oder höher erforderlich.
Dieses Verfahren ermöglicht die AWS IoT Greengrass Verbindung mit dem Internet über einen HTTP- oder HTTPS-Netzwerk-Proxy.
1. Führen Sie den folgenden Befehl aus, um den Greengrass-Daemon zu beenden:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie `greengrass-root/config/config.json` zur Bearbeitung als su-Benutzer.
1. Fügen Sie im Objekt `coreThing` das Objekt [networkProxy](#networkProxy-object) hinzu, wie im folgenden Beispiel gezeigt.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"keepAlive" : 600,
"networkProxy": {
"noProxyAddresses" : "http://128.12.34.56,www.mywebsite.com",
"proxy" : {
"url" : "https://my-proxy-server:1100",
"username" : "Mary_Major",
"password" : "pass@word1357"
}
}
},
...
}
```
1. Starten Sie den -Daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**networkProxy-Objekt**
Geben Sie mithilfe des `networkProxy`-Objekts Informationen zum Netzwerk-Proxy an. Dieses Objekt hat die folgenden Eigenschaften.
| Feld | Description |
| --- | --- |
| noProxyAddresses | Optional. Eine durch Komma getrennte Liste von IP-Adressen oder Host-Namen, die vom Proxy ausgeschlossen sind. |
| proxy | Der Proxy, mit dem die Verbindung hergestellt werden soll. Ein Proxy hat die folgenden Eigenschaften. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/gg-core.html) |
### Zulassen von Endpunkten
Die Kommunikation zwischen Greengrass-Geräten AWS IoT Core und/oder AWS IoT Greengrass muss authentifiziert werden. Diese Authentifizierung basiert auf registrierten X.509-Gerätezertifikaten und kryptografischen Schlüsseln. Damit authentifizierte Anfragen ohne zusätzliche Verschlüsselung Proxys durchlaufen können, müssen Sie die folgenden Endpunkte zulassen.
| Endpoint | Port | Description |
| --- | --- | --- |
| greengrass.region.amazonaws.com | 443 | Für Operationen auf Steuerebene für die Gruppenverwaltung |
| `prefix-ats.iot.region.amazonaws.com` oder `prefix.iot.region.amazonaws.com` | MQTT: 8883 oder 443 HTTPS: 8443 oder 443 | Für Operationen auf Datenebene für das Gerätemanagement, wie z. B. Schattensynchronisierung Erlauben Sie die Verwendung eines oder beider Endpunkte, je nachdem, ob Ihre Core- und Client-Geräte (bevorzugte) Root-CA-Zertifikate von Amazon Trust Services, ältere Root-CA-Zertifikate oder beides verwenden. Weitere Informationen finden Sie unter [Dienstendpunkte müssen dem Zertifikatstyp der Stammzertifizierungsstelle entsprechen](#certificate-endpoints). |
| `greengrass-ats.iot.region.amazonaws.com` oder `greengrass.iot.region.amazonaws.com` | 8443 oder 443 | Für Geräteerkennungsoperationen Erlauben Sie die Verwendung eines oder beider Endpunkte, je nachdem, ob Ihre Core- und Client-Geräte (bevorzugte) Root-CA-Zertifikate von Amazon Trust Services, ältere Root-CA-Zertifikate oder beides verwenden. Weitere Informationen finden Sie unter [Dienstendpunkte müssen dem Zertifikatstyp der Stammzertifizierungsstelle entsprechen](#certificate-endpoints). Clients, die eine Verbindung über Port 443 herstellen, müssen die TLS-Erweiterung [Application Layer Protocol Negotiation (ALPN)](https://tools.ietf.org/html/rfc7301) implementieren und `x-amzn-http-ca` als `ProtocolName` in die übergeben. `ProtocolNameList` Weitere Informationen finden Sie unter [Protokolle](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html) im *AWS IoT Entwicklerhandbuch*. |
| \$1.s3.amazonaws.com | 443 | Wird für Bereitstellungsvorgänge und over-the-air Updates verwendet. Dieses Format enthält das Zeichen `*`, da Endpunktpräfixe intern kontrolliert werden und sich jederzeit ändern können. |
| logs.region.amazonaws.com | 443 | Erforderlich, wenn die Greengrass-Gruppe so konfiguriert ist, dass Protokolle in CloudWatch geschrieben werden. |
## Konfigurieren Sie ein Schreibverzeichnis für AWS IoT Greengrass
Diese Funktion ist für AWS IoT Greengrass Core v1.6 und höher verfügbar.
Standardmäßig wird die AWS IoT Greengrass Core-Software in einem einzigen Stammverzeichnis bereitgestellt, in dem alle Lese- und Schreibvorgänge AWS IoT Greengrass ausgeführt werden. Sie können jedoch so konfigurieren, AWS IoT Greengrass dass für alle Schreibvorgänge, einschließlich der Erstellung von Verzeichnissen und Dateien, ein separates Verzeichnis verwendet wird. In diesem Fall werden zwei Verzeichnisse der obersten Ebene AWS IoT Greengrass verwendet:
+ Das *greengrass-root*-Verzeichnis, das Sie als Lese-/Schreibzugriff belassen oder optional schreibgeschützt machen können. Dies enthält die AWS IoT Greengrass Core-Software und andere wichtige Komponenten, die während der Laufzeit unveränderlich bleiben sollten, wie Zertifikate und. `config.json`
+ Das angegebene Schreibverzeichnis. Dies enthält beschreibbaren Inhalt wie Protokolle, Statusinformationen und bereitgestellte benutzerdefinierte Lambda-Funktionen.
Diese Konfiguration führt zu der folgenden Verzeichnisstruktur.
**Greengrass-Stammverzeichnis**
```
greengrass-root/
|-- certs/
| |-- root.ca.pem
| |-- hash.cert.pem
| |-- hash.private.key
| |-- hash.public.key
|-- config/
| |-- config.json
|-- ggc/
| |-- packages/
| |-- package-version/
| |-- bin/
| |-- daemon
| |-- greengrassd
| |-- lambda/
| |-- LICENSE/
| |-- release_notes_package-version.html
| |-- runtime/
| |-- java8/
| |-- nodejs8.10/
| |-- python3.8/
| |-- core/
```
**Schreibverzeichnis**
```
write-directory/
|-- packages/
| |-- package-version/
| |-- ggc_root/
| |-- rootfs_nosys/
| |-- rootfs_sys/
| |-- var/
|-- deployment/
| |-- group/
| |-- group.json
| |-- lambda/
| |-- mlmodel/
|-- var/
| |-- log/
| |-- state/
```
**So konfigurieren Sie ein Schreibverzeichnis**
1. Führen Sie den folgenden Befehl aus, um den Daemon zu beenden: AWS IoT Greengrass
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie `greengrass-root/config/config.json` zur Bearbeitung als su-Benutzer.
1. Fügen Sie `writeDirectory` als einen Parameter hinzu und geben Sie, wie im folgenden Beispiel, den Pfad zum Zielverzeichnis an.
```
{
"coreThing": {
"caPath": "root-CA.pem",
"certPath": "hash.pem.crt",
...
},
...
"writeDirectory" : "/write-directory"
}
```
**Anmerkung**
Sie können die `writeDirectory`-Einstellung so oft aktualisieren, wie Sie möchten. AWS IoT Greengrass Verwendet nach der Aktualisierung der Einstellung beim nächsten Start das neu angegebene Schreibverzeichnis, migriert aber keine Inhalte aus dem vorherigen Schreibverzeichnis.
1. Nachdem Ihr Schreibverzeichnis konfiguriert ist, können Sie optional das *greengrass-root*-Verzeichnis auf schreibgeschützt einstellen. Anweisungen finden Sie unter [So wird das Greengrass-Stammverzeichnis auf schreibgeschützt eingestellt](#configure-ro-directory).
Andernfalls starten Sie den AWS IoT Greengrass Daemon:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**So aktivieren Sie den Schreibschutz für das Greengrass-Stammverzeichnis**
Führen Sie diese Schritte nur aus, wenn das Greengrass-Stammverzeichnis schreibgeschützt sein soll. Das Schreibverzeichnis muss vor Beginn konfiguriert werden.
1. Erteilen Sie Zugriffsberechtigungen für erforderliche Verzeichnisse:
1. Dem `config.json`-Besitzer Lese- und Schreibberechtigung erteilen.
```
sudo chmod 0600 /greengrass-root/config/config.json
```
1. Machen Sie ggc\$1user zum Besitzer der Zertifikate und System-Lambda-Verzeichnisse.
```
sudo chown -R ggc_user:ggc_group /greengrass-root/certs/
sudo chown -R ggc_user:ggc_group /greengrass-root/ggc/packages/1.11.6/lambda/
```
**Anmerkung**
Die Konten ggc\$1user und ggc\$1group werden standardmäßig verwendet, um Lambda-Systemfunktionen auszuführen. Wenn Sie die [Standardzugriffsidentität](lambda-group-config.md#lambda-access-identity-groupsettings) auf Gruppenebene konfiguriert haben, um verschiedene Konten zu verwenden, sollten Sie stattdessen dem Benutzer (UID) und der Gruppe (GID) Berechtigungen erteilen.
1. Machen Sie das *greengrass-root*-Verzeichnis schreibgeschützt, indem Sie Ihren bevorzugten Mechanismus verwenden.
**Anmerkung**
Sie können den Schreibschutz für das *greengrass-root*-Verzeichnis einstellen, indem Sie das Verzeichnis als schreibgeschützt mounten. Um jedoch over-the-air (OTA) -Updates auf die AWS IoT Greengrass Core-Software in einem bereitgestellten Verzeichnis anzuwenden, muss das Verzeichnis zuerst entfernt und nach dem Update erneut bereitgestellt werden. Sie können diese `umount`- und `mount`-Operationen für die `ota_pre_update`- und `ota_post_update`-Skripts hinzufügen. Weitere Informationen über OTA-Updates finden Sie unter [Greengrass OTA-Update-Agent](core-ota-update.md#ota-agent) und [Managed Respawn mit OTA-Updates](core-ota-update.md#ota-managed-respawn).
1. Starten Sie den -Daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
Wenn die Berechtigungen aus Schritt 1 nicht korrekt festgelegt wurden, wird der Daemon nicht gestartet.
## Konfigurieren der MQTT-Einstellungen
In der AWS IoT Greengrass Umgebung können lokale Client-Geräte, Lambda-Funktionen, Konnektoren und Systemkomponenten miteinander und mit AWS IoT Core kommunizieren. Die gesamte Kommunikation erfolgt durch den Core, der die [Abonnements](gg-sec.md#gg-msg-workflow) verwaltet, die die MQTT-Kommunikation zwischen Entitäten autorisieren.
Informationen zu MQTT-Einstellungen AWS IoT Greengrass, für die Sie konfigurieren können, finden Sie in den folgenden Abschnitten:
+ [Nachrichtenqualität des Service](#message-quality-of-service)
+ [MQTT-Nachrichtenwarteschlange für Cloud-Ziele](#mqtt-message-queue)
+ [Persistente MQTT-Sitzungen mit AWS IoT Core](#mqtt-persistent-sessions)
+ [Client IDs für MQTT-Verbindungen mit AWS IoT](#connection-client-id)
+ [MQTT-Port für lokales Messaging](#config-local-mqtt-port)
+ [Timeout für Veröffentlichungs-, Abonnierungs- und Abmeldevorgänge in MQTT-Verbindungen mit dem AWS Cloud](#mqtt-operation-timeout)
**Anmerkung**
OPC-UA ist ein Standard für den Informationsaustausch für die industrielle Kommunikation. [Um die Unterstützung für OPC-UA auf dem Greengrass-Core zu implementieren, können Sie den IoT-Connector verwenden. SiteWise ](iot-sitewise-connector.md) Der Konnektor sendet Daten von Industriegeräten von OPC-UA-Servern an Anlagen in. AWS IoT SiteWise
### Nachrichtenqualität des Service
AWS IoT Greengrass unterstützt die Quality-of-Service-Stufen (QoS) 0 oder 1, abhängig von Ihrer Konfiguration und dem Ziel und der Richtung der Kommunikation. Der Greengrass-Kern fungiert als Client für die Kommunikation mit dem lokalen Netzwerk AWS IoT Core und als Nachrichtenbroker für die Kommunikation im lokalen Netzwerk.
![\[Der Core als Client und lokaler Nachrichtenbroker.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/mqtt-qos.png)
Weitere Informationen zu MQTT und QoS finden Sie unter [Getting Started](https://mqtt.org/getting-started/) auf der MQTT-Website.
**Kommunikation mit dem AWS Cloud**
+ **Ausgehende Nachrichten verwenden QoS 1**
Der Kern sendet Nachrichten, die für AWS Cloud Ziele bestimmt sind, die QoS 1 verwenden. AWS IoT Greengrass verwendet eine MQTT-Nachrichtenwarteschlange, um diese Nachrichten zu verarbeiten. Wenn die Nachrichtenzustellung von nicht bestätigt wird AWS IoT, wird die Nachricht in einem Spoolmodus gespeichert, sodass sie zu einem späteren Zeitpunkt erneut versucht wird. Die Nachricht kann nicht erneut versucht werden, wenn die Warteschlange voll ist. Die Bestätigung der Nachrichtenzustellung kann dazu beitragen, den Datenverlust aufgrund unterbrochener Konnektivität zu minimieren.
Da ausgehende Nachrichten QoS 1 AWS IoT verwenden sollen, hängt die maximale Geschwindigkeit, mit der der Greengrass-Core Nachrichten senden kann, von der Latenz zwischen dem Kern und ab. AWS IoT Jedes Mal, wenn der Core eine Nachricht sendet, wartet er, bis er die Nachricht AWS IoT bestätigt, bevor er die nächste Nachricht sendet. Wenn die Umlaufzeit zwischen dem Kern und seinem Kern beispielsweise 50 Millisekunden AWS-Region beträgt, kann der Kern bis zu 20 Nachrichten pro Sekunde senden. Berücksichtigen Sie dieses Verhalten, wenn Sie auswählen, AWS-Region wo Ihr Kern eine Verbindung herstellt. Um umfangreiche IoT-Daten in den aufzunehmen AWS Cloud, können Sie den [Stream](stream-manager.md) Manager verwenden.
Weitere Informationen zur MQTT-Nachrichtenwarteschlange, einschließlich der Konfiguration eines lokalen Speichercaches, der Nachrichten, die für Ziele bestimmt sind, speichern kann, finden Sie unter. AWS Cloud [MQTT-Nachrichtenwarteschlange für Cloud-Ziele](#mqtt-message-queue)
+ **Eingehende Nachrichten verwenden QoS 0 (Standard) oder QoS 1**
Standardmäßig abonniert der Core mit QoS 0 Nachrichten aus AWS Cloud Quellen. Wenn Sie persistente Sitzungen aktivieren, abonniert der Core mit QoS 1. Dies kann dazu beitragen, Datenverluste durch intermittierende Konnektivität zu minimieren. Um die QoS für diese Abonnements zu verwalten, konfigurieren Sie Persistenzeinstellungen für die lokale Spooler-Systemkomponente.
Weitere Informationen, unter anderem dazu, wie Sie es dem Core ermöglichen, eine persistente Sitzung mit AWS Cloud Zielen einzurichten, finden Sie unter. [Persistente MQTT-Sitzungen mit AWS IoT Core](#mqtt-persistent-sessions)
**Kommunikation mit lokalen Zielen**
Die gesamte lokale Kommunikation verwendet QoS 0. Der Core versucht einmal, eine Nachricht an ein lokales Ziel zu senden, bei dem es sich um eine Greengrass Lambda-Funktion, einen Connector oder ein [Client-Gerät](what-is-gg.md#greengrass-devices) handeln kann. Der Core speichert keine Nachrichten und bestätigt die Zustellung nicht. Nachrichten können überall zwischen den Komponenten gelöscht werden.
Obwohl die direkte Kommunikation zwischen Lambda-Funktionen kein MQTT-Messaging verwendet, ist das Verhalten dasselbe.
### MQTT-Nachrichtenwarteschlange für Cloud-Ziele
MQTT-Nachrichten, die für AWS Cloud Ziele bestimmt sind, werden in eine Warteschlange gestellt, um auf ihre Verarbeitung zu warten. Nachrichten in der Warteschlange werden in der FIFO (First-in-First-out)-Reihenfolge verarbeitet. Nachdem eine Nachricht verarbeitet und veröffentlicht wurde AWS IoT Core, wird sie aus der Warteschlange entfernt.
Standardmäßig speichert der Greengrass-Kern unverarbeitete Nachrichten, die für Ziele bestimmt sind, im Speicher. AWS Cloud Sie können den Core so konfigurieren, dass nicht verarbeitete Nachrichten stattdessen in einem lokalen Speichercache gespeichert werden. Im Gegensatz zum In-Memory-Speicher kann der lokale Speichercache auch nach einem Neustart des Kerns bestehen bleiben (z. B. nach einer Gruppenbereitstellung oder einem Geräteneustart), sodass die Nachrichten weiter verarbeitet AWS IoT Greengrass werden können. Sie können auch die Speichergröße konfigurieren.
**Warnung**
Der Greengrass-Core könnte doppelte MQTT-Nachrichten in die Warteschlange stellen, wenn er die Verbindung verliert, weil er einen Veröffentlichungsvorgang wiederholt, bevor der MQTT-Client erkennt, dass er offline ist. Um doppelte MQTT-Nachrichten für Cloud-Ziele zu vermeiden, konfigurieren Sie den `keepAlive` Wert des Kerns auf weniger als die Hälfte seines Werts. `mqttOperationTimeout` Weitere Informationen finden Sie unter [AWS IoT Greengrass Kernkonfigurationsdatei](#config-json).
AWS IoT Greengrass verwendet die Spooler-Systemkomponente (die `GGCloudSpooler` Lambda-Funktion), um die Nachrichtenwarteschlange zu verwalten. Sie können die folgenden `GGCloudSpooler`-Umgebungsvariablen verwenden, um Speichereinstellungen zu konfigurieren.
+ **GG\$1CONFIG\$1STORAGE\$1TYPE**. Der Speicherort der Nachrichtenwarteschlange. Die folgenden Werte sind gültig:
+ `FileSystem`. Speichern Sie unverarbeitete Nachrichten im lokalen Speichercache auf der Festplatte des physischen Kerngeräts. Wenn der Core neu gestartet wird, werden Nachrichten in der Warteschlange für die Verarbeitung beibehalten. Nachrichten werden nach der Verarbeitung entfernt.
+ `Memory` (default). Speichern Sie nicht verarbeitete Nachrichten im Arbeitsspeicher. Wenn der Core neu gestartet wird, gehen Nachrichten in der Warteschlange verloren.
Diese Option sind für Geräte mit eingeschränkten Hardwaremöglichkeiten optimiert. Wenn Sie diese Konfiguration verwenden, sollten Sie Gruppen bereitstellen oder das Gerät neu starten, wenn die Serviceunterbrechung möglichst gering ist.
+ **GG\$1CONFIG\$1MAX\$1SIZE\$1BYTES**. Die Speichergröße in Bytes. Bei diesem Wert kann es sich **um eine beliebige nicht negative Ganzzahl handeln, die größer oder gleich 262144** (256 KB) ist. Eine kleinere Größe verhindert, dass die AWS IoT Greengrass Core-Software gestartet wird. Die Standardgröße ist 2.5 MB. Wenn die maximale Größe erreicht ist, werden die ältesten Nachrichten in der Warteschlange durch neue Nachrichten ersetzt.
**Anmerkung**
Diese Funktion ist für AWS IoT Greengrass Core v1.6 und höher verfügbar. Frühere Versionen verwenden In-Memory-Speicher mit einer Warteschlangengröße von 2,5 MB. Sie können keine Speichereinstellungen für frühere Versionen konfigurieren.
#### So speichern Sie Nachrichten im lokalen Speicher
Sie können so konfigurieren AWS IoT Greengrass , dass Nachrichten im Dateisystem zwischengespeichert werden, sodass sie auch nach einem Neustart des Kerns bestehen bleiben. Dazu stellen Sie eine Funktionsdefinitionsversion bereit, in der die `GGCloudSpooler`-Funktion den Speichertyp auf `FileSystem` festlegt. Sie müssen die AWS IoT Greengrass API verwenden, um den lokalen Speichercache zu konfigurieren. Sie können dies von der Konsole aus erledigen.
Das folgende Verfahren verwendet den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html)CLI-Befehl, um den Spooler so zu konfigurieren, dass Nachrichten in der Warteschlange im Dateisystem gespeichert werden. Außerdem wird damit eine Warteschlange mit einer Größe von 2,6 MB konfiguriert.
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie finden diese Werte auch in der AWS IoT Konsole. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `LatestVersion`Werte und `Id` aus der Zielgruppe in die Ausgabe.
1. Rufen Sie die neueste Gruppenversion ab.
+ Ersetzen Sie *group-id* durch den `Id`, den Sie kopiert haben.
+ Ersetzen Sie *latest-group-version-id* durch den `LatestVersion`, den Sie kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Kopieren Sie aus dem `Definition` Objekt in der Ausgabe die `CoreDefinitionVersionArn` und die ARNs aller anderen Gruppenkomponenten außer`FunctionDefinitionVersionArn`. Diese Werte verwenden Sie, wenn Sie eine neue Gruppenversion erstellen.
1. Kopieren Sie die ID der Funktionsdefinition aus `FunctionDefinitionVersionArn`. Die ID ist die GUID, die dem `functions`-Segment im ARN folgt, wie im folgenden Beispiel gezeigt.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**Anmerkung**
Sie können auch eine Funktionsdefinition erstellen, indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)Befehl ausführen und dann die ID aus der Ausgabe kopieren.
1. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.
+ *function-definition-id*Ersetzen Sie sie durch `Id` die, die Sie für die Funktionsdefinition kopiert haben.
+ *arbitrary-function-id*Ersetzen Sie durch einen Namen für die Funktion, z. **spooler-function** B.
+ Fügen Sie dem `functions` Array alle Lambda-Funktionen hinzu, die Sie in diese Version aufnehmen möchten. Sie können den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html)Befehl verwenden, um die Greengrass Lambda-Funktionen aus einer vorhandenen Funktionsdefinitionsversion abzurufen.
**Warnung**
Stellen Sie sicher, dass Sie einen Wert für `GG_CONFIG_MAX_SIZE_BYTES` angeben, der **größer als oder gleich 262144** ist. Eine geringere Größe verhindert, dass die AWS IoT Greengrass Core-Software gestartet wird.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_MAX_SIZE_BYTES":"2621440","GG_CONFIG_STORAGE_TYPE":"FileSystem"}},"Executable": "spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'
```
**Anmerkung**
Wenn Sie die `GG_CONFIG_SUBSCRIPTION_QUALITY` Umgebungsvariable zuvor so eingestellt haben, dass sie [persistente Sitzungen unterstützt AWS IoT Core](#mqtt-persistent-sessions), nehmen Sie sie in diese Funktionsinstanz auf.
1. Kopieren Sie den `Arn` der Funktionsdefinitionsversion aus der Ausgabe.
1. Erstellen Sie eine Gruppenversion, die die Lambda-Funktion des Systems enthält.
+ Ersetzen Sie *group-id* durch die `Id` für die Gruppe.
+ *core-definition-version-arn*Ersetzen Sie es durch `CoreDefinitionVersionArn` das, was Sie aus der neuesten Gruppenversion kopiert haben.
+ *function-definition-version-arn*Ersetzen Sie es durch `Arn` das, was Sie für die neue Version der Funktionsdefinition kopiert haben.
+ Ersetzen Sie die ARNs für andere Gruppenkomponenten (z. B. `SubscriptionDefinitionVersionArn` oder`DeviceDefinitionVersionArn`), die Sie aus der neuesten Gruppenversion kopiert haben.
+ Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel `--resource-definition-version-arn`, wenn Ihre Gruppenversion keine Ressourcen enthält.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Kopieren Sie die `Version` aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.
1. Stellen Sie die Gruppe mit der neuen Gruppenversion bereit.
+ *group-id*Ersetzen Sie sie durch `Id` die, die Sie für die Gruppe kopiert haben.
+ *group-version-id*Ersetzen Sie es durch `Version` das, was Sie für die neue Gruppenversion kopiert haben.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Um die Speichereinstellungen zu aktualisieren, verwenden Sie die AWS IoT Greengrass API, um eine neue Version der Funktionsdefinition zu erstellen, die die `GGCloudSpooler` Funktion mit der aktualisierten Konfiguration enthält. Fügen Sie anschließend die Funktionsdefinitionsversion einer neuen Gruppenversion (zusammen mit Ihren anderen Gruppenkomponenten) hinzu und stellen Sie die Gruppenversion bereit. Wenn Sie die Standardkonfiguration wiederherstellen möchten, können Sie eine Funktionsdefinitionsversion bereitstellen, in der die `GGCloudSpooler`-Funktion nicht enthalten ist.
Diese System-Lambda-Funktion ist in der Konsole nicht sichtbar. Nachdem die Funktion der neuesten Gruppenversion hinzugefügt wurde, ist sie allerdings in Bereitstellungen enthalten, die Sie von der Konsole aus erstellen, es sei denn, Sie ersetzen oder verschieben sie mit der API.
### Persistente MQTT-Sitzungen mit AWS IoT Core
Diese Funktion ist für AWS IoT Greengrass Core v1.10 und höher verfügbar.
Ein Greengrass-Core kann eine persistente Sitzung mit dem AWS IoT Message Broker aufbauen. Eine dauerhafte Sitzung ist eine fortlaufende Verbindung, die es dem Core ermöglicht, Nachrichten zu empfangen, die gesendet werden, während der Core offline ist. Der Core ist der Client in der Verbindung.
In einer persistenten Sitzung speichert der AWS IoT Message Broker alle Abonnements, die der Core während der Verbindung abschließt. [Wenn der Core die Verbindung trennt, speichert der AWS IoT Message Broker unbestätigte und neue Nachrichten, die als QoS 1 veröffentlicht wurden und für lokale Ziele wie Lambda-Funktionen und Client-Geräte bestimmt sind.](what-is-gg.md#greengrass-devices) Wenn der Core wieder eine Verbindung herstellt, wird die persistente Sitzung wieder aufgenommen und der AWS IoT Message Broker sendet gespeicherte Nachrichten mit einer maximalen Rate von 10 Nachrichten pro Sekunde an den Core. Dauerhafte Sitzungen haben eine Standardablauffrist von 1 Stunde, die beginnt, wenn der Nachrichtenbroker erkennt, dass der Core getrennt wird. *Weitere Informationen finden Sie unter [Persistente MQTT-Sitzungen im AWS IoT Entwicklerhandbuch](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt-persistent-sessions.html).*
AWS IoT Greengrass verwendet die Spooler-Systemkomponente (die `GGCloudSpooler` Lambda-Funktion), um Abonnements zu erstellen, die AWS IoT als Quelle haben. Sie können die folgende `GGCloudSpooler`-Umgebungsvariable verwenden, um persistente Sitzungen zu konfigurieren.
+ **GG\$1CONFIG\$1SUBSCRIPTION\$1QUALITY**. Die Qualität von Abonnements, die AWS IoT als Quelle verwenden. Die folgenden Werte sind gültig:
+ `AtMostOnce` (default). Deaktiviert persistente Sitzungen. Abonnements verwenden QoS 0.
+ `AtLeastOncePersistent`. Aktiviert persistente Sitzungen. Legt das `cleanSession`-Flag in `CONNECT`-Nachrichten auf `0` fest und abonniert mit QoS 1.
Nachrichten, die mit QoS 1 veröffentlicht wurden, die der Core erhält, erreichen garantiert die In-Memory-Arbeitswarteschlange des Greengrass-Daemons. Der Core bestätigt die Nachricht, nachdem sie zur Warteschlange hinzugefügt wurde. Die nachfolgende Kommunikation von der Warteschlange zum lokalen Ziel (z. B. Greengrass Lambda-Funktion, Connector oder Gerät) wird als QoS 0 gesendet. AWS IoT Greengrass garantiert nicht die Zustellung an lokale Ziele.
**Anmerkung**
Sie können die Konfigurationseigenschaft [maxWorkItemCount](#config-json-runtime) verwenden, um die Größe der Warteschlange für Arbeitsaufgaben zu steuern. Beispielsweise können Sie die Warteschlangengröße erhöhen, wenn Ihre Arbeitslast einen hohen MQTT-Datenverkehr erfordert.
Wenn persistente Sitzungen aktiviert sind, öffnet der Core mindestens eine zusätzliche Verbindung für den MQTT-Nachrichtenaustausch mit AWS IoT. Weitere Informationen finden Sie unter [Client IDs für MQTT-Verbindungen mit AWS IoT](#connection-client-id).
#### So konfigurieren Sie persistente MQTT-Sitzungen
Sie können konfigurieren AWS IoT Greengrass , dass persistente Sitzungen mit AWS IoT Core verwendet werden. Dazu stellen Sie eine Funktionsdefinitionsversion bereit, in der die `GGCloudSpooler`-Funktion die Abonnementqualität auf `AtLeastOncePersistent` festlegt. Diese Einstellung gilt für alle Ihre Abonnements, die AWS IoT Core (`cloud`) als Quelle haben. Sie müssen die AWS IoT Greengrass API verwenden, um persistente Sitzungen zu konfigurieren. Sie können dies von der Konsole aus erledigen.
Das folgende Verfahren verwendet den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html)CLI-Befehl, um den Spooler für die Verwendung persistenter Sitzungen zu konfigurieren. In diesem Verfahren wird davon ausgegangen, dass Sie die Konfiguration auf die neueste Gruppenversion einer vorhandenen Gruppe aktualisieren.
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie finden diese Werte auch in der AWS IoT Konsole. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `LatestVersion`Werte und `Id` aus der Zielgruppe in die Ausgabe.
1. Rufen Sie die neueste Gruppenversion ab.
+ Ersetzen Sie *group-id* durch den `Id`, den Sie kopiert haben.
+ Ersetzen Sie *latest-group-version-id* durch den `LatestVersion`, den Sie kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Kopieren Sie aus dem `Definition` Objekt in der Ausgabe die `CoreDefinitionVersionArn` und die ARNs aller anderen Gruppenkomponenten außer`FunctionDefinitionVersionArn`. Diese Werte verwenden Sie, wenn Sie eine neue Gruppenversion erstellen.
1. Kopieren Sie die ID der Funktionsdefinition aus `FunctionDefinitionVersionArn`. Die ID ist die GUID, die dem `functions`-Segment im ARN folgt, wie im folgenden Beispiel gezeigt.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**Anmerkung**
Sie können auch eine Funktionsdefinition erstellen, indem Sie den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)Befehl ausführen und dann die ID aus der Ausgabe kopieren.
1. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.
+ *function-definition-id*Ersetzen Sie sie durch `Id` die, die Sie für die Funktionsdefinition kopiert haben.
+ *arbitrary-function-id*Ersetzen Sie durch einen Namen für die Funktion, z. **spooler-function** B.
+ Fügen Sie dem `functions` Array alle Lambda-Funktionen hinzu, die Sie in diese Version aufnehmen möchten. Sie können den [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html)Befehl verwenden, um die Greengrass Lambda-Funktionen aus einer vorhandenen Funktionsdefinitionsversion abzurufen.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_SUBSCRIPTION_QUALITY":"AtLeastOncePersistent"}},"Executable": "spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'
```
**Anmerkung**
Wenn Sie zuvor die Umgebungsvariablen `GG_CONFIG_STORAGE_TYPE` oder `GG_CONFIG_MAX_SIZE_BYTES` zum [Definieren von Speichereinstellungen](#mqtt-message-queue) festlegen, schließen Sie sie in diese Funktions-Instance ein.
1. Kopieren Sie den `Arn` der Funktionsdefinitionsversion aus der Ausgabe.
1. Erstellen Sie eine Gruppenversion, die die Lambda-Funktion des Systems enthält.
+ Ersetzen Sie *group-id* durch die `Id` für die Gruppe.
+ *core-definition-version-arn*Ersetzen Sie es durch `CoreDefinitionVersionArn` das, was Sie aus der neuesten Gruppenversion kopiert haben.
+ *function-definition-version-arn*Ersetzen Sie es durch `Arn` das, was Sie für die neue Version der Funktionsdefinition kopiert haben.
+ Ersetzen Sie die ARNs für andere Gruppenkomponenten (z. B. `SubscriptionDefinitionVersionArn` oder`DeviceDefinitionVersionArn`), die Sie aus der neuesten Gruppenversion kopiert haben.
+ Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel `--resource-definition-version-arn`, wenn Ihre Gruppenversion keine Ressourcen enthält.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Kopieren Sie die `Version` aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.
1. Stellen Sie die Gruppe mit der neuen Gruppenversion bereit.
+ *group-id*Ersetzen Sie sie durch `Id` die, die Sie für die Gruppe kopiert haben.
+ *group-version-id*Ersetzen Sie es durch `Version` das, was Sie für die neue Gruppenversion kopiert haben.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
1. (Optional) Erhöhen Sie die Eigenschaft [maxWorkItemCount](#config-json-runtime) in der Core-Konfigurationsdatei. Dies kann dem Core helfen, erhöhten MQTT-Datenverkehr und die Kommunikation mit lokalen Zielen zu bewältigen.
Um den Core mit diesen Konfigurationsänderungen zu aktualisieren, verwenden Sie die AWS IoT Greengrass API, um eine neue Version der Funktionsdefinition zu erstellen, die die `GGCloudSpooler` Funktion mit der aktualisierten Konfiguration enthält. Fügen Sie anschließend die Funktionsdefinitionsversion einer neuen Gruppenversion (zusammen mit Ihren anderen Gruppenkomponenten) hinzu und stellen Sie die Gruppenversion bereit. Wenn Sie die Standardkonfiguration wiederherstellen möchten, können Sie eine Funktionsdefinitionsversion erstellen, in der die `GGCloudSpooler`-Funktion nicht enthalten ist.
Diese System-Lambda-Funktion ist in der Konsole nicht sichtbar. Nachdem die Funktion der neuesten Gruppenversion hinzugefügt wurde, ist sie allerdings in Bereitstellungen enthalten, die Sie von der Konsole aus erstellen, es sei denn, Sie ersetzen oder verschieben sie mit der API.
### Client IDs für MQTT-Verbindungen mit AWS IoT
Diese Funktion ist für AWS IoT Greengrass Core v1.8 und höher verfügbar.
Der Greengrass-Kern öffnet MQTT-Verbindungen AWS IoT Core für Operationen wie Shadow Sync und Zertifikatsverwaltung. Für diese Verbindungen generiert der Core einen vorhersehbaren Client, der auf dem IDs Namen des Kern-Dings basiert. Der IDs Predictable Client kann mit Überwachungs-, Prüf- und Preisfunktionen, einschließlich AWS IoT Device Defender [AWS IoT Lebenszyklusereignissen](https://docs.aws.amazon.com/iot/latest/developerguide/life-cycle-events.html), verwendet werden. Sie können auch Logik rund um den Predictable Client erstellen IDs (z. B. Vorlagen für [Abonnementrichtlinien](https://docs.aws.amazon.com/iot/latest/developerguide/pub-sub-policy.html#pub-sub-policy-cert), die auf Zertifikatsattributen basieren).
------
#### [ GGC v1.9 and later ]
Zwei Greengrass-Systemkomponenten öffnen MQTT-Verbindungen mit. AWS IoT Core Diese Komponenten verwenden die folgenden Muster, um den Client IDs für die Verbindungen zu generieren.
| Operation | Client-ID Muster |
| --- | --- |
| Bereitstellungen | `core-thing-name` Beispiel: `MyCoreThing` Verwenden Sie diese Client-ID für Benachrichtigungen bei folgenden Lebenszyklusereignissen: Verbinden, Verbindung trennen, Abonnieren und Abonnement kündigen. |
| Subscriptions (Abonnements) | `core-thing-name-cn` Beispiel: `MyCoreThing-c01` `n`ist eine Ganzzahl, die bei 00 beginnt und bei jeder neuen Verbindung auf eine maximale Anzahl von 250 erhöht wird. Die Anzahl der Verbindungen wird durch die Anzahl der Geräte bestimmt, mit denen ihr Schattenstatus synchronisiert wird AWS IoT Core (maximal 2.500 pro Gruppe), und durch die Anzahl der Abonnements, deren Quelle in der Gruppe ist (maximal 10.000 pro Gruppe). `cloud` Die Spooler-Systemkomponente stellt eine Verbindung her AWS IoT Core , um Nachrichten für Abonnements mit einer Cloud-Quelle oder einem Cloud-Ziel auszutauschen. Der Spooler fungiert auch als Proxy für den Nachrichtenaustausch zwischen dem lokalen Shadow-Dienst AWS IoT Core und dem Gerätezertifikatsmanager. |
Verwenden Sie die folgende Formel, um die Anzahl der MQTT-Verbindungen pro Gruppe zu berechnen:
`number of MQTT connections per group = number of connections for Deployment Agent + number of connections for Subscriptions`
Wobei gilt,
+ Anzahl der Verbindungen für Deployment Agent = 1.
+ Anzahl der Verbindungen für Abonnements =`(2 subscriptions for supporting certificate generation + number of MQTT topics in AWS IoT Core + number of device shadows synced) / 50`.
+ Wobei, `50` = die maximale Anzahl von Abonnements pro Verbindung, die unterstützt AWS IoT Core werden können.
**Anmerkung**
Wenn Sie [persistente Sitzungen](#mqtt-persistent-sessions) für das Abonnement aktivieren AWS IoT Core, öffnet der Core mindestens eine zusätzliche Verbindung, die in einer persistenten Sitzung verwendet werden kann. Die Systemkomponenten unterstützen keine persistenten Sitzungen, sodass sie diese Verbindung nicht gemeinsam nutzen können.
Um die Anzahl der MQTT-Verbindungen zu reduzieren und die Kosten zu senken, können Sie lokale Lambda-Funktionen verwenden, um Daten am Edge zu aggregieren. Dann senden Sie die aggregierten Daten an die. AWS Cloud Dadurch verwenden Sie weniger MQTT-Themen in. AWS IoT Core Weitere Informationen finden Sie unter [AWS IoT Greengrass – Preise](https://aws.amazon.com/greengrass/pricing/).
------
#### [ GGC v1.8 ]
Mehrere Greengrass-Systemkomponenten öffnen MQTT-Verbindungen mit AWS IoT Core. Diese Komponenten verwenden die folgenden Muster, um den Client IDs für die Verbindungen zu generieren.
| Operation | Client-ID Muster |
| --- | --- |
| Bereitstellungen | `core-thing-name` Beispiel: `MyCoreThing` Verwenden Sie diese Client-ID für Benachrichtigungen bei folgenden Lebenszyklusereignissen: Verbinden, Verbindung trennen, Abonnieren und Abonnement kündigen. |
| MQTT-Nachrichtenaustausch mit AWS IoT Core | `core-thing-name-spr` Beispiel: `MyCoreThing-spr` |
| Schattensynchronisierung | `core-thing-name-snn` Beispiel: `MyCoreThing-s01` `nn` ist eine Ganzzahl, die bei 00 beginnt und mit jeder neuen Verbindung auf höchstens 03 ansteigt. Die Anzahl der Verbindungen wird durch die Anzahl der Geräte (maximal 200 Geräte pro Gruppe) bestimmt, mit denen ihr Schattenstatus synchronisiert wird AWS IoT Core (maximal 50 Abonnements pro Verbindung). |
| Gerätezertifikatsverwaltung | `core-thing-name-dcm` Beispiel: `MyCoreThing-dcm` |
------
**Anmerkung**
Doppelte Clients, die bei gleichzeitigen Verbindungen IDs verwendet werden, können zu einer unendlichen Verbindungs-/Trennschleife führen. Dies kann der Fall sein, wenn für ein anderes Gerät festgelegt ist, dass der Core-Gerätename als Client-ID in Verbindungen verwendet wird. Weitere Informationen finden Sie im [Fehlerbehandlungsschritt](gg-troubleshooting.md#config-client-id).
Greengrass-Geräte sind zudem vollständig in den Flotten-Indizierungsdienst von AWS IoT Device Management integriert. Auf diese Weise können Sie Geräte in der Cloud auf der Grundlage von Geräteattributen, Schattenzustand und Verbindungsstatus indizieren und suchen. Greengrass-Geräte stellen beispielsweise mindestens eine Verbindung her, bei der der Objektname als Client-ID verwendet wird, damit Sie mithilfe der Gerätekonnektivitätsindizierung ermitteln können, welche Greengrass-Geräte derzeit mit AWS IoT Core verbunden oder davon getrennt sind. *Weitere Informationen finden Sie unter [Fleet Indexing Service im Entwicklerhandbuch](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html).AWS IoT *
### Konfigurieren des MQTT-Ports für lokales Messaging
Für diese Funktion ist AWS IoT Greengrass Core v1.10 oder höher erforderlich.
[Der Greengrass-Kern fungiert als lokaler Nachrichtenbroker für MQTT-Messaging zwischen lokalen Lambda-Funktionen, Konnektoren und Client-Geräten.](what-is-gg.md#greengrass-devices) Standardmäßig verwendet der Core Port 8883 für MQTT-Datenverkehr im lokalen Netzwerk. Möglicherweise möchten Sie den Port ändern, um Konflikte mit anderer Software zu vermeiden, die auf Port 8883 ausgeführt wird.
**So konfigurieren Sie die Portnummer, die der Core für den lokalen MQTT-Datenverkehr verwendet**
1. Führen Sie den folgenden Befehl aus, um den Greengrass-Daemon zu beenden:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie `greengrass-root/config/config.json` zur Bearbeitung als su-Benutzer.
1. Fügen Sie im `coreThing`-Objekt die `ggMqttPort`-Eigenschaft hinzu und legen Sie den Wert auf die Portnummer fest, die Sie verwenden möchten. Gültige Werte sind 1024 bis 65535. Im folgenden Beispiel wird die Portnummer auf `9000` festgelegt.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"ggMqttPort" : 9000,
"keepAlive" : 600
},
...
}
```
1. Starten Sie den -Daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
1. Wenn die [automatische IP-Erkennung](#ip-auto-detect) für den Core aktiviert ist, ist die Konfiguration abgeschlossen.
Wenn die automatische IP-Erkennung nicht aktiviert ist, müssen Sie die Konnektivitätsinformationen für den Core aktualisieren. Auf diese Weise können Client-Geräte bei Erkennungsvorgängen die richtige Portnummer erhalten, um wichtige Verbindungsinformationen zu erhalten. Sie können die AWS IoT Konsole oder AWS IoT Greengrass API verwenden, um die Informationen zur Kernkonnektivität zu aktualisieren. Für dieses Verfahren aktualisieren Sie nur die Portnummer. Die lokale IP-Adresse für den Core bleibt unverändert.
**So aktualisieren Sie die Konnektivitätsinformationen für den Core (Konsole)**
1. Wählen Sie auf der Gruppenkonfigurationsseite den Greengrass-Core aus.
1. Wählen Sie auf der Seite mit den Kerndetails den Tab **MQTT-Broker-Endpoints** aus.
1. **Wählen Sie **Endpoints verwalten** und dann Endpoint hinzufügen**
1. Geben Sie Ihre aktuelle lokale IP-Adresse und die neue Portnummer ein. Im folgenden Beispiel wird die Portnummer `9000` für die IP-Adresse `192.168.1.8` festgelegt.
1. Entfernen Sie den veralteten Endpunkt und wählen Sie dann **Aktualisieren** aus.
**So aktualisieren Sie die Konnektivitätsinformationen für den Core (API)**
+ Verwenden Sie die Aktion „[UpdateConnectivityInfo](https://docs.aws.amazon.com/greengrass/v1/apireference/updateconnectivityinfo-put.html)“. Im folgenden Beispiel wird `update-connectivity-info` in der AWS CLI verwendet, um die Portnummer `9000` für die IP-Adresse `192.168.1.8` festzulegen.
```
aws greengrass update-connectivity-info \
--thing-name "MyGroup_Core" \
--connectivity-info "[{\"Metadata\":\"\",\"PortNumber\":9000,\"HostAddress\":\"192.168.1.8\",\"Id\":\"localIP_192.168.1.8\"},{\"Metadata\":\"\",\"PortNumber\":8883,\"HostAddress\":\"127.0.0.1\",\"Id\":\"localhost_127.0.0.1_0\"}]"
```
**Anmerkung**
Sie können auch den Port konfigurieren, den der Core für MQTT-Messaging verwendet. AWS IoT Core Weitere Informationen finden Sie unter [Verbindungsherstellung auf Port 443 oder über einen Netzwerk-Proxy](#alpn-network-proxy).
### Timeout für Veröffentlichungs-, Abonnierungs- und Abmeldevorgänge in MQTT-Verbindungen mit dem AWS Cloud
Diese Funktion ist in AWS IoT Greengrass Version 1.10.2 oder höher verfügbar.
Sie können die Zeit (in Sekunden) so konfigurieren, dass der Greengrass-Core eine Veröffentlichungs-, Abonnement- oder Abmeldeoperation in MQTT-Verbindungen mit AWS IoT Core abschließen kann. Sie können diese Einstellung anpassen, wenn die Operationen aufgrund von Bandbreitenbeschränkungen oder hoher Latenz zu einer Zeitüberschreitung führen. Um diese Einstellung in der Datei [config.json](#config-json) zu konfigurieren, fügen Sie die `mqttOperationTimeout`-Eigenschaft im `coreThing`-Objekt hinzu, oder ändern Sie sie. Beispiel:
```
{
"coreThing": {
"mqttOperationTimeout": 10,
"caPath": "root-ca.pem",
"certPath": "hash.cert.pem",
"keyPath": "hash.private.key",
...
},
...
}
```
Das Standard-Timeout beträgt 5 Sekunden. Der minimale Timeout beträgt 5 Sekunden.
## Aktivieren der automatischen IP-Erkennung
Sie können so konfigurieren AWS IoT Greengrass , dass Client-Geräte in einer Greengrass-Gruppe den Greengrass-Core automatisch erkennen. Wenn diese Option aktiviert ist, beobachtet der Core Änderungen an seinen IP-Adressen. Wenn sich eine Adresse ändert, veröffentlicht der Core eine aktualisierte Adressliste. Diese Adressen werden Client-Geräten zur Verfügung gestellt, die sich in derselben Greengrass-Gruppe wie der Core befinden.
**Anmerkung**
Die AWS IoT Richtlinie für Client-Geräte muss den Geräten das `greengrass:Discover` Abrufen von Verbindungsinformationen für den Core gestatten. Weitere Informationen zur Richtlinienanweisung finden Sie unter [Discovery-Autorisierung](gg-discover-api.md#gg-discover-auth).
Um diese Funktion von der AWS IoT Greengrass Konsole aus zu aktivieren, wählen Sie **Automatische Erkennung**, wenn Sie Ihre Greengrass-Gruppe zum ersten Mal bereitstellen. Sie können diese Funktion auch auf der Gruppenkonfigurationsseite aktivieren oder deaktivieren, indem Sie die Registerkarte **Lambda-Funktionen** und dann den **IP-Detektor** auswählen. Die automatische IP-Erkennung ist aktiviert, wenn die Option **MQTT-Broker-Endpunkte automatisch erkennen und überschreiben** ausgewählt ist.
Um die automatische Erkennung mit der AWS IoT Greengrass API zu verwalten, müssen Sie die Lambda-Funktion des `IPDetector` Systems konfigurieren. Das folgende Verfahren zeigt, wie Sie den [ create-function-definition-version](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html)CLI-Befehl verwenden, um die automatische Erkennung des Greengrass-Kerns zu konfigurieren.
1. Rufen Sie IDs die Greengrass-Zielgruppe und die Gruppenversion ab. Bei diesem Verfahren wird davon ausgegangen, dass es sich um die neueste Gruppen- und Gruppenversion handelt. Die folgende Abfrage gibt die zuletzt erstellte Gruppe zurück.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Sie können auch nach Namen abfragen. Gruppennamen müssen nicht eindeutig sein, sodass mehrere Gruppen zurückgegeben werden können.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Anmerkung**
Sie finden diese Werte auch in der AWS IoT Konsole. Die Gruppen-ID wird auf der Seite **Einstellungen** der Gruppe angezeigt. Die Gruppenversion IDs wird auf der Registerkarte **Bereitstellungen** der Gruppe angezeigt.
1. Kopieren Sie die `LatestVersion`Werte und `Id` aus der Zielgruppe in die Ausgabe.
1. Rufen Sie die neueste Gruppenversion ab.
+ Ersetzen Sie *group-id* durch den `Id`, den Sie kopiert haben.
+ Ersetzen Sie *latest-group-version-id* durch den `LatestVersion`, den Sie kopiert haben.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Kopieren Sie aus dem `Definition` Objekt in der Ausgabe die `CoreDefinitionVersionArn` und die ARNs aller anderen Gruppenkomponenten außer`FunctionDefinitionVersionArn`. Diese Werte verwenden Sie, wenn Sie eine neue Gruppenversion erstellen.
1. Kopieren Sie die ID der Funktionsdefinition sowie die Funktionsdefinitionsversion aus `FunctionDefinitionVersionArn` in der Ausgabe:
```
arn:aws:greengrass:region:account-id:/greengrass/groups/function-definition-id/versions/function-definition-version-id
```
**Anmerkung**
Sie können optional eine Funktionsdefinition mit dem [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)-Befehl erstellen, und anschließend die ID aus der Ausgabe kopieren.
1. Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html) zum Abrufen des aktuellen Definitionsstatus. Verwenden *function-definition-id* Sie das, was Sie kopiert haben, für die Funktionsdefinition. Beispiel, *4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3*.
```
aws greengrass get-function-definition-version
--function-definition-id function-definition-id
--function-definition-version-id function-definition-version-id
```
Notieren Sie sich die aufgeführten Funktionskonfigurationen. Beim Erstellen einer neuen Funktionsdefinitionsversion müssen Sie diese angeben, um zu verhindern, dass Ihre aktuellen Definitionseinstellungen verloren gehen.
1. Fügen Sie der Funktionsdefinition eine Funktionsdefinitionsversion hinzu.
+ *function-definition-id*Ersetzen Sie es durch `Id` das, was Sie für die Funktionsdefinition kopiert haben. Beispiel, *4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3*.
+ *arbitrary-function-id*Ersetzen Sie durch einen Namen für die Funktion, z. **auto-detection-function** B.
+ Fügen Sie dem `functions` Array alle Lambda-Funktionen hinzu, die Sie in diese Version aufnehmen möchten, z. B. alle im vorherigen Schritt aufgeführten.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn":"arn:aws:lambda:::function:GGIPDetector:1","Id":"arbitrary-function-id","FunctionConfiguration":{"Pinned":true,"MemorySize":32768,"Timeout":3}}]'\
--region us-west-2
```
1. Kopieren Sie den `Arn` der Funktionsdefinitionsversion aus der Ausgabe.
1. Erstellen Sie eine Gruppenversion, die die Lambda-Funktion des Systems enthält.
+ Ersetzen Sie *group-id* durch die `Id` für die Gruppe.
+ *core-definition-version-arn*Ersetzen Sie es durch `CoreDefinitionVersionArn` das, was Sie aus der neuesten Gruppenversion kopiert haben.
+ *function-definition-version-arn*Ersetzen Sie es durch `Arn` das, was Sie für die neue Version der Funktionsdefinition kopiert haben.
+ Ersetzen Sie die ARNs für andere Gruppenkomponenten (z. B. `SubscriptionDefinitionVersionArn` oder`DeviceDefinitionVersionArn`), die Sie aus der neuesten Gruppenversion kopiert haben.
+ Entfernen Sie alle nicht verwendeten Parameter. Entfernen Sie zum Beispiel `--resource-definition-version-arn`, wenn Ihre Gruppenversion keine Ressourcen enthält.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Kopieren Sie die `Version` aus der Ausgabe. Dies ist die ID der neuen Gruppenversion.
1. Stellen Sie die Gruppe mit der neuen Gruppenversion bereit.
+ *group-id*Ersetzen Sie sie durch `Id` die, die Sie für die Gruppe kopiert haben.
+ *group-version-id*Ersetzen Sie es durch `Version` das, was Sie für die neue Gruppenversion kopiert haben.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Wenn Sie die IP-Adresse Ihres Greengrass-Cores manuell eingeben möchten, können Sie dieses Tutorial mit einer anderen Funktionsdefinition abschließen, die die `IPDetector`-Funktion nicht enthält. Dadurch wird verhindert, dass die Erkennungsfunktion Ihre Greengrass-Core-IP-Adresse lokalisiert und automatisch eingibt.
Diese System-Lambda-Funktion ist in der Lambda-Konsole nicht sichtbar. Nachdem die Funktion der neuesten Gruppenversion hinzugefügt wurde, ist sie in Bereitstellungen enthalten, die Sie von der Konsole aus erstellen (es sei denn, Sie ersetzen oder verschieben sie mit der API).
## Konfigurieren das Init-Systems zum Starten des Greengrass-Daemons
Es ist ein bewährtes Verfahren, Ihr Init-System so einzurichten, dass der Greengrass-Daemon beim Startvorgang ausgeführt wird, insbesondere bei der Verwaltung großer Geräteflotten.
**Anmerkung**
Wenn Sie früher `apt` die AWS IoT Greengrass Core-Software installiert haben, können Sie die Systemd-Skripte verwenden, um den Start beim Systemstart zu aktivieren. Weitere Informationen finden Sie unter [Verwenden von systemd-Skripts zum Verwalten des Greengrass Daemon-Lebenszyklus](install-ggc.md#ggc-package-manager-systemd).
Es gibt verschiedene Arten von Init-Systemen, z. B. initd, systemd und SystemV, und sie verwenden ähnliche Konfigurationsparameter. Das folgende Beispiel ist eine Servicedatei für systemd. Der `Type`-Parameter wird auf `forking` festgelegt, da greengrassd (das zum Starten von Greengrass verwendet wird) den Greengrass-Daemon-Prozess verzweigt und der `Restart`-Parameter auf `on-failure` festgelegt wird, um systemd so zu steuern, dass Greengrass neu gestartet wird, wenn Greengrass einen fehlerhaften Zustand aufweist.
**Anmerkung**
Führen Sie das `check_ggc_dependencies`-Skript wie in [Modul 1](module1.md) beschrieben aus, um festzustellen, ob Ihr Gerät systemd verwendet. Zur Verwendung von systemd stellen Sie anschließend sicher, dass der `useSystemd`-Parameter in [`config.json`](#config-json) auf `yes` festgelegt ist.
```
[Unit]
Description=Greengrass Daemon
[Service]
Type=forking
PIDFile=/var/run/greengrassd.pid
Restart=on-failure
ExecStart=/greengrass/ggc/core/greengrassd start
ExecReload=/greengrass/ggc/core/greengrassd restart
ExecStop=/greengrass/ggc/core/greengrassd stop
[Install]
WantedBy=multi-user.target
```
## Weitere Informationen finden Sie auch unter
+ [Was ist AWS IoT Greengrass?](what-is-gg.md)
+ [Unterstützte Plattformen und Anforderungen](what-is-gg.md#gg-platforms)
+ [Erste Schritte mit AWS IoT Greengrass](gg-gs.md)
+ [Überblick über das AWS IoT Greengrass Gruppenobjektmodell](deployments.md#api-overview)
+ [Integration von Hardware-Sicherheit](hardware-security.md)