Führen Sie einen Docker-Container aus - AWS IoT Greengrass

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.

Führen Sie einen Docker-Container aus

Sie können AWS IoT Greengrass Komponenten so konfigurieren, dass sie einen Docker-Container aus Images ausführen, die an den folgenden Speicherorten gespeichert sind:

  • Öffentliche und private Image-Repositorys in Amazon Elastic Container Registry (Amazon ECR)

  • Öffentliches Docker Hub-Repository

  • Vertrauenswürdiges öffentliches Docker-Register

  • S3-Bucket

Fügen Sie in Ihrer benutzerdefinierten Komponente den Docker-Image-URI als Artefakt ein, um das Image abzurufen und auf dem Kerngerät auszuführen. Für Amazon ECR- und Docker Hub-Images können Sie die Docker Application Manager-Komponente verwenden, um die Images herunterzuladen und Anmeldeinformationen für private Amazon ECR-Repositorys zu verwalten.

Voraussetzungen

Um einen Docker-Container in einer Komponente auszuführen, benötigen Sie Folgendes:

  • Ein Greengrass-Core-Gerät. Falls Sie noch keines haben, beachten Sie die Informationen unter Tutorial: Erste Schritte mit AWS IoT Greengrass V2.

  • Docker Engine 1.9.1 oder höher ist auf dem Greengrass-Core-Gerät installiert. Version 20.10 ist die neueste Version, für die verifiziert wurde, dass sie mit der Core-Software funktioniert. AWS IoT Greengrass Sie müssen Docker direkt auf dem Kerngerät installieren, bevor Sie Komponenten bereitstellen, auf denen Docker-Container ausgeführt werden.

    Tipp

    Sie können das Kerngerät auch so konfigurieren, dass die Docker Engine bei der Installation der Komponente installiert wird. Das folgende Installationsskript installiert beispielsweise die Docker Engine, bevor das Docker-Image geladen wird. Dieses Installationsskript funktioniert auf Debian-basierten Linux-Distributionen wie Ubuntu. Wenn Sie die Komponente für die Installation von Docker Engine mit diesem Befehl konfigurieren, müssen Sie möglicherweise true im Lifecycle-Skript auf einstellen, RequiresPrivilege um die Installation und die Befehle auszuführen. docker Weitere Informationen finden Sie unter AWS IoT Greengrass Referenz zum Komponenten-Rezept.

    apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
  • Der Systembenutzer, der eine Docker-Container-Komponente ausführt, muss über Root- oder Administratorrechte verfügen, oder Sie müssen Docker so konfigurieren, dass es als Benutzer ohne Root- oder Administratorrechte ausgeführt wird.

    • Auf Linux-Geräten können Sie der Gruppe einen Benutzer hinzufügen, um Befehle ohne Befehle docker aufzurufen. docker sudo

    • Auf Windows-Geräten können Sie der docker-users Gruppe einen Benutzer hinzufügen, um docker Befehle ohne Administratorrechte aufzurufen.

    Linux or Unix

    Führen Sie den folgenden Befehl ausggc_user, um der docker Gruppe einen Nicht-Root-Benutzer, den Sie zum Ausführen von Docker-Container-Komponenten verwenden, hinzuzufügen.

    sudo usermod -aG docker ggc_user

    Weitere Informationen finden Sie unter Docker als Nicht-Root-Benutzer verwalten.

    Windows Command Prompt (CMD)

    Um der docker-users Gruppe den Benutzerggc_user, den Sie zum Ausführen von Docker-Container-Komponenten verwenden, hinzuzufügen, führen Sie den folgenden Befehl als Administrator aus.

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Um der docker-users Gruppe den Benutzerggc_user, den Sie zum Ausführen von Docker-Container-Komponenten verwenden, hinzuzufügen, führen Sie den folgenden Befehl als Administrator aus.

    Add-LocalGroupMember -Group docker-users -Member ggc_user
  • Dateien, auf die die Docker-Container-Komponente zugreift, die als Volume im Docker-Container gemountet ist.

  • Wenn Sie die AWS IoT Greengrass Core-Software für die Verwendung eines Netzwerk-Proxys konfigurieren, müssen Sie Docker für die Verwendung desselben Proxyservers konfigurieren.

Zusätzlich zu diesen Anforderungen müssen Sie auch die folgenden Anforderungen erfüllen, wenn sie für Ihre Umgebung gelten:

  • Um Docker Compose zum Erstellen und Starten Ihrer Docker-Container zu verwenden, installieren Sie Docker Compose auf Ihrem Greengrass-Core-Gerät und laden Sie Ihre Docker Compose-Datei in einen S3-Bucket hoch. Sie müssen Ihre Compose-Datei in einem S3-Bucket im selben und wie AWS-Konto die Komponente speichern. AWS-Region Ein Beispiel, das den docker-compose up Befehl in einer benutzerdefinierten Komponente verwendet, finden Sie unterFühren Sie einen Docker-Container von einem öffentlichen Image in Amazon ECR oder Docker Hub aus.

  • Wenn Sie AWS IoT Greengrass hinter einem Netzwerk-Proxy laufen, konfigurieren Sie den Docker-Daemon für die Verwendung eines Proxyservers.

  • Wenn Ihre Docker-Images in Amazon ECR oder Docker Hub gespeichert sind, fügen Sie die Komponente Docker Component Manager als Abhängigkeit in Ihre Docker-Container-Komponente ein. Sie müssen den Docker-Daemon auf dem Kerngerät starten, bevor Sie Ihre Komponente bereitstellen.

    Fügen Sie außerdem die Image-URIs als Komponentenartefakte hinzu. Bild-URIs müssen das Format docker:registry/image[:tag|@digest] haben, das in den folgenden Beispielen gezeigt wird:

    • Privates Amazon ECR-Bild: docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]

    • Öffentliches Amazon ECR-Bild: docker:public.ecr.aws/repository/image[:tag|@digest]

    • Öffentliches Docker Hub-Bild: docker:name[:tag|@digest]

    Weitere Informationen zum Ausführen von Docker-Containern aus Images, die in öffentlichen Repositorys gespeichert sind, finden Sie unter. Führen Sie einen Docker-Container von einem öffentlichen Image in Amazon ECR oder Docker Hub aus

  • Wenn Ihre Docker-Images in einem privaten Amazon ECR-Repository gespeichert sind, müssen Sie die Token-Exchange-Servicekomponente als Abhängigkeit in die Docker-Container-Komponente aufnehmen. Außerdem muss die Greengrass-Geräterolle die ecr:GetDownloadUrlForLayer Aktionen ecr:GetAuthorizationTokenecr:BatchGetImage, und zulassen, wie in der folgenden IAM-Beispielrichtlinie gezeigt.

    { "Version": "2012-10-17", "Statement": [ { "Action": [ "ecr:GetAuthorizationToken", "ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer" ], "Resource": [ "*" ], "Effect": "Allow" } ] }

    Informationen zum Ausführen von Docker-Containern aus Images, die in einem privaten Amazon ECR-Repository gespeichert sind, finden Sie unter. Führen Sie einen Docker-Container von einem privaten Image in Amazon ECR aus

  • Um Docker-Images zu verwenden, die in einem privaten Amazon ECR-Repository gespeichert sind, muss sich das private Repository auf demselben Gerät befinden AWS-Region wie das Kerngerät.

  • Wenn Ihre Docker-Images oder Compose-Dateien in einem S3-Bucket gespeichert sind, muss die Greengrass-Geräterolle die s3:GetObject Berechtigung gewähren, Kerngeräten das Herunterladen der Images als Komponentenartefakte zu gestatten, wie in der folgenden IAM-Beispielrichtlinie gezeigt.

    { "Version": "2012-10-17", "Statement": [ { "Action": [ "s3:GetObject" ], "Resource": [ "*" ], "Effect": "Allow" } ] }

    Informationen zum Ausführen von Docker-Containern aus in Amazon S3 gespeicherten Bildern finden Sie unterFühren Sie einen Docker-Container von einem Image in Amazon S3 aus.

  • Um Interprozesskommunikation (IPC), AWS Anmeldeinformationen oder Stream Manager in Ihrer Docker-Container-Komponente zu verwenden, müssen Sie bei der Ausführung des Docker-Containers zusätzliche Optionen angeben. Weitere Informationen finden Sie hier:

Führen Sie einen Docker-Container von einem öffentlichen Image in Amazon ECR oder Docker Hub aus

In diesem Abschnitt wird beschrieben, wie Sie eine benutzerdefinierte Komponente erstellen können, die Docker Compose verwendet, um einen Docker-Container aus Docker-Images auszuführen, die in Amazon ECR und Docker Hub gespeichert sind.

Um einen Docker-Container mit Docker Compose auszuführen
  1. Erstellen Sie eine Docker Compose-Datei und laden Sie sie in einen Amazon S3 S3-Bucket hoch. Stellen Sie sicher, dass die Greengrass-Geräterolle die s3:GetObject Erlaubnis erteilt, dem Gerät den Zugriff auf die Compose-Datei zu ermöglichen. Die im folgenden Beispiel gezeigte Compose-Beispieldatei enthält das Amazon CloudWatch Agent-Image von Amazon ECR und das MySQL-Image von Docker Hub.

    version: "3" services: cloudwatchagent: image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest" mysql: image: "mysql:8.0"
  2. Erstellen Sie eine benutzerdefinierte Komponente auf Ihrem AWS IoT Greengrass Kerngerät. Das im folgenden Beispiel gezeigte Beispielrezept hat die folgenden Eigenschaften:

    • Die Docker-Anwendungsmanager-Komponente als Abhängigkeit. Diese Komponente ermöglicht AWS IoT Greengrass das Herunterladen von Bildern aus öffentlichen Amazon ECR- und Docker Hub-Repositorys.

    • Ein Komponentenartefakt, das ein Docker-Image in einem öffentlichen Amazon ECR-Repository spezifiziert.

    • Ein Komponentenartefakt, das ein Docker-Image in einem öffentlichen Docker Hub-Repository spezifiziert.

    • Ein Komponentenartefakt, das die Docker Compose-Datei spezifiziert, die Container für die Docker-Images enthält, die Sie ausführen möchten.

    • Ein Lifecycle-Run-Skript, das Docker-Compose verwendet, um einen Container aus den angegebenen Images zu erstellen und zu starten.

    JSON
    { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.MyDockerComposeComponent", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.", "ComponentPublisher": "Amazon", "ComponentDependencies": { "aws.greengrass.DockerApplicationManager": { "VersionRequirement": "~2.0.0" } }, "Manifests": [ { "Platform": { "os": "all" }, "Lifecycle": { "run": "docker-compose -f {artifacts:path}/docker-compose.yaml up" }, "Artifacts": [ { "URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest" }, { "URI": "docker:mysql:8.0" }, { "URI": "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml" } ] } ] }
    YAML
    --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.MyDockerComposeComponent ComponentVersion: '1.0.0' ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.' ComponentPublisher: Amazon ComponentDependencies: aws.greengrass.DockerApplicationManager: VersionRequirement: ~2.0.0 Manifests: - Platform: os: all Lifecycle: run: docker-compose -f {artifacts:path}/docker-compose.yaml up Artifacts: - URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest" - URI: "docker:mysql:8.0" - URI: "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
    Anmerkung

    Um Interprozesskommunikation (IPC), AWS Anmeldeinformationen oder Stream Manager in Ihrer Docker-Container-Komponente zu verwenden, müssen Sie bei der Ausführung des Docker-Containers zusätzliche Optionen angeben. Weitere Informationen finden Sie hier:

  3. Testen Sie die Komponente, um sicherzustellen, dass sie wie erwartet funktioniert.

    Wichtig

    Sie müssen den Docker-Daemon installieren und starten, bevor Sie die Komponente bereitstellen.

    Nachdem Sie die Komponente lokal bereitgestellt haben, können Sie den Befehl docker container ls ausführen, um zu überprüfen, ob Ihr Container ausgeführt wird.

    docker container ls
  4. Wenn die Komponente bereit ist, laden Sie die Komponente hoch, AWS IoT Greengrass um sie auf anderen Kerngeräten bereitzustellen. Weitere Informationen finden Sie unter Veröffentlichen Sie Komponenten zur Bereitstellung auf Ihren Kerngeräten.

Führen Sie einen Docker-Container von einem privaten Image in Amazon ECR aus

In diesem Abschnitt wird beschrieben, wie Sie eine benutzerdefinierte Komponente erstellen können, die einen Docker-Container aus einem Docker-Image ausführt, das in einem privaten Repository in Amazon ECR gespeichert ist.

Um einen Docker-Container auszuführen
  1. Erstellen Sie eine benutzerdefinierte Komponente auf Ihrem AWS IoT Greengrass Kerngerät. Verwenden Sie das folgende Beispielrezept mit den folgenden Eigenschaften:

    • Die Docker-Anwendungsmanager-Komponente als Abhängigkeit. Diese Komponente ermöglicht die Verwaltung von Anmeldeinformationen AWS IoT Greengrass zum Herunterladen von Bildern aus privaten Repositorys.

    • Die Token-Exchange-Dienstkomponente als Abhängigkeit. Diese Komponente ermöglicht AWS IoT Greengrass das Abrufen von AWS Anmeldeinformationen für die Interaktion mit Amazon ECR.

    • Ein Komponentenartefakt, das ein Docker-Image in einem privaten Amazon ECR-Repository spezifiziert.

    • Ein Lifecycle-Run-Skript, das Docker Run verwendet, um einen Container aus dem Image zu erstellen und zu starten.

    JSON
    { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.MyPrivateDockerComponent", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.", "ComponentPublisher": "Amazon", "ComponentDependencies": { "aws.greengrass.DockerApplicationManager": { "VersionRequirement": "~2.0.0" }, "aws.greengrass.TokenExchangeService": { "VersionRequirement": "~2.0.0" } }, "Manifests": [ { "Platform": { "os": "all" }, "Lifecycle": { "run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]" }, "Artifacts": [ { "URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]" } ] } ] }
    YAML
    --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.MyPrivateDockerComponent ComponentVersion: '1.0.0' ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.' ComponentPublisher: Amazon ComponentDependencies: aws.greengrass.DockerApplicationManager: VersionRequirement: ~2.0.0 aws.greengrass.TokenExchangeService: VersionRequirement: ~2.0.0 Manifests: - Platform: os: all Lifecycle: run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest] Artifacts: - URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
    Anmerkung

    Um Interprozesskommunikation (IPC), AWS Anmeldeinformationen oder Stream Manager in Ihrer Docker-Container-Komponente zu verwenden, müssen Sie bei der Ausführung des Docker-Containers zusätzliche Optionen angeben. Weitere Informationen finden Sie hier:

  2. Testen Sie die Komponente, um sicherzustellen, dass sie wie erwartet funktioniert.

    Wichtig

    Sie müssen den Docker-Daemon installieren und starten, bevor Sie die Komponente bereitstellen.

    Nachdem Sie die Komponente lokal bereitgestellt haben, können Sie den Befehl docker container ls ausführen, um zu überprüfen, ob Ihr Container ausgeführt wird.

    docker container ls
  3. Laden Sie die Komponente hoch, AWS IoT Greengrass um sie auf anderen Kerngeräten bereitzustellen. Weitere Informationen finden Sie unter Veröffentlichen Sie Komponenten zur Bereitstellung auf Ihren Kerngeräten.

Führen Sie einen Docker-Container von einem Image in Amazon S3 aus

In diesem Abschnitt wird beschrieben, wie Sie einen Docker-Container in einer Komponente von einem Docker-Image aus ausführen können, das in Amazon S3 gespeichert ist.

So führen Sie einen Docker-Container in einer Komponente aus einem Image in Amazon S3 aus
  1. Führen Sie den Befehl docker save aus, um ein Backup eines Docker-Containers zu erstellen. Sie stellen dieses Backup als Komponentenartefakt bereit, auf dem der Container ausgeführt werden kann. AWS IoT Greengrass Ersetzen Sie hello-world durch den Namen des Images und hello-world.tar durch den Namen der zu erstellenden Archivdatei.

    docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
  2. Erstellen Sie eine benutzerdefinierte Komponente auf Ihrem AWS IoT Greengrass Core-Gerät. Verwenden Sie das folgende Beispielrezept mit den folgenden Eigenschaften:

    • Ein Lifecycle-Installationsskript, das Docker Load verwendet, um ein Docker-Image aus einem Archiv zu laden.

    • Ein Lifecycle-Run-Skript, das Docker Run verwendet, um einen Container aus dem Image zu erstellen und zu starten. Die --rm Option bereinigt den Container, wenn er beendet wird.

    JSON
    { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.MyS3DockerComponent", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.", "ComponentPublisher": "Amazon", "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": { "Script": "docker load -i {artifacts:path}/hello-world.tar" }, "run": { "Script": "docker run --rm hello-world" } } } ] }
    YAML
    --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.MyS3DockerComponent ComponentVersion: '1.0.0' ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.' ComponentPublisher: Amazon Manifests: - Platform: os: linux Lifecycle: install: Script: docker load -i {artifacts:path}/hello-world.tar run: Script: docker run --rm hello-world
    Anmerkung

    Um Interprozesskommunikation (IPC), AWS Anmeldeinformationen oder Stream Manager in Ihrer Docker-Container-Komponente zu verwenden, müssen Sie bei der Ausführung des Docker-Containers zusätzliche Optionen angeben. Weitere Informationen finden Sie hier:

  3. Testen Sie die Komponente, um sicherzustellen, dass sie wie erwartet funktioniert.

    Nachdem Sie die Komponente lokal bereitgestellt haben, können Sie den Befehl docker container ls ausführen, um zu überprüfen, ob Ihr Container ausgeführt wird.

    docker container ls
  4. Wenn die Komponente bereit ist, laden Sie das Docker-Image-Archiv in einen S3-Bucket hoch und fügen Sie dessen URI dem Komponentenrezept hinzu. Anschließend können Sie die Komponente hochladen, AWS IoT Greengrass um sie auf anderen Kerngeräten bereitzustellen. Weitere Informationen finden Sie unter Veröffentlichen Sie Komponenten zur Bereitstellung auf Ihren Kerngeräten.

    Wenn Sie fertig sind, sollte das Komponentenrezept wie im folgenden Beispiel aussehen.

    JSON
    { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.MyS3DockerComponent", "ComponentVersion": "1.0.0", "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.", "ComponentPublisher": "Amazon", "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": { "Script": "docker load -i {artifacts:path}/hello-world.tar" }, "run": { "Script": "docker run --rm hello-world" } }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar" } ] } ] }
    YAML
    --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.MyS3DockerComponent ComponentVersion: '1.0.0' ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.' ComponentPublisher: Amazon Manifests: - Platform: os: linux Lifecycle: install: Script: docker load -i {artifacts:path}/hello-world.tar run: Script: docker run --rm hello-world Artifacts: - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

Verwenden Sie die Interprozesskommunikation in Docker-Container-Komponenten

Sie können die Greengrass Interprocess Communication (IPC) -Bibliothek in der verwenden, AWS IoT Device SDK um mit dem Greengrass-Kern, anderen Greengrass-Komponenten und zu kommunizieren. AWS IoT Core Weitere Informationen finden Sie unter Verwenden Sie den AWS IoT Device SDK , um mit dem Greengrass-Kern und anderen Komponenten zu kommunizieren und AWS IoT Core.

Um IPC in einer Docker-Container-Komponente zu verwenden, müssen Sie den Docker-Container mit den folgenden Parametern ausführen:

  • Mounten Sie den IPC-Socket in den Container. Der Greengrass-Kern stellt den IPC-Socket-Dateipfad in der AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT Umgebungsvariablen bereit.

  • Stellen Sie die AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT Umgebungsvariablen SVCUID und auf die Werte ein, die der Greengrass-Kern für Komponenten bereitstellt. Ihre Komponente verwendet diese Umgebungsvariablen, um Verbindungen zum Greengrass-Nucleus zu authentifizieren.

Beispielrezept: Eine MQTT-Nachricht veröffentlichen in AWS IoT Core (Python)

Das folgende Rezept definiert ein Beispiel für eine Docker-Container-Komponente, die eine MQTT-Nachricht veröffentlicht. AWS IoT Core Das Rezept hat die folgenden Eigenschaften:

  • Eine Autorisierungsrichtlinie (accessControl), die es der Komponente ermöglicht, MQTT-Nachrichten zu allen AWS IoT Core Themen zu veröffentlichen. Weitere Informationen finden Sie unter Autorisieren Sie Komponenten zur Ausführung von IPC-Vorgängen und AWS IoT Core MQTT IPC-Autorisierung.

  • Ein Komponentenartefakt, das ein Docker-Image als TAR-Archiv in Amazon S3 spezifiziert.

  • Ein Lifecycle-Installationsskript, das das Docker-Image aus dem TAR-Archiv lädt.

  • Ein Lifecycle-Run-Skript, das einen Docker-Container vom Image aus ausführt. Der Befehl Docker run hat die folgenden Argumente:

    • Das -v Argument mountet den Greengrass-IPC-Socket in den Container.

    • Die ersten beiden -e Argumente legen die erforderlichen Umgebungsvariablen im Docker-Container fest.

    • Die zusätzlichen -e Argumente legen die in diesem Beispiel verwendeten Umgebungsvariablen fest.

    • Das --rm Argument bereinigt den Container, wenn er beendet wird.

JSON
{ "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.python.docker.PublishToIoTCore", "ComponentVersion": "1.0.0", "ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "topic": "test/topic/java", "message": "Hello, World!", "qos": "1", "accessControl": { "aws.greengrass.ipc.mqttproxy": { "com.example.python.docker.PublishToIoTCore:pubsub:1": { "policyDescription": "Allows access to publish to IoT Core on all topics.", "operations": [ "aws.greengrass#PublishToIoTCore" ], "resources": [ "*" ] } } } } }, "Manifests": [ { "Platform": { "os": "all" }, "Lifecycle": { "install": "docker load -i {artifacts:path}/publish-to-iot-core.tar", "run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core" }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar" } ] } ] }
YAML
RecipeFormatVersion: '2020-01-25' ComponentName: com.example.python.docker.PublishToIoTCore ComponentVersion: 1.0.0 ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: topic: 'test/topic/java' message: 'Hello, World!' qos: '1' accessControl: aws.greengrass.ipc.mqttproxy: 'com.example.python.docker.PublishToIoTCore:pubsub:1': policyDescription: Allows access to publish to IoT Core on all topics. operations: - 'aws.greengrass#PublishToIoTCore' resources: - '*' Manifests: - Platform: os: all Lifecycle: install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar' run: | docker run \ -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \ -e SVCUID \ -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \ -e MQTT_TOPIC="{configuration:/topic}" \ -e MQTT_MESSAGE="{configuration:/message}" \ -e MQTT_QOS="{configuration:/qos}" \ --rm publish-to-iot-core Artifacts: - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar

Verwenden Sie AWS Anmeldeinformationen in Docker-Container-Komponenten (Linux)

Sie können die Token-Exchange-Dienstkomponente verwenden, um mit AWS Diensten in Greengrass-Komponenten zu interagieren. Diese Komponente stellt AWS Anmeldeinformationen aus der Token-Austauschrolle des Kerngeräts mithilfe eines lokalen Containerservers bereit. Weitere Informationen finden Sie unter Interagieren mit -AWSServices.

Anmerkung

Das Beispiel in diesem Abschnitt funktioniert nur auf Linux-Core-Geräten.

Um AWS Anmeldeinformationen aus dem Token-Exchange-Dienst in einer Docker-Container-Komponente zu verwenden, müssen Sie den Docker-Container mit den folgenden Parametern ausführen:

  • Stellen Sie mithilfe des Arguments Zugriff auf das Host-Netzwerk bereit. --network=host Diese Option ermöglicht es dem Docker-Container, eine Verbindung zum lokalen Token-Austauschdienst herzustellen, um AWS Anmeldeinformationen abzurufen. Dieses Argument funktioniert nur auf Docker für Linux.

    Warnung

    Diese Option gewährt dem Container Zugriff auf alle lokalen Netzwerkschnittstellen auf dem Host, sodass diese Option weniger sicher ist, als wenn Sie Docker-Container ohne diesen Zugriff auf das Host-Netzwerk ausführen. Berücksichtigen Sie dies, wenn Sie Docker-Container-Komponenten entwickeln und ausführen, die diese Option verwenden. Weitere Informationen finden Sie unter Network: host in der Docker-Dokumentation.

  • Stellen Sie die AWS_CONTAINER_AUTHORIZATION_TOKEN Umgebungsvariablen AWS_CONTAINER_CREDENTIALS_FULL_URI und auf die Werte ein, die der Greengrass-Kern für Komponenten bereitstellt. AWS SDKs verwenden diese Umgebungsvariablen, um Anmeldeinformationen abzurufen AWS .

Beispielrezept: S3-Buckets in einer Docker-Container-Komponente auflisten (Python)

Das folgende Rezept definiert ein Beispiel für eine Docker-Container-Komponente, die die S3-Buckets in Ihrem auflistet. AWS-Konto Das Rezept hat die folgenden Eigenschaften:

  • Die Token-Exchange-Dienstkomponente als Abhängigkeit. Diese Abhängigkeit ermöglicht es der Komponente, AWS Anmeldeinformationen für die Interaktion mit anderen AWS Diensten abzurufen.

  • Ein Komponentenartefakt, das ein Docker-Image als Tar-Archiv in Amazon S3 spezifiziert.

  • Ein Lifecycle-Installationsskript, das das Docker-Image aus dem TAR-Archiv lädt.

  • Ein Lifecycle-Run-Skript, das einen Docker-Container vom Image aus ausführt. Der Befehl Docker run hat die folgenden Argumente:

    • Das --network=host Argument gewährt dem Container Zugriff auf das Host-Netzwerk, sodass der Container eine Verbindung zum Token-Austauschdienst herstellen kann.

    • Das -e Argument legt die erforderlichen Umgebungsvariablen im Docker-Container fest.

    • Das --rm Argument bereinigt den Container, wenn er beendet wird.

JSON
{ "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.python.docker.ListS3Buckets", "ComponentVersion": "1.0.0", "ComponentDescription": "Uses the token exchange service to lists your S3 buckets.", "ComponentPublisher": "Amazon", "ComponentDependencies": { "aws.greengrass.TokenExchangeService": { "VersionRequirement": "^2.0.0", "DependencyType": "HARD" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": "docker load -i {artifacts:path}/list-s3-buckets.tar", "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets" }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar" } ] } ] }
YAML
RecipeFormatVersion: '2020-01-25' ComponentName: com.example.python.docker.ListS3Buckets ComponentVersion: 1.0.0 ComponentDescription: Uses the token exchange service to lists your S3 buckets. ComponentPublisher: Amazon ComponentDependencies: aws.greengrass.TokenExchangeService: VersionRequirement: ^2.0.0 DependencyType: HARD Manifests: - Platform: os: linux Lifecycle: install: 'docker load -i {artifacts:path}/list-s3-buckets.tar' run: | docker run \ --network=host \ -e AWS_CONTAINER_AUTHORIZATION_TOKEN \ -e AWS_CONTAINER_CREDENTIALS_FULL_URI \ --rm list-s3-buckets Artifacts: - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar

Verwenden Sie den Stream-Manager in Docker-Container-Komponenten (Linux)

Sie können die Stream-Manager-Komponente verwenden, um Datenströme in Greengrass-Komponenten zu verwalten. Mit dieser Komponente können Sie Datenströme verarbeiten und umfangreiche IoT-Daten an die AWS Cloudübertragen. AWS IoT Greengrass stellt ein Stream-Manager-SDK bereit, das Sie für die Interaktion mit der Stream Manager-Komponente verwenden. Weitere Informationen finden Sie unter Verwalten von Datenströmen auf Greengrass-Core-Geräten.

Anmerkung

Das Beispiel in diesem Abschnitt funktioniert nur auf Linux-Core-Geräten.

Um das Stream Manager SDK in einer Docker-Container-Komponente zu verwenden, müssen Sie den Docker-Container mit den folgenden Parametern ausführen:

  • Stellen Sie mithilfe des Arguments Zugriff auf das Host-Netzwerk bereit. --network=host Diese Option ermöglicht es dem Docker-Container, über eine lokale TLS-Verbindung mit der Stream Manager-Komponente zu interagieren. Dieses Argument funktioniert nur auf Docker für Linux

    Warnung

    Diese Option gewährt dem Container Zugriff auf alle lokalen Netzwerkschnittstellen auf dem Host, sodass diese Option weniger sicher ist, als wenn Sie Docker-Container ohne diesen Zugriff auf das Host-Netzwerk ausführen. Berücksichtigen Sie dies, wenn Sie Docker-Container-Komponenten entwickeln und ausführen, die diese Option verwenden. Weitere Informationen finden Sie unter Network: host in der Docker-Dokumentation.

  • Wenn Sie die Stream-Manager-Komponente so konfigurieren, dass eine Authentifizierung erforderlich ist, was das Standardverhalten ist, setzen Sie die AWS_CONTAINER_CREDENTIALS_FULL_URI Umgebungsvariable auf den Wert, den der Greengrass-Nucleus den Komponenten zur Verfügung stellt. Weitere Informationen finden Sie unter Stream Manager-Konfiguration.

  • Wenn Sie die Stream Manager-Komponente so konfigurieren, dass sie einen nicht standardmäßigen Port verwendet, verwenden Sie Interprocess Communication (IPC), um den Port aus der Stream Manager-Komponentenkonfiguration abzurufen. Sie müssen den Docker-Container mit zusätzlichen Optionen ausführen, um IPC verwenden zu können. Weitere Informationen finden Sie hier:

Beispielrezept: Streamen Sie eine Datei in einen S3-Bucket in einer Docker-Container-Komponente (Python)

Das folgende Rezept definiert ein Beispiel für eine Docker-Container-Komponente, die eine Datei erstellt und sie in einen S3-Bucket streamt. Das Rezept hat die folgenden Eigenschaften:

  • Die Stream-Manager-Komponente als Abhängigkeit. Diese Abhängigkeit ermöglicht es der Komponente, das Stream-Manager-SDK für die Interaktion mit der Stream-Manager-Komponente zu verwenden.

  • Ein Komponentenartefakt, das ein Docker-Image als TAR-Archiv in Amazon S3 spezifiziert.

  • Ein Lifecycle-Installationsskript, das das Docker-Image aus dem TAR-Archiv lädt.

  • Ein Lifecycle-Run-Skript, das einen Docker-Container vom Image aus ausführt. Der Befehl Docker run hat die folgenden Argumente:

    • Das --network=host Argument ermöglicht dem Container den Zugriff auf das Host-Netzwerk, sodass der Container eine Verbindung zur Stream Manager-Komponente herstellen kann.

    • Das erste -e Argument legt die erforderliche AWS_CONTAINER_AUTHORIZATION_TOKEN Umgebungsvariable im Docker-Container fest.

    • Die zusätzlichen -e Argumente legen die in diesem Beispiel verwendeten Umgebungsvariablen fest.

    • Das -v Argument hängt den Arbeitsordner der Komponente im Container ein. In diesem Beispiel wird eine Datei im Arbeitsordner erstellt, um diese Datei mithilfe des Stream-Managers auf Amazon S3 hochzuladen.

    • Das --rm Argument bereinigt den Container, wenn er beendet wird.

JSON
{ "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.python.docker.StreamFileToS3", "ComponentVersion": "1.0.0", "ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.", "ComponentPublisher": "Amazon", "ComponentDependencies": { "aws.greengrass.StreamManager": { "VersionRequirement": "^2.0.0", "DependencyType": "HARD" } }, "ComponentConfiguration": { "DefaultConfiguration": { "bucketName": "" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "install": "docker load -i {artifacts:path}/stream-file-to-s3.tar", "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3" }, "Artifacts": [ { "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar" } ] } ] }
YAML
RecipeFormatVersion: '2020-01-25' ComponentName: com.example.python.docker.StreamFileToS3 ComponentVersion: 1.0.0 ComponentDescription: Creates a text file and uses stream manager to stream the file to S3. ComponentPublisher: Amazon ComponentDependencies: aws.greengrass.StreamManager: VersionRequirement: ^2.0.0 DependencyType: HARD ComponentConfiguration: DefaultConfiguration: bucketName: '' Manifests: - Platform: os: linux Lifecycle: install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar' run: | docker run \ --network=host \ -e AWS_CONTAINER_AUTHORIZATION_TOKEN \ -e BUCKET_NAME="{configuration:/bucketName}" \ -e WORK_PATH="{work:path}" \ -v {work:path}:{work:path} \ --rm stream-file-to-s3 Artifacts: - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar