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. # Docker-Anwendungsbereitstellungs-Konnektor Der Greengrass Docker Application Deployment Connector macht es einfacher, Ihre Docker-Images auf einem Core auszuführen. AWS IoT Greengrass Der Konnektor verwendet Docker Compose, um eine Docker-Anwendung mit mehreren Containern aus einer `docker-compose.yml`-Datei zu starten. Insbesondere führt der Konnektor `docker-compose`-Befehle aus, um Docker-Container auf einem Single-Core-Gerät zu verwalten. Weitere Informationen finden Sie unter [Übersicht über Docker Compose](https://docs.docker.com/compose/) in der Docker-Dokumentation. Der Connector kann auf Docker-Images zugreifen, die in Docker-Container-Registern wie Amazon Elastic Container Registry (Amazon ECR), Docker Hub und privaten vertrauenswürdigen Docker-Registern gespeichert sind. Nachdem Sie die Greengrass-Gruppe bereitgestellt haben, ruft der Connector die neuesten Images ab und startet die Docker-Container. Er führt den Befehl and aus`docker-compose pull`. `docker-compose up` Anschließend veröffentlicht der Konnektor den Status des Befehls in einem [MQTT-Ausgabethema](#docker-app-connector-data-output). Er protokolliert auch Statusinformationen zum Ausführen von Docker-Containern. Auf diese Weise können Sie Ihre Anwendungsprotokolle in Amazon überwachen CloudWatch. Weitere Informationen finden Sie unter [Überwachung mit AWS IoT Greengrass Protokollen](greengrass-logs-overview.md). Der Konnektor startet auch Docker-Container bei jedem Neustart des Greengrass-Daemons. Die Anzahl der Docker-Container, die auf dem Core ausgeführt werden können, hängt von Ihrer Hardware ab. Die Docker-Container werden außerhalb der Greengrass-Domäne auf dem Core-Gerät ausgeführt, sodass sie nicht auf die Interprozesskommunikation (IPC) des Cores zugreifen können. Sie können jedoch einige Kommunikationskanäle mit Greengrass-Komponenten konfigurieren, z. B. lokale Lambda-Funktionen. Weitere Informationen finden Sie unter [Kommunikation mit Docker-Containern](#docker-app-connector-communicating). Sie können den Konnektor für Szenarien wie das Hosten eines Webservers oder eines MySQL-Servers auf Ihrem Core-Gerät verwenden. Lokale Services in Ihren Docker-Anwendungen können miteinander, mit anderen Prozessen in der lokalen Umgebung und mit Cloud-Services kommunizieren. Sie können beispielsweise einen Webserver auf dem Core ausführen, der Anfragen von Lambda-Funktionen an einen Webdienst in der Cloud sendet. Dieser Konnektor wird im [No container (Kein Container)](lambda-group-config.md#no-container-mode)-Isolationsmodus ausgeführt, so dass Sie ihn für eine Greengrass-Gruppe bereitstellen können, die ohne Greengrass-Containerisierung ausgeführt wird. Dieser Connector hat die folgenden Versionen. | Version | ARN | | --- | --- | | 7 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/7` | | 6 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/6` | | 5 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5` | | 4 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/4` | | 3 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/3` | | 2 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/2` | | 1 | `arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/1` | Informationen über Versionsänderungen finden Sie im [Änderungsprotokoll](#docker-app-connector-changelog). ## Voraussetzungen Dieser Konnektor hat die folgenden Anforderungen: + AWS IoT Greengrass Kernsoftware v1.10 oder höher. **Anmerkung** Dieser Connector wird auf OpenWrt Distributionen nicht unterstützt. + [Python-Version](https://www.python.org/) 3.7 oder 3.8 wurde auf dem Core-Gerät installiert und zur Umgebungsvariablen PATH hinzugefügt. **Anmerkung** Um Python 3.8 zu verwenden, führen Sie den folgenden Befehl aus, um einen symbolischen Link vom standardmäßigen Python 3.7-Installationsordner zu den installierten Python 3.8-Binärdateien zu erstellen. ``` sudo ln -s path-to-python-3.8/python3.8 /usr/bin/python3.7 ``` Dadurch wird Ihr Gerät so konfiguriert, dass es die Python-Anforderung für AWS IoT Greengrass erfüllt. + Mindestens 36 MB RAM auf dem Greengrass Core für den Konnektor, um laufende Docker-Container zu überwachen. Der Gesamtspeicherbedarf hängt von der Anzahl der Docker-Container ab, die auf dem Core ausgeführt werden. + [Docker Engine](https://docs.docker.com/install/) 1.9.1 oder höher muss auf dem Greengrass Core installiert sein. Version 19.0.3 ist die neueste Version, die nachgewiesenermaßen mit dem Konnektor funktioniert. Die ausführbare `docker`-Datei muss sich im Verzeichnis `/usr/bin` oder `/usr/local/bin` befinden. **Wichtig** Es wird empfohlen, einen Anmeldeinformationsspeicher zu installieren, um die lokalen Kopien Ihrer Docker-Anmeldeinformationen zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Informationen zur Installation von Docker auf Amazon Linux-Distributionen finden Sie unter [Docker-Grundlagen für Amazon ECS im Amazon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/docker-basics.html) *Elastic Container Service* Developer Guide. + [Docker Compose](https://docs.docker.com/compose/install/) installiert auf dem Greengrass Core. Die ausführbare `docker-compose`-Datei muss sich im Verzeichnis `/usr/bin` oder `/usr/local/bin` befinden. Die folgenden Docker Compose-Versionen funktionieren nachgewiesenermaßen mit dem Konnektor. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/docker-app-connector.html) + Eine einzelne Docker Compose-Datei (z. B.`docker-compose.yml`), gespeichert in Amazon Simple Storage Service (Amazon S3). Das Format muss mit der auf dem Core installierten Version von Docker Compose kompatibel sein. Sie sollten die Datei testen, bevor Sie sie auf Ihrem Core verwenden. Wenn Sie die Datei bearbeiten, nachdem Sie die Greengrass-Gruppe bereitgestellt haben, müssen Sie die Gruppe erneut bereitstellen, um Ihre lokale Kopie auf dem Core zu aktualisieren. + Ein Linux-Benutzer mit der Berechtigung, den lokalen Docker-Daemon aufzurufen und in das Verzeichnis zu schreiben, in dem die lokale Kopie Ihrer Compose-Datei gespeichert ist. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). + Die [Greengrass-Gruppenrolle](group-role.md) muss so konfiguriert sein, dass sie die Aktion `s3:GetObject` für den S3-Bucket zulässt, der Ihre Compose-Datei enthält. Diese Berechtigung wird in der folgenden Beispiel-IAM-Richtlinie gezeigt. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowAccessToComposeFileS3Bucket", "Action": [ "s3:GetObject", "s3:GetObjectVersion" ], "Effect": "Allow", "Resource": "arn:aws:s3:::bucket-name/*" } ] } ``` ------ **Anmerkung** Wenn Ihr S3-Bucket versioning-fähig ist, muss die Rolle the so konfiguriert werden, dass sie die `s3:GetObjectVersion` Aktion ebenfalls zulässt. Weitere Informationen finden Sie unter [Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. Für die Gruppenrollenanforderung müssen Sie die Rolle so konfigurieren, dass die erforderlichen Berechtigungen erteilt werden, und sicherstellen, dass die Rolle der Gruppe hinzugefügt wurde. Für weitere Informationen siehe [Verwalten der Greengrass-Gruppenrolle (Konsole)](group-role.md#manage-group-role-console) oder [Verwalten der Greengrass-Gruppenrolle (CLI)](group-role.md#manage-group-role-cli). + Wenn Ihre Docker Compose-Datei auf ein in Amazon ECR gespeichertes Docker-Image verweist, ist die [Greengrass-Gruppenrolle](group-role.md) so konfiguriert, dass sie Folgendes zulässt: + `ecr:GetDownloadUrlForLayer`und `ecr:BatchGetImage` Aktionen in Ihren Amazon ECR-Repositorys, die die Docker-Images enthalten. + Die `ecr:GetAuthorizationToken`-Aktion für die Ressourcen. Repositorys müssen sich im selben AWS-Konto und AWS-Region wie der Connector befinden. **Wichtig** Berechtigungen in der Gruppenrolle können von allen Lambda-Funktionen und -Konnektoren in der Greengrass-Gruppe übernommen werden. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Diese Berechtigungen werden in der folgenden Beispielrichtlinie angezeigt. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGetEcrRepositories", "Effect": "Allow", "Action": [ "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage" ], "Resource": [ "arn:aws:ecr:us-east-1:123456789012:repository/repository-name" ] }, { "Sid": "AllowGetEcrAuthToken", "Effect": "Allow", "Action": "ecr:GetAuthorizationToken", "Resource": "*" } ] } ``` ------ Weitere Informationen finden Sie unter [Beispiele für Amazon ECR-Repository-Richtlinien](https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html) im *Amazon ECR-Benutzerhandbuch*. Für die Gruppenrollenanforderung müssen Sie die Rolle so konfigurieren, dass die erforderlichen Berechtigungen erteilt werden, und sicherstellen, dass die Rolle der Gruppe hinzugefügt wurde. Für weitere Informationen siehe [Verwalten der Greengrass-Gruppenrolle (Konsole)](group-role.md#manage-group-role-console) oder [Verwalten der Greengrass-Gruppenrolle (CLI)](group-role.md#manage-group-role-cli). + Wenn Ihre Docker Compose-Datei auf ein Docker-Abbild aus [AWS Marketplace](https://aws.amazon.com/marketplace) verweist, gelten für den Konnektor außerdem folgende Anforderungen: + Sie müssen Container-Produkte abonniert haben. AWS Marketplace Weitere Informationen finden Sie unter [Suchen und Abonnieren von Containerprodukten](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-finding-and-subscribing-to-container-products.html) im *AWS Marketplace -Abonnentenhandbuch*. + AWS IoT Greengrass muss so konfiguriert sein, dass es lokale Geheimnisse unterstützt, wie in [Secrets Requirements](secrets.md#secrets-reqs) beschrieben. Der Connector verwendet diese Funktion nur, um Ihre Geheimnisse abzurufen AWS Secrets Manager, nicht um sie zu speichern. + Sie müssen in Secrets Manager für jede AWS Marketplace Registrierung, die ein Docker-Image speichert, auf das in Ihrer Compose-Datei verwiesen wird, ein Geheimnis erstellen. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). + Wenn Ihre Docker Compose-Datei auf ein Docker-Image aus privaten Repositorys in anderen Registern als Amazon ECR verweist, z. B. Docker Hub, hat der Connector auch die folgenden Anforderungen: + AWS IoT Greengrass [muss so konfiguriert sein, dass es lokale Geheimnisse unterstützt, wie in Secrets Requirements beschrieben.](secrets.md#secrets-reqs) Der Connector verwendet diese Funktion nur, um Ihre Geheimnisse abzurufen AWS Secrets Manager, nicht um sie zu speichern. + Sie müssen in Secrets Manager für jedes private Repository, das ein Docker-Image speichert, auf das in Ihrer Compose-Datei verwiesen wird, ein Geheimnis erstellen. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). + Der Docker-Daemon muss ausgeführt werden, wenn Sie eine Greengrass-Gruppe bereitstellen, die diesen Konnektor enthält. ### Zugreifen auf Docker-Images aus privaten Repositorys Wenn Sie Anmeldeinformationen verwenden, um auf Ihre Docker-Abbilder zuzugreifen, müssen Sie dem Konnektor erlauben, darauf zuzugreifen. Wie Sie dies tun, hängt davon ab, wo sich das Docker-Abbild befindet. Für Docker-Images, die in Amazon ECR gespeichert sind, erteilen Sie die Erlaubnis, Ihr Autorisierungstoken in der Greengrass-Gruppenrolle abzurufen. Weitere Informationen finden Sie unter [Voraussetzungen](#docker-app-connector-req). Für Docker-Images, die in anderen privaten Repositorys oder Registern gespeichert sind, müssen Sie ein Secret erstellen, in AWS Secrets Manager dem Ihre Anmeldeinformationen gespeichert werden. Dazu gehören Docker-Images, die Sie abonniert haben. AWS Marketplace Erstellen Sie ein Secret für jedes Repository. Wenn Sie Ihre Secrets in Secrets Manager aktualisieren, werden die Änderungen bei der nächsten Bereitstellung der Gruppe auf den Core übertragen. **Anmerkung** Secrets Manager ist ein Dienst, mit dem Sie Ihre Anmeldeinformationen, Schlüssel und andere Geheimnisse sicher speichern und verwalten können AWS Cloud. Weitere Informationen finden Sie unter [Was ist AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) im *AWS Secrets Manager Benutzerhandbuch*. Jedes Secret muss die folgenden Schlüssel enthalten: | Key (Schlüssel) | Value (Wert) | | --- | --- | | `username` | Der Benutzername, der für den Zugriff auf das Repository oder die Registrierung verwendet wird. | | `password` | Das Passwort, das für den Zugriff auf das Repository oder die Registrierung verwendet wird. | | `registryUrl` | Der Endpunkt der Registrierung. Dies muss mit der entsprechenden Registrierungs-URL in der Compose-Datei übereinstimmen. | **Anmerkung** Um standardmäßig auf ein Secret zugreifen AWS IoT Greengrass zu können, muss der Name des Secrets mit *greengrass-* beginnen. Andernfalls muss Ihre Greengrass-Servicerolle Zugriff gewähren. Weitere Informationen finden Sie unter [Erlaubt das Abrufen geheimer Werte AWS IoT Greengrass](secrets.md#secrets-config-service-role). **So rufen Sie Anmeldeinformationen für Docker-Abbilder aus AWS Marketplace ab** 1. Rufen Sie Ihr Passwort für Docker-Images mit dem AWS Marketplace `aws ecr get-login-password` Befehl ab. Weitere Informationen finden Sie unter [get-login-password](https://docs.aws.amazon.com/cli/latest/reference/ecr/get-login.html) in der Referenz zum *AWS CLI -Befehl*. ``` aws ecr get-login-password ``` 1. Rufen Sie die Registrierungs-URL für das Docker-Image ab. Öffnen Sie die AWS Marketplace Website und die Startseite für das Container-Produkt. Wählen Sie unter **Container-Images** die Option **Container-Image-Details anzeigen** aus, um den Benutzernamen und die Registrierungs-URL zu finden. Verwenden Sie den abgerufenen Benutzernamen, das Passwort und die Registrierungs-URL, um ein Geheimnis für jede AWS Marketplace Registrierung zu erstellen, in der Docker-Images gespeichert werden, auf die in Ihrer Compose-Datei verwiesen wird. **So erstellen Sie Secrets (Konsole)** Wählen Sie in der AWS Secrets Manager Konsole **Andere Arten von Geheimnissen aus**. Fügen Sie unter **Angabe der Schlüssel/Wert-Paare, die für dieses Secret gespeichert werden sollen** Zeilen für `username`, `password` und `registryUrl` hinzu. Weitere Informationen finden Sie im *AWS Secrets Manager Benutzerhandbuch* unter [Erstellen eines grundlegenden Geheimnisses](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html). ![\[Erstellen eines Secrets mit Benutzernamen, Passwort und registryUrl-Schlüsseln.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/connectors/secret-docker-trusted-registry.png) **So erstellen Sie Secrets (CLI)** Verwenden Sie in der AWS CLI den Secrets Manager `create-secret` Manager-Befehl, wie im folgenden Beispiel gezeigt. Weitere Informationen finden Sie unter [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html) in der *AWS CLI Befehlsreferenz*. ``` aws secretsmanager create-secret --name greengrass-MySecret --secret-string [{"username":"Mary_Major"},{"password":"abc123xyz456"},{"registryUrl":"https://docker.io"}] ``` **Wichtig** Es liegt in Ihrer Verantwortung, das `DockerComposeFileDestinationPath`-Verzeichnis zu sichern, in dem Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert sind. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). ## Parameters Dieser Konnektor stellt die folgenden Parameter bereit: ------ #### [ Version 7 ] `DockerComposeFileS3Bucket` Der Name des S3-Buckets, der Ihre Docker Compose-Datei enthält. Achten Sie bei der Erstellung des Buckets darauf, die [Regeln für Bucket-Namen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) zu befolgen, die im *Amazon Simple Storage Service-Benutzerhandbuch* beschrieben sind. Anzeigename in der AWS IoT Konsole: **Docker Compose-Datei in S3** In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` Der Objektschlüssel für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie unter [Objektschlüssel und Metadaten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `.+` `DockerComposeFileS3Version` Die Objektversion für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie [unter Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `false` Typ: `string` Gültiges Muster `.+` `DockerComposeFileDestinationPath` Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern einer Kopie der Docker Compose-Datei verwendet wird. Dies muss ein vorhandenes Verzeichnis sein. Der für `DockerUserId` angegebene Benutzer muss über die Berechtigung zum Erstellen einer Datei in diesem Verzeichnis verfügen. Weitere Informationen finden Sie unter [Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass](#docker-app-connector-linux-user). In diesem Verzeichnis werden Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Anzeigename in der AWS IoT Konsole: **Verzeichnispfad für die lokale Compose-Datei** Erforderlich: `true` Typ: `string` Gültiges Muster `\/.*\/?` Beispiel: `/home/username/myCompose` `DockerUserId` Die UID des Linux-Benutzers, unter dem der Konnektor ausgeführt wird. Dieser Benutzer muss zur `docker`-Linux-Gruppe auf dem Core-Gerät gehören und Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis haben. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). Anzeigename in der AWS IoT Konsole: **Docker-Benutzer-ID** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[0-9]{1,5}$` `AWSSecretsArnList` Die Amazon-Ressourcennamen (ARNs) der darin enthaltenen Geheimnisse enthalten die Anmeldeinformationen AWS Secrets Manager , die für den Zugriff auf Ihre Docker-Images in privaten Repositorys verwendet werden. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). Anzeigename in der AWS IoT Konsole: **Anmeldeinformationen für** private Repositorys Erforderlich: `false`. Dieser Parameter ist erforderlich, um auf Docker-Abbilder zuzugreifen, die in privaten Repositorys gespeichert sind. Typ: `array` von `string` Gültiges Muster: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Die Häufigkeit (in Sekunden), mit der der Konnektor Statusinformationen über die Docker-Container protokolliert, die auf dem Core ausgeführt werden. Der Standardwert ist 300 Sekunden (5 Minuten). Anzeigename in der AWS IoT Konsole: **Häufigkeit der Protokollierung** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Gibt an, ob die Docker-Bereitstellung erzwungen werden soll, wenn sie aufgrund einer unsachgemäßen Bereinigung der letzten Bereitstellung fehlschlägt. Der Standardwert ist `False`. **Anzeigename in der AWS IoT Konsole: Bereitstellung erzwingen** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `DockerPullBeforeUp` Gibt an, ob der Deployer ausgeführt werden soll, `docker-compose pull` bevor er `docker-compose up` für ein pull-down-up Verhalten ausgeführt wird. Der Standardwert ist `True`. Anzeigename in der AWS IoT Konsole: **Docker Pull Before Up** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `StopContainersOnNewDeployment` Gibt an, ob der Connector die von Docker Deployer verwalteten Docker-Container stoppen soll, wenn GGC gestoppt wird (GGC stoppt, wenn eine neue Gruppe bereitgestellt wird oder der Kernel heruntergefahren wird). Der Standardwert ist `True`. **Anzeigename in der AWS IoT Konsole: Docker stoppt bei neuer Bereitstellung** Wir empfehlen, für diesen Parameter den `True` Standardwert beizubehalten. Der Parameter to `False` bewirkt, dass Ihr Docker-Container auch nach dem Beenden des AWS IoT Greengrass Cores oder dem Starten einer neuen Bereitstellung weiter ausgeführt wird. Wenn Sie diesen Parameter auf setzen, müssen Sie sicherstellen`False`, dass Ihre Docker-Container im Falle einer Änderung oder Hinzufügung eines `docker-compose` Servicenamens nach Bedarf beibehalten werden. Weitere Informationen finden Sie in der Dokumentation zur `docker-compose` Compose-Datei. Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `DockerOfflineMode` Gibt an, ob die vorhandene Docker Compose-Datei verwendet werden soll, wenn sie offline AWS IoT Greengrass gestartet wird. Der Standardwert ist `False`. Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` ------ #### [ Version 6 ] `DockerComposeFileS3Bucket` Der Name des S3-Buckets, der Ihre Docker Compose-Datei enthält. Achten Sie bei der Erstellung des Buckets darauf, die [Regeln für Bucket-Namen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) zu befolgen, die im *Amazon Simple Storage Service-Benutzerhandbuch* beschrieben sind. Anzeigename in der AWS IoT Konsole: **Docker Compose-Datei in S3** In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` Der Objektschlüssel für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie unter [Objektschlüssel und Metadaten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `.+` `DockerComposeFileS3Version` Die Objektversion für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie [unter Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `false` Typ: `string` Gültiges Muster `.+` `DockerComposeFileDestinationPath` Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern einer Kopie der Docker Compose-Datei verwendet wird. Dies muss ein vorhandenes Verzeichnis sein. Der für `DockerUserId` angegebene Benutzer muss über die Berechtigung zum Erstellen einer Datei in diesem Verzeichnis verfügen. Weitere Informationen finden Sie unter [Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass](#docker-app-connector-linux-user). In diesem Verzeichnis werden Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Anzeigename in der AWS IoT Konsole: **Verzeichnispfad für die lokale Compose-Datei** Erforderlich: `true` Typ: `string` Gültiges Muster `\/.*\/?` Beispiel: `/home/username/myCompose` `DockerUserId` Die UID des Linux-Benutzers, unter dem der Konnektor ausgeführt wird. Dieser Benutzer muss zur `docker`-Linux-Gruppe auf dem Core-Gerät gehören und Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis haben. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). Anzeigename in der AWS IoT Konsole: **Docker-Benutzer-ID** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[0-9]{1,5}$` `AWSSecretsArnList` Die Amazon-Ressourcennamen (ARNs) der darin enthaltenen Geheimnisse enthalten die Anmeldeinformationen AWS Secrets Manager , die für den Zugriff auf Ihre Docker-Images in privaten Repositorys verwendet werden. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). Anzeigename in der AWS IoT Konsole: **Anmeldeinformationen für** private Repositorys Erforderlich: `false`. Dieser Parameter ist erforderlich, um auf Docker-Abbilder zuzugreifen, die in privaten Repositorys gespeichert sind. Typ: `array` von `string` Gültiges Muster: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Die Häufigkeit (in Sekunden), mit der der Konnektor Statusinformationen über die Docker-Container protokolliert, die auf dem Core ausgeführt werden. Der Standardwert ist 300 Sekunden (5 Minuten). Anzeigename in der AWS IoT Konsole: **Häufigkeit der Protokollierung** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Gibt an, ob die Docker-Bereitstellung erzwungen werden soll, wenn sie aufgrund einer unsachgemäßen Bereinigung der letzten Bereitstellung fehlschlägt. Der Standardwert ist `False`. **Anzeigename in der AWS IoT Konsole: Bereitstellung erzwingen** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `DockerPullBeforeUp` Gibt an, ob der Deployer ausgeführt werden soll, `docker-compose pull` bevor er `docker-compose up` für ein pull-down-up Verhalten ausgeführt wird. Der Standardwert ist `True`. Anzeigename in der AWS IoT Konsole: **Docker Pull Before Up** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `StopContainersOnNewDeployment` Gibt an, ob der Connector die von Docker Deployer verwalteten Docker-Container stoppen soll, wenn GGC gestoppt wird (wenn eine neue Gruppenbereitstellung erfolgt oder der Kernel heruntergefahren wird). Der Standardwert ist `True`. Anzeigename in der AWS IoT Konsole: **Docker** stoppt bei neuer Bereitstellung Wir empfehlen, für diesen Parameter den `True` Standardwert beizubehalten. Der Parameter to `False` bewirkt, dass Ihr Docker-Container auch nach dem Beenden des AWS IoT Greengrass Cores oder dem Starten einer neuen Bereitstellung weiter ausgeführt wird. Wenn Sie diesen Parameter auf setzen, müssen Sie sicherstellen`False`, dass Ihre Docker-Container im Falle einer Änderung oder Hinzufügung eines `docker-compose` Servicenamens nach Bedarf beibehalten werden. Weitere Informationen finden Sie in der Dokumentation zur `docker-compose` Compose-Datei. Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` ------ #### [ Version 5 ] `DockerComposeFileS3Bucket` Der Name des S3-Buckets, der Ihre Docker Compose-Datei enthält. Achten Sie bei der Erstellung des Buckets darauf, die [Regeln für Bucket-Namen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) zu befolgen, die im *Amazon Simple Storage Service-Benutzerhandbuch* beschrieben sind. Anzeigename in der AWS IoT Konsole: **Docker Compose-Datei in S3** In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` Der Objektschlüssel für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie unter [Objektschlüssel und Metadaten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `.+` `DockerComposeFileS3Version` Die Objektversion für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie [unter Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `false` Typ: `string` Gültiges Muster `.+` `DockerComposeFileDestinationPath` Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern einer Kopie der Docker Compose-Datei verwendet wird. Dies muss ein vorhandenes Verzeichnis sein. Der für `DockerUserId` angegebene Benutzer muss über die Berechtigung zum Erstellen einer Datei in diesem Verzeichnis verfügen. Weitere Informationen finden Sie unter [Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass](#docker-app-connector-linux-user). In diesem Verzeichnis werden Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Anzeigename in der AWS IoT Konsole: **Verzeichnispfad für die lokale Compose-Datei** Erforderlich: `true` Typ: `string` Gültiges Muster `\/.*\/?` Beispiel: `/home/username/myCompose` `DockerUserId` Die UID des Linux-Benutzers, unter dem der Konnektor ausgeführt wird. Dieser Benutzer muss zur `docker`-Linux-Gruppe auf dem Core-Gerät gehören und Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis haben. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). Anzeigename in der AWS IoT Konsole: **Docker-Benutzer-ID** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[0-9]{1,5}$` `AWSSecretsArnList` Die Amazon-Ressourcennamen (ARNs) der darin enthaltenen Geheimnisse enthalten die Anmeldeinformationen AWS Secrets Manager , die für den Zugriff auf Ihre Docker-Images in privaten Repositorys verwendet werden. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). Anzeigename in der AWS IoT Konsole: **Anmeldeinformationen für** private Repositorys Erforderlich: `false`. Dieser Parameter ist erforderlich, um auf Docker-Abbilder zuzugreifen, die in privaten Repositorys gespeichert sind. Typ: `array` von `string` Gültiges Muster: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Die Häufigkeit (in Sekunden), mit der der Konnektor Statusinformationen über die Docker-Container protokolliert, die auf dem Core ausgeführt werden. Der Standardwert ist 300 Sekunden (5 Minuten). Anzeigename in der AWS IoT Konsole: **Häufigkeit der Protokollierung** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Gibt an, ob die Docker-Bereitstellung erzwungen werden soll, wenn sie aufgrund einer unsachgemäßen Bereinigung der letzten Bereitstellung fehlschlägt. Der Standardwert ist `False`. **Anzeigename in der AWS IoT Konsole: Bereitstellung erzwingen** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` `DockerPullBeforeUp` Gibt an, ob der Deployer ausgeführt werden soll, `docker-compose pull` bevor er `docker-compose up` für ein pull-down-up Verhalten ausgeführt wird. Der Standardwert ist `True`. Anzeigename in der AWS IoT Konsole: **Docker Pull Before Up** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` ------ #### [ Versions 2 - 4 ] `DockerComposeFileS3Bucket` Der Name des S3-Buckets, der Ihre Docker Compose-Datei enthält. Achten Sie bei der Erstellung des Buckets darauf, die [Regeln für Bucket-Namen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) zu befolgen, die im *Amazon Simple Storage Service-Benutzerhandbuch* beschrieben sind. Anzeigename in der AWS IoT Konsole: **Docker Compose-Datei in S3** In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` Der Objektschlüssel für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie unter [Objektschlüssel und Metadaten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `.+` `DockerComposeFileS3Version` Die Objektversion für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie [unter Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `false` Typ: `string` Gültiges Muster `.+` `DockerComposeFileDestinationPath` Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern einer Kopie der Docker Compose-Datei verwendet wird. Dies muss ein vorhandenes Verzeichnis sein. Der für `DockerUserId` angegebene Benutzer muss über die Berechtigung zum Erstellen einer Datei in diesem Verzeichnis verfügen. Weitere Informationen finden Sie unter [Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass](#docker-app-connector-linux-user). In diesem Verzeichnis werden Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Anzeigename in der AWS IoT Konsole: **Verzeichnispfad für die lokale Compose-Datei** Erforderlich: `true` Typ: `string` Gültiges Muster `\/.*\/?` Beispiel: `/home/username/myCompose` `DockerUserId` Die UID des Linux-Benutzers, unter dem der Konnektor ausgeführt wird. Dieser Benutzer muss zur `docker`-Linux-Gruppe auf dem Core-Gerät gehören und Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis haben. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). Anzeigename in der AWS IoT Konsole: **Docker-Benutzer-ID** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[0-9]{1,5}$` `AWSSecretsArnList` Die Amazon-Ressourcennamen (ARNs) der darin enthaltenen Geheimnisse enthalten die Anmeldeinformationen AWS Secrets Manager , die für den Zugriff auf Ihre Docker-Images in privaten Repositorys verwendet werden. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). Anzeigename in der AWS IoT Konsole: **Anmeldeinformationen für** private Repositorys Erforderlich: `false`. Dieser Parameter ist erforderlich, um auf Docker-Abbilder zuzugreifen, die in privaten Repositorys gespeichert sind. Typ: `array` von `string` Gültiges Muster: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Die Häufigkeit (in Sekunden), mit der der Konnektor Statusinformationen über die Docker-Container protokolliert, die auf dem Core ausgeführt werden. Der Standardwert ist 300 Sekunden (5 Minuten). Anzeigename in der AWS IoT Konsole: **Häufigkeit der Protokollierung** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[1-9]{1}[0-9]{0,3}$` `ForceDeploy` Gibt an, ob die Docker-Bereitstellung erzwungen werden soll, wenn sie aufgrund einer unsachgemäßen Bereinigung der letzten Bereitstellung fehlschlägt. Der Standardwert ist `False`. **Anzeigename in der AWS IoT Konsole: Bereitstellung erzwingen** Erforderlich: `false` Typ: `string` Gültiges Muster: `^(true|false)$` ------ #### [ Version 1 ] `DockerComposeFileS3Bucket` Der Name des S3-Buckets, der Ihre Docker Compose-Datei enthält. Achten Sie bei der Erstellung des Buckets darauf, die [Regeln für Bucket-Namen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) zu befolgen, die im *Amazon Simple Storage Service-Benutzerhandbuch* beschrieben sind. Anzeigename in der AWS IoT Konsole: **Docker Compose-Datei in S3** In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `[a-zA-Z0-9\\-\\.]{3,63}` `DockerComposeFileS3Key` Der Objektschlüssel für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie unter [Objektschlüssel und Metadaten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `true` Typ: `string` Gültiges Muster `.+` `DockerComposeFileS3Version` Die Objektversion für Ihre Docker Compose-Datei in Amazon S3. Weitere Informationen, einschließlich Richtlinien zur Benennung von Objektschlüsseln, finden Sie [unter Verwenden der Versionierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. In der Konsole kombiniert die **Docker Compose-Datei in S3**-Eigenschaft die Parameter `DockerComposeFileS3Bucket`, `DockerComposeFileS3Key` und `DockerComposeFileS3Version`. Erforderlich: `false` Typ: `string` Gültiges Muster `.+` `DockerComposeFileDestinationPath` Der absolute Pfad des lokalen Verzeichnisses, das zum Speichern einer Kopie der Docker Compose-Datei verwendet wird. Dies muss ein vorhandenes Verzeichnis sein. Der für `DockerUserId` angegebene Benutzer muss über die Berechtigung zum Erstellen einer Datei in diesem Verzeichnis verfügen. Weitere Informationen finden Sie unter [Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass](#docker-app-connector-linux-user). In diesem Verzeichnis werden Ihre Docker Compose-Datei und die Anmeldeinformationen für Ihre Docker-Abbilder aus privaten Repositorys gespeichert. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Weitere Informationen finden Sie unter [Sicherheitshinweise](#docker-app-connector-security). Anzeigename in der AWS IoT Konsole: **Verzeichnispfad für die lokale Compose-Datei** Erforderlich: `true` Typ: `string` Gültiges Muster `\/.*\/?` Beispiel: `/home/username/myCompose` `DockerUserId` Die UID des Linux-Benutzers, unter dem der Konnektor ausgeführt wird. Dieser Benutzer muss zur `docker`-Linux-Gruppe auf dem Core-Gerät gehören und Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis haben. Weitere Informationen finden Sie unter [Einrichten des Docker-Benutzers auf dem Core](#docker-app-connector-linux-user). Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). Anzeigename in der AWS IoT Konsole: **Docker-Benutzer-ID** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[0-9]{1,5}$` `AWSSecretsArnList` Die Amazon-Ressourcennamen (ARNs) der darin enthaltenen Geheimnisse enthalten die Anmeldeinformationen AWS Secrets Manager , die für den Zugriff auf Ihre Docker-Images in privaten Repositorys verwendet werden. Weitere Informationen finden Sie unter [Zugreifen auf Docker-Images aus privaten Repositorys](#access-private-repositories). Anzeigename in der AWS IoT Konsole: **Anmeldeinformationen für** private Repositorys Erforderlich: `false`. Dieser Parameter ist erforderlich, um auf Docker-Abbilder zuzugreifen, die in privaten Repositorys gespeichert sind. Typ: `array` von `string` Gültiges Muster: `[( ?,? ?"(arn:(aws(-[a-z]+)):secretsmanager:[a-z0-9-]+:[0-9]{12}:secret:([a-zA-Z0-9\]+/)[a-zA-Z0-9/_+=,.@-]+-[a-zA-Z0-9]+)")]` `DockerContainerStatusLogFrequency` Die Häufigkeit (in Sekunden), mit der der Konnektor Statusinformationen über die Docker-Container protokolliert, die auf dem Core ausgeführt werden. Der Standardwert ist 300 Sekunden (5 Minuten). Anzeigename in der AWS IoT Konsole: **Häufigkeit der Protokollierung** Erforderlich: `false` Typ: `string` Gültiges Muster: `^[1-9]{1}[0-9]{0,3}$` ------ ### Beispiel für das Erstellen eines Konnektors (AWS CLI) Der folgende CLI-Befehl erstellt einen `ConnectorDefinition` mit einer ersten Version, die den Greengrass Docker Application Deployment Connector enthält. ``` aws greengrass create-connector-definition --name MyGreengrassConnectors --initial-version '{ "Connectors": [ { "Id": "MyDockerAppplicationDeploymentConnector", "ConnectorArn": "arn:aws:greengrass:region::/connectors/DockerApplicationDeployment/versions/5", "Parameters": { "DockerComposeFileS3Bucket": "amzn-s3-demo-bucket", "DockerComposeFileS3Key": "production-docker-compose.yml", "DockerComposeFileS3Version": "123", "DockerComposeFileDestinationPath": "/home/username/myCompose", "DockerUserId": "1000", "AWSSecretsArnList": "[\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret1-hash\",\"arn:aws:secretsmanager:region:account-id:secret:greengrass-secret2-hash\"]", "DockerContainerStatusLogFrequency": "30", "ForceDeploy": "True", "DockerPullBeforeUp": "True" } } ] }' ``` **Anmerkung** Die Lambda-Funktion in diesem Konnektor hat einen [langlebigen Lebenszyklus](lambda-functions.md#lambda-lifecycle). ## Eingabedaten Dieser Konnektor benötigt oder akzeptiert keine Eingabedaten. ## Ausgabedaten Dieser Konnektor veröffentlicht den Status des `docker-compose up`-Befehls als Ausgabedaten. **Themenfilter im Abonnement** `dockerapplicationdeploymentconnector/message/status` **Beispielausgabe: Erfolg** ``` { "status":"success", "GreengrassDockerApplicationDeploymentStatus":"Successfully triggered docker-compose up", "S3Bucket":"amzn-s3-demo-bucket", "ComposeFileName":"production-docker-compose.yml", "ComposeFileVersion":"123" } ``` **Beispielausgabe: Fehler** ``` { "status":"fail", "error_message":"description of error", "error":"InvalidParameter" } ``` Der Fehlertyp kann `InvalidParameter` oder `InternalError` sein. ## Den Docker-Benutzer auf dem Core einrichten AWS IoT Greengrass Der Greengrass Docker Application Deployment Connector wird als der Benutzer ausgeführt, den Sie für den `DockerUserId` Parameter angeben. Wenn Sie keinen Wert angeben, wird der Konnektor als `ggc_user` ausgeführt. Dies ist die standardmäßige Greengrass-Zugriffsidentität. Damit der Konnektor mit dem Docker-Daemon interagieren kann, muss der Docker-Benutzer zur `docker`-Linux-Gruppe auf dem Core gehören. Der Docker-Benutzer muss auch über Schreibberechtigungen für das `DockerComposeFileDestinationPath`-Verzeichnis verfügen. Hier speichert der Konnektor Ihre lokale `docker-compose.yml`-Datei und die Docker-Anmeldeinformationen. **Anmerkung** Es wird empfohlen, einen Linux-Benutzer zu erstellen, anstatt den Standard-`ggc_user` zu verwenden. Andernfalls kann jede Lambda-Funktion in der Greengrass-Gruppe auf die Compose-Datei und die Docker-Anmeldeinformationen zugreifen. Wir empfehlen Ihnen, eine Ausführung als Root zu vermeiden, sofern dies nicht absolut notwendig ist. Wenn Sie den Root-Benutzer angeben, müssen Sie zulassen, dass Lambda-Funktionen auf dem AWS IoT Greengrass Core als Root ausgeführt werden. Weitere Informationen finden Sie unter [Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root). 1. Erstellen Sie den Benutzer. Sie können den `useradd`-Befehl ausführen und die optionale `-u`-Option zum Zuweisen einer UID hinzufügen. Beispiel: ``` sudo useradd -u 1234 user-name ``` 1. Fügen Sie den Benutzer der `docker`-Gruppe auf dem Core hinzu. Beispiel: ``` sudo usermod -aG docker user-name ``` Weitere Informationen, einschließlich dem Erstellen der `docker`-Gruppe, finden Sie unter [Verwalten von Docker als Nicht-Root-Benutzer](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) in der Docker-Dokumentation. 1. Erteilen Sie dem Benutzer die Berechtigungen, in das für den `DockerComposeFileDestinationPath`-Parameter angegebene Verzeichnis zu schreiben. Beispiel: 1. So legen Sie den Benutzer als Besitzer des Verzeichnisses fest. In diesem Beispiel wird die UID aus Schritt 1 verwendet. ``` chown 1234 docker-compose-file-destination-path ``` 1. So erteilen Sie dem Besitzer Lese- und Schreibberechtigungen. ``` chmod 700 docker-compose-file-destination-path ``` Weitere Informationen finden Sie unter [How To Manage File And Folder Permissions In Linux](https://www.linux.com/tutorials/how-manage-file-and-folder-permissions-linux/) in der Linux Foundation-Dokumentation. 1. Wenn Sie beim Erstellen des Benutzers keine UID zugewiesen haben oder wenn Sie einen vorhandenen Benutzer verwendet haben, führen Sie den `id`-Befehl aus, um die UID zu suchen. ``` id -u user-name ``` Sie verwenden die UID, um den `DockerUserId`-Parameter für den Konnektor zu konfigurieren. ## Informationen zur Nutzung Wenn Sie den Greengrass Docker Application Deployment Connector verwenden, sollten Sie die folgenden implementierungsspezifischen Nutzungsinformationen beachten. + **Das Präfix für Projektnamen wurde korrigiert.** Der Konnektor stellt das `greengrassdockerapplicationdeployment`-Präfix den Namen der Docker-Container vor, die er startet. Der Konnektor verwendet dieses Präfix als Projektname in den ausgeführten `docker-compose`-Befehlen. + **Verhalten beim Protokollieren.** Der Konnektor schreibt Statusinformationen und Fehlerbehebungsinformationen in eine Protokolldatei. Sie können so konfigurieren AWS IoT Greengrass , dass CloudWatch Protokolle an Logs gesendet und Logs lokal geschrieben werden. Weitere Informationen finden Sie unter [Protokollieren für Konnektoren](connectors.md#connectors-logging). Dies ist der Pfad zum lokalen Protokoll für den Konnektor: ``` /greengrass-root/ggc/var/log/user/region/aws/DockerApplicationDeployment.log ``` Sie müssen über Root-Berechtigungen verfügen, um auf lokale Protokolle zugreifen zu können. + **Docker-Images werden aktualisiert.** Docker speichert Abbilder auf dem Core-Gerät zwischen. Wenn Sie ein Docker-Abbild aktualisieren und die Änderung an das Core-Gerät weitergeben möchten, stellen Sie sicher, dass Sie das Tag für das Abbild in der Compose-Datei ändern. Änderungen werden wirksam, nachdem die Greengrass-Gruppe bereitgestellt wurde. + **10-minütiges Timeout für Aufräumarbeiten.** Wenn der Greengrass-Daemon während eines Neustarts stoppt, wird der `docker-compose down` Befehl initiiert. Alle Docker-Container haben nach der Initiierung maximal 10 Minuten Zeit, um alle `docker-compose down` Bereinigungsvorgänge durchzuführen. Wenn die Bereinigung nicht innerhalb von 10 Minuten abgeschlossen ist, müssen Sie die verbleibenden Container manuell bereinigen. Weitere Informationen finden Sie unter [docker rm](https://docs.docker.com/engine/reference/commandline/rm/) in der Docker-CLI-Dokumentation. + **Docker-Befehle ausführen.** Um Probleme zu beheben, können Sie Docker-Befehle in einem Terminalfenster auf dem Core-Gerät ausführen. Führen Sie beispielsweise den folgenden Befehl aus, um die Docker-Container anzuzeigen, die vom Konnektor gestartet wurden: ``` docker ps --filter name="greengrassdockerapplicationdeployment" ``` + **Reservierte Ressourcen-ID.** Der Konnektor verwendet die `DOCKER_DEPLOYER_SECRET_RESOURCE_RESERVED_ID_index`-ID für die Greengrass-Ressourcen, die er in der Greengrass-Gruppe erstellt. Die Ressource IDs muss in der Gruppe eindeutig sein. Weisen Sie daher keine Ressourcen-ID zu, die mit dieser reservierten Ressourcen-ID in Konflikt geraten könnte. + **Offline-Modus.** Wenn Sie den `DockerOfflineMode` Konfigurationsparameter auf setzen`True`, kann der Docker-Connector im *Offline-Modus* betrieben werden. Dies kann passieren, wenn eine Greengrass-Gruppenbereitstellung neu gestartet wird, während das Kerngerät offline ist und der Connector keine Verbindung zu Amazon S3 oder Amazon ECR herstellen kann, um die Docker Compose-Datei abzurufen. Wenn der Offline-Modus aktiviert ist, versucht der Connector, Ihre Compose-Datei herunterzuladen und `docker login` Befehle auszuführen, wie dies bei einem normalen Neustart der Fall wäre. Wenn diese Versuche fehlschlagen, sucht der Connector nach einer lokal gespeicherten Compose-Datei in dem Ordner, der mit dem `DockerComposeFileDestinationPath` Parameter angegeben wurde. Wenn eine lokale Compose-Datei vorhanden ist, folgt der Konnektor der normalen `docker-compose` Befehlsfolge und bezieht Daten aus lokalen Bildern. Wenn die Compose-Datei oder die lokalen Bilder nicht vorhanden sind, schlägt der Connector fehl. Das Verhalten der `StopContainersOnNewDeployment` Parameter `ForceDeploy` und bleibt im Offline-Modus gleich. ## Kommunikation mit Docker-Containern AWS IoT Greengrass unterstützt die folgenden Kommunikationskanäle zwischen Greengrass-Komponenten und Docker-Containern: + Greengrass Lambda-Funktionen können REST verwenden, APIs um mit Prozessen in Docker-Containern zu kommunizieren. Sie können einen Server in einem Docker-Container einrichten, der einen Port öffnet. Lambda-Funktionen können mit dem Container an diesem Port kommunizieren. + Prozesse in Docker-Containern können MQTT-Nachrichten über den lokalen Greengrass-Nachrichtenbroker austauschen. Sie können den Docker-Container als Client-Gerät in der Greengrass-Gruppe einrichten und dann Abonnements erstellen, damit der Container mit Greengrass Lambda-Funktionen, Client-Geräten und anderen Connectoren in der Gruppe oder mit AWS IoT und dem lokalen Shadow-Service kommunizieren kann. Weitere Informationen finden Sie unter [Konfigurieren der MQTT-Kommunikation mit Docker-Containern](#docker-app-connector-mqtt-communication). + Die Lambda-Funktionen von Greengrass können eine gemeinsam genutzte Datei aktualisieren, um Informationen an Docker-Container weiterzuleiten. Sie können die Compose-Datei für ein Bind-Mount des freigegebenen Dateipfads für einen Docker-Container verwenden. ### Konfigurieren der MQTT-Kommunikation mit Docker-Containern Sie können einen Docker-Container als Client-Gerät konfigurieren und ihn einer Greengrass-Gruppe hinzufügen. Anschließend können Sie Abonnements erstellen, die die MQTT-Kommunikation zwischen dem Docker-Container und Greengrass-Komponenten oder AWS IoT ermöglichen. Im folgenden Verfahren erstellen Sie ein Abonnement, mit dem das Docker-Containergerät Schattenaktualisierungsmeldungen vom lokalen Schattenservice empfangen kann. Sie können diesem Muster folgen, um andere Abonnements zu erstellen. **Anmerkung** Bei diesem Verfahren wird davon ausgegangen, dass Sie bereits eine Greengrass-Gruppe und einen Greengrass-Kern (v1.10 oder höher) erstellt haben. Informationen zum Erstellen einer Greengrass-Gruppe und eines Greengrass-Kerns finden Sie unter[Erste Schritte mit AWS IoT Greengrass](gg-gs.md). **Um einen Docker-Container als Client-Gerät zu konfigurieren und ihn einer Greengrass-Gruppe hinzuzufügen** 1. Erstellen Sie einen Ordner auf dem Core-Gerät, um die Zertifikate und Schlüssel zu speichern, die zur Authentifizierung des Greengrass-Geräts verwendet werden. Der Dateipfad muss auf dem Docker-Container gemountet werden, den Sie starten möchten. Das folgende Snippet zeigt, wie Sie einen Dateipfad in Ihrer Compose-Datei mounten. Stellt in diesem Beispiel den Ordner *path-to-device-certs* dar, den Sie in diesem Schritt erstellt haben. ``` version: '3.3' services: myService: image: user-name/repo:image-tag volumes: - /path-to-device-certs/:/path-accessible-in-container ``` 1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus. 1. Wählen Sie die Zielgruppe aus. 1. Wählen Sie auf der Gruppenkonfigurationsseite die Option **Client-Geräte** und dann **Associate** aus. 1. Wählen **Sie im Modal Ein Client-Gerät mit dieser Gruppe verknüpfen** die Option **Neues Objekt erstellen AWS IoT aus**. Die Seite „**Dinge erstellen**“ wird auf einer neuen Registerkarte geöffnet. 1. Wählen Sie auf der Seite „**Dinge erstellen**“ die Option „**Einzelnes Ding erstellen**“ und dann „**Weiter**“ aus. 1. Geben Sie auf der Seite „**Eigenschaften des Objekts angeben**“ einen Namen für das Gerät ein und wählen Sie dann **Weiter** aus. 1. Wählen Sie auf der Seite **Gerätezertifikat konfigurieren** die Option **Weiter** aus. 1. Führen Sie auf der Seite **Richtlinien an Zertifikat anhängen** einen der folgenden Schritte aus: + Wählen Sie eine bestehende Richtlinie aus, die Berechtigungen gewährt, die Client-Geräte benötigen, und wählen Sie dann **Ding erstellen** aus. Es öffnet sich ein Fenster, in dem Sie die Zertifikate und Schlüssel herunterladen können, die das Gerät für die Verbindung mit dem Core AWS Cloud und dem Core verwendet. + Erstellen Sie eine neue Richtlinie, die Client-Geräteberechtigungen gewährt, und fügen Sie sie an. Gehen Sie wie folgt vor: 1. Wählen Sie **Richtlinie erstellen** aus. Die Seite **Create policy (Richtlinie erstellen)** wird in einer neuen Registerkarte geöffnet. 1. Führen Sie auf der Seite **Create policy (Richtlinie erstellen)** die folgenden Schritte aus: 1. Geben Sie als **Richtlinienname** einen Namen ein, der die Richtlinie beschreibt, z. **GreengrassV1ClientDevicePolicy** B. 1. Wählen Sie auf der Registerkarte **Richtlinienerklärungen** unter **Richtliniendokument die** Option **JSON** aus. 1. Geben Sie das folgende Richtliniendokument ein. Diese Richtlinie ermöglicht es dem Client-Gerät, Greengrass-Kerne zu erkennen und zu allen MQTT-Themen zu kommunizieren. Informationen darüber, wie Sie den Zugriff dieser Richtlinie einschränken können, finden Sie unter. [Geräteauthentifizierung und Autorisierung für AWS IoT Greengrass](device-auth.md) ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iot:Publish", "iot:Subscribe", "iot:Connect", "iot:Receive" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "greengrass:*" ], "Resource": [ "*" ] } ] } ``` ------ 1. Wählen Sie **Create** (Erstellen) aus, um die Richtlinie zu erstellen. 1. Kehren Sie zur Browser-Registerkarte zurück, auf der die Seite **Richtlinien an Zertifikat anhängen** geöffnet ist. Gehen Sie wie folgt vor: 1. Wählen Sie in der Liste **Richtlinien** die Richtlinie aus, die Sie erstellt haben, z. **GreengrassV1ClientDevicePolicy**B. Wenn Sie die Richtlinie nicht sehen, klicken Sie auf die Schaltfläche „Aktualisieren“. 1. Wählen Sie **Objekt erstellen** aus. Es öffnet sich ein Fenster, in dem Sie die Zertifikate und Schlüssel herunterladen können, die das Gerät für die Verbindung mit dem Core AWS Cloud und dem Core verwendet. 1. **Laden Sie im Modal Zertifikate und Schlüssel** herunterladen die Zertifikate des Geräts herunter. **Wichtig** Laden Sie die Sicherheitsressourcen herunter, bevor Sie „**Fertig**“ wählen. Gehen Sie wie folgt vor: 1. Wählen Sie **unter Gerätezertifikat** die Option **Herunterladen** aus, um das Gerätezertifikat herunterzuladen. 1. Wählen Sie unter **Datei mit öffentlichem Schlüssel** die Option **Herunterladen** aus, um den öffentlichen Schlüssel für das Zertifikat herunterzuladen. 1. Wählen Sie unter **Datei mit privatem Schlüssel** die Option **Herunterladen** aus, um die Datei mit dem privaten Schlüssel für das Zertifikat herunterzuladen. 1. Lesen Sie die [Serverauthentifizierung](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) im *AWS IoT Entwicklerhandbuch* und wählen Sie das entsprechende Root-CA-Zertifikat aus. Wir empfehlen die Verwendung von Amazon Trust Services (ATS) -Endpunkten und ATS-Root-CA-Zertifikaten. Wählen Sie unter **Root-CA-Zertifikate** die Option **Herunterladen** für ein Root-CA-Zertifikat aus. 1. Wählen Sie **Fertig** aus. Notieren Sie sich die Zertifikat-ID, die in den Dateinamen für das Gerätezertifikat und die Schlüssel häufig vorkommt. Sie benötigen sie später. 1. Kopieren Sie die Zertifikate und Schlüssel in den Ordner, den Sie in Schritt 1 erstellt haben. Erstellen Sie als Nächstes ein Abonnement in der Gruppe. In diesem Beispiel können Sie ein Abonnement erstellen, damit das Docker-Containergerät MQTT-Nachrichten vom lokalen Schattenservice empfangen kann. **Anmerkung** Die maximale Größe eines Schattendokuments beträgt 8 KB. Weitere Informationen finden Sie unter [AWS IoT -Kontingente](https://docs.aws.amazon.com/iot/latest/developerguide/limits-iot.html) im *AWS IoT -Entwicklerhandbuch*. **So erstellen Sie ein Abonnement, mit dem das Docker-Containergerät MQTT-Nachrichten vom lokalen Schattenservice empfangen kann** 1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Abonnements** und dann **Abonnement hinzufügen** aus. 1. Konfigurieren Sie auf der Seite **Select your source and target** die Quelle und das Ziel wie folgt: 1. Wählen Sie für **Eine Quelle auswählen** die Option **Services** und danach **Local Shadow Service (Service lokaler Schatten)** aus. 1. Wählen Sie für **Ziel auswählen** die Option **Geräte** und dann Ihr Gerät aus. 1. Wählen Sie **Weiter** aus. 1. Wählen Sie auf der Seite **Ihre Daten mit einem Thema filtern** für **Themenfilter** die Option **\$1aws/things/*MyDockerDevice*/shadow/update/accepted** und dann **Weiter** aus. *MyDockerDevice*Ersetzen Sie es durch den Namen des Geräts, das Sie zuvor erstellt haben. 1. Wählen Sie **Finish** (Abschließen). Fügen Sie den folgenden Codeausschnitt in das Docker-Abbild ein, das Sie in der Compose-Datei referenzieren. Das ist der Greengrass-Gerätecode. Fügen Sie außerdem Code in Ihrem Docker-Container hinzu, der das Greengrass-Gerät innerhalb des Containers startet. Es kann als separater Prozess im Abbild oder in einem separaten Thread ausgeführt werden. ``` import os import sys import time import uuid from AWSIoTPythonSDK.core.greengrass.discovery.providers import DiscoveryInfoProvider from AWSIoTPythonSDK.exception.AWSIoTExceptions import DiscoveryInvalidRequestException from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient # Replace thingName with the name you registered for the Docker device. thingName = "MyDockerDevice" clientId = thingName # Replace host with the IoT endpoint for your &AWS-account;. host = "myPrefix.iot.region.amazonaws.com" # Replace topic with the topic where the Docker container subscribes. topic = "$aws/things/MyDockerDevice/shadow/update/accepted" # Replace these paths based on the download location of the certificates for the Docker container. rootCAPath = "/path-accessible-in-container/AmazonRootCA1.pem" certificatePath = "/path-accessible-in-container/certId-certificate.pem.crt" privateKeyPath = "/path-accessible-in-container/certId-private.pem.key" # Discover Greengrass cores. discoveryInfoProvider = DiscoveryInfoProvider() discoveryInfoProvider.configureEndpoint(host) discoveryInfoProvider.configureCredentials(rootCAPath, certificatePath, privateKeyPath) discoveryInfoProvider.configureTimeout(10) # 10 seconds. GROUP_CA_PATH = "./groupCA/" MQTT_QOS = 1 discovered = False groupCA = None coreInfo = None try: # Get discovery info from AWS IoT. discoveryInfo = discoveryInfoProvider.discover(thingName) caList = discoveryInfo.getAllCas() coreList = discoveryInfo.getAllCores() # Use first discovery result. groupId, ca = caList[0] coreInfo = coreList[0] # Save the group CA to a local file. groupCA = GROUP_CA_PATH + groupId + "_CA_" + str(uuid.uuid4()) + ".crt" if not os.path.exists(GROUP_CA_PATH): os.makedirs(GROUP_CA_PATH) groupCAFile = open(groupCA, "w") groupCAFile.write(ca) groupCAFile.close() discovered = True except DiscoveryInvalidRequestException as e: print("Invalid discovery request detected!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") except BaseException as e: print("Error in discovery!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) print("Stopping...") myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId) myAWSIoTMQTTClient.configureCredentials(groupCA, privateKeyPath, certificatePath) # Try to connect to the Greengrass core. connected = False for connectivityInfo in coreInfo.connectivityInfoList: currentHost = connectivityInfo.host currentPort = connectivityInfo.port myAWSIoTMQTTClient.configureEndpoint(currentHost, currentPort) try: myAWSIoTMQTTClient.connect() connected = True except BaseException as e: print("Error in connect!") print("Type: %s" % str(type(e))) print("Error message: %s" % str(e)) if connected: break if not connected: print("Cannot connect to core %s. Exiting..." % coreInfo.coreThingArn) sys.exit(-2) # Handle the MQTT message received from GGShadowService. def customCallback(client, userdata, message): print("Received an MQTT message") print(message) # Subscribe to the MQTT topic. myAWSIoTMQTTClient.subscribe(topic, MQTT_QOS, customCallback) # Keep the process alive to listen for messages. while True: time.sleep(1) ``` ## Sicherheitshinweise Wenn Sie den Greengrass Docker Application Deployment Connector verwenden, sollten Sie die folgenden Sicherheitsaspekte beachten. **Lokale Speicherung der Docker Compose-Datei** Der Konnektor speichert eine Kopie der Compose-Datei in dem für den `DockerComposeFileDestinationPath`-Parameter angegebenen Verzeichnis. Es liegt in Ihrer Verantwortung, dieses Verzeichnis zu sichern. Sie sollten Dateisystemberechtigungen verwenden, um den Zugriff auf das Verzeichnis zu beschränken. **Lokale Speicherung der Docker-Anmeldeinformationen** Wenn Ihre Docker-Abbilder in privaten Repositorys gespeichert sind, speichert der Konnektor Ihre Docker-Anmeldeinformationen in dem für den `DockerComposeFileDestinationPath`-Parameter angegebenen Verzeichnis. Es liegt in Ihrer Verantwortung, diese Anmeldeinformationen zu sichern. Beispielsweise sollten Sie [credential-helper](https://docs.docker.com/engine/reference/commandline/login/#credentials-store) auf dem Core-Gerät verwenden, wenn Sie Docker Engine installieren. **Installieren von Docker Engine von einer vertrauenswürdigen Quelle** Es liegt in Ihrer Verantwortung, Docker Engine von einer vertrauenswürdigen Quelle zu installieren. Dieser Konnektor verwendet den Docker-Daemon auf dem Core-Gerät, um auf Ihre Docker-Komponenten zuzugreifen und Docker-Container zu verwalten. **Umfang der Greengrass-Gruppenrollenberechtigungen** Berechtigungen, die Sie in der Greengrass-Gruppenrolle hinzufügen, können von allen Lambda-Funktionen und -Konnektoren in der Greengrass-Gruppe übernommen werden. Dieser Konnektor erfordert Zugriff auf Ihre Docker Compose-Datei, die in einem S3-Bucket gespeichert ist. Außerdem ist Zugriff auf Ihr Amazon ECR-Autorisierungstoken erforderlich, wenn Ihre Docker-Images in einem privaten Repository in Amazon ECR gespeichert sind. ## Lizenzen Der Greengrass Docker Application Deployment Connector umfasst die folgende Software/Lizenzierung von Drittanbietern: + [AWS SDK für Python (Boto3)](https://pypi.org/project/boto3/)/Apache-Lizenz 2.0 + [botocore](https://pypi.org/project/botocore/)/Apache-Lizenz 2.0 + [dateutil](https://pypi.org/project/python-dateutil/1.4/)/PSF-Lizenz + [docutils](https://pypi.org/project/docutils/)/BSD-Lizenz, GNU General Public License (GPL), Python Software Foundation License, Public Domain + [jmespath](https://pypi.org/project/jmespath/)/MIT-Lizenz + [s3transfer](https://pypi.org/project/s3transfer/)/Apache-Lizenz 2.0 + [urllib3](https://pypi.org/project/urllib3/)/MIT-Lizenz Dieser Connector ist im Rahmen der [Greengrass Core Software-Lizenzvereinbarung](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf) veröffentlicht. ## Änderungsprotokoll In der folgenden Tabelle werden die Änderungen in den einzelnen Versionen des Connectors beschrieben. | Version | Änderungen | | --- | --- | | 7 | Es wurde hinzugefügt`DockerOfflineMode`, um eine vorhandene Docker Compose-Datei zu verwenden, wenn sie offline AWS IoT Greengrass gestartet wird. Wiederholungsversuche für den `docker login` Befehl wurden implementiert. Support für 32-Bit UIDs. | | 6 | Es wurde hinzugefügt`StopContainersOnNewDeployment`, um die Container-Bereinigung zu überschreiben, wenn eine neue Bereitstellung erfolgt oder GGC beendet wird. Sicherere Mechanismen zum Herunterfahren und Starten. Fehlerbehebung bei der YAML-Validierung. | | 5 | Bilder werden vor der Ausführung `docker-compose down` abgerufen. | | 4 | pull-before-upVerhalten zum Aktualisieren von Docker-Images hinzugefügt. | | 3 | Es wurde ein Problem beim Suchen von Umgebungsvariablen behoben. | | 2 | Der Parameter `ForceDeploy` wurde hinzugefügt. | | 1 | Erstversion. | Eine Greengrass-Gruppe kann jeweils nur eine Version des Connectors enthalten. Weitere Informationen zum Aktualisieren einer Konnektorversion finden Sie unter [Aktualisieren von Konnektorversionen](connectors.md#upgrade-connector-versions). ## Weitere Informationen finden Sie auch unter + [Integrieren von Services und Protokollen mit Greengrass-Konnektoren](connectors.md) + [Erste Schritte mit Greengrass-Konnektoren (Konsole)](connectors-console.md) + [Erste Schritte mit Greengrass-Konnektoren (CLI)](connectors-cli.md)