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.
# Stellen Sie containerisierte Anwendungen bereit, wenn AWS IoT Greengrass V2 sie als Docker-Container ausgeführt werden
*Salih Bakir, Giuseppe Di Bella und Gustav Svalander, Amazon Web Services*
## Zusammenfassung
AWS IoT Greengrass Version 2, wenn es als Docker-Container bereitgestellt wird, unterstützt es nicht nativ das Ausführen von Docker-Anwendungscontainern. Dieses Muster zeigt Ihnen, wie Sie ein benutzerdefiniertes Container-Image erstellen, das auf der neuesten Version basiert und AWS IoT Greengrass V2 die Funktionalität Docker-in-Docker (DinD) aktiviert. Mit DinD können Sie containerisierte Anwendungen in der Umgebung ausführen. AWS IoT Greengrass V2
Sie können dieses Muster als eigenständige Lösung einsetzen oder es in Container-Orchestrierungsplattformen wie Amazon ECS Anywhere integrieren. In beiden Bereitstellungsmodellen behalten Sie den vollen AWS IoT Greengrass V2 Funktionsumfang, einschließlich der AWS IoT SiteWise Edge-Verarbeitungsfunktionen, bei und ermöglichen gleichzeitig skalierbare, containerbasierte Bereitstellungen.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver. AWS-Konto
+ Allgemeine AWS IoT Greengrass Version 2 Voraussetzungen finden Sie in der AWS IoT Greengrass Version 2 Dokumentation unter [Voraussetzungen](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started-prerequisites.html).
+ Docker Engine, installiert und konfiguriert unter Linux, macOS oder Windows.
+ Docker Compose (wenn Sie die Docker Compose-Befehlszeilenschnittstelle (CLI) zum Ausführen von Docker-Images verwenden).
+ Ein Linux-Betriebssystem.
+ Ein Hypervisor mit einem Hostserver, der Virtualisierung unterstützt.
+ Systemanforderungen:
+ 2 GB RAM (mindestens)
+ 5 GB verfügbarer Festplattenspeicher (mindestens)
+ Für AWS IoT SiteWise Edge eine x86\_64-Quad-Core-CPU mit 16 GB RAM und 50 GB verfügbarem Festplattenspeicher. Weitere Informationen AWS IoT SiteWise zur Datenverarbeitung finden Sie in der Dokumentation unter Anforderungen an das [Datenverarbeitungspaket](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-gateway-ggv2.html#w2aac17c19c13b7). AWS IoT SiteWise
**Produktversionen**
+ AWS IoT Greengrass Version 2 Version 2.5.3 oder höher
+ Docker-in-Docker Version 1.0.0 oder höher
+ Docker Compose Version 1.22 oder höher
+ Docker Engine Version 20.10.12 oder höher
**Einschränkungen**
+ Einige AWS-Services sind nicht in allen verfügbar. AWS-Regionen Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie unter [AWS Dienste nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus.
## Architektur
**Zieltechnologie-Stack**
+ **Datenquellen** — IoT-Geräte, Sensoren oder Industrieanlagen, die Daten für die Verarbeitung generieren
+ **AWS IoT Greengrass V2**— Läuft als Docker-Container mit D-in-D Funktionen und wird auf Edge-Infrastrukturen bereitgestellt
+ **Containerisierte Anwendungen — Benutzerdefinierte Anwendungen**, die in der AWS IoT Greengrass V2 Umgebung als verschachtelte Docker-Container ausgeführt werden
+ **(Optional) Amazon ECS Anywhere** — Container-Orchestrierung, die die AWS IoT Greengrass V2 Container-Bereitstellung verwaltet
+ **Andere AWS-Services** — AWS IoT Core AWS IoT SiteWise, und andere AWS-Services für die Datenverarbeitung und -verwaltung
**Zielarchitektur**
Das folgende Diagramm zeigt ein Beispiel für eine Zielbereitstellungsarchitektur, die Amazon ECS Anywhere, ein Container-Management-Tool, verwendet.
Das Diagramm zeigt den folgenden Workflow:
**1: Container-Image-Speicher** — Amazon ECR speichert die AWS IoT Greengrass Container-Images und alle benutzerdefinierten Anwendungscontainer, die für die Edge-Verarbeitung benötigt werden.
**2** und **3: Container-Bereitstellung** — Amazon ECS Anywhere stellt das AWS IoT Greengrass Container-Image von Amazon ECR am Edge-Standort bereit und verwaltet so den Container-Lebenszyklus und den Bereitstellungsprozess.
**4: Bereitstellung von Komponenten** — Der bereitgestellte AWS IoT Greengrass Core stellt seine relevanten Komponenten automatisch auf der Grundlage seiner Konfiguration bereit. Zu den Komponenten gehören AWS IoT SiteWise Edge und andere notwendige Edge-Verarbeitungskomponenten innerhalb der containerisierten Umgebung.
**5: Datenaufnahme** — Nach der vollständigen Konfiguration AWS IoT Greengrass beginnt die Erfassung von Telemetrie- und Sensordaten aus verschiedenen IoT-Datenquellen am Edge-Standort.
**6: Datenverarbeitung und Cloud-Integration** — Der containerisierte AWS IoT Greengrass Kern verarbeitet Daten lokal mithilfe der eingesetzten Komponenten (einschließlich AWS IoT SiteWise Edge für industrielle Daten). Anschließend werden die verarbeiteten Daten zur weiteren Analyse und Speicherung an AWS Cloud Dienste gesendet.
## Tools
**AWS-Services**
+ [Amazon ECS Anywhere](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch-type-external.html) unterstützt Sie bei der Bereitstellung, Verwendung und Verwaltung von Amazon ECS-Aufgaben und -Services in Ihrer eigenen Infrastruktur.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) bietet sichere und skalierbare Rechenkapazität in der AWS Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren.
+ [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist.
+ [AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html)ist ein Open-Source-Edge-Runtime- und Cloud-Dienst für das Internet der Dinge (IoT), mit dem Sie IoT-Anwendungen auf Ihren Geräten erstellen, bereitstellen und verwalten können.
+ [AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html)hilft Ihnen dabei, Daten von Industrieanlagen in großem Maßstab zu sammeln, zu modellieren, zu analysieren und zu visualisieren.
**Andere Tools**
+ [Docker](https://www.docker.com/) ist eine Reihe von Platform-as-a-Service (PaaS) -Produkten, die Virtualisierung auf Betriebssystemebene nutzen, um Software in Containern bereitzustellen.
+ [Docker Compose](https://docs.docker.com/compose/) ist ein Tool zum Definieren und Ausführen von Multi-Container-Anwendungen.
+ [Docker Engine](https://docs.docker.com/engine/) ist eine Open-Source-Containerisierungstechnologie zum Erstellen und Containerisieren von Anwendungen.
**Code-Repository**
Der Code für dieses Muster ist im GitHub [AWS IoT Greengrass Docker-in-Dockerv2-Repository](https://github.com/aws-samples/aws-iot-greengrass-docker-in-docker) verfügbar.
## Epen
### Baue das Bild AWS IoT Greengrass V2 Docker-in-Docker
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie und navigieren Sie zum Repository. | Verwenden Sie den folgenden Befehl, um das Repository zu klonen:
`git clone https://github.com/aws-samples/aws-iot-greengrass-docker-in-docker.git`
Verwenden Sie den folgenden Befehl, um zu dem `docker` Verzeichnis zu navigieren:
`cd aws-iot-greengrass-docker-in-docker/docker` | DevOps Ingenieur, AWS DevOps |
| Erstellen Sie das Docker-Image. | Führen Sie den folgenden Befehl aus, um das Docker-Image mit der (neuesten) Standardversion zu erstellen:
`docker build -t x86_64/aws-iot-greengrass:latest .`
Oder führen Sie den folgenden Befehl aus, um das Docker-Image mit einer bestimmten Version zu erstellen:
`docker build --build-arg GREENGRASS_RELEASE_VERSION=2.12.0 -t x86_64/aws-iot-greengrass:2.12.0 .`
Führen Sie den folgenden Befehl aus, um den Build zu überprüfen:
`docker images \| grep aws-iot-greengrass`
| AWS DevOps, DevOps Ingenieur, App-Entwickler |
| (Optional) Push zu Amazon ECR. | 1. Führen Sie den folgenden Befehl aus, um das Repository zu erstellen:
`aws ecr create-repository --repository-name aws-iot-greengrass-dind --region us-east-1`
2. Führen Sie den folgenden Befehl aus, um sich zu authentifizieren:
`aws ecr get-login-password --region us-east-1 \| docker login --username AWS --password-stdin .dkr.ecr.us-east-1.amazonaws.com`
3. Führen Sie die folgenden Befehle aus, um zu taggen und zu pushen:
`docker tag x86_64/aws-iot-greengrass:latest .dkr.ecr.us-east-1.amazonaws.com/aws-iot-greengrass-dind:latest`
`docker push .dkr.ecr.us-east-1.amazonaws.com/aws-iot-greengrass-dind:latest` | App-Entwickler, AWS DevOps, DevOps Ingenieur |
### AWS Anmeldeinformationen konfigurieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Wählen Sie die Authentifizierungsmethode aus. | Wählen Sie eine der folgenden Optionen:+ **Option 1 (empfohlen)**: IAM-Rollen — Wird verwendet, wenn sie auf Amazon EC2, Amazon ECS oder Amazon EKS mit den richtigen IAM-Rollen ausgeführt werden. Keine zusätzliche Konfiguration erforderlich.
+ **Option 2**: Umgebungsvariablen — Zum Testen und Entwickeln.
+ **Option 3**: Datei mit Anmeldeinformationen — Nicht für die Produktion empfohlen.
+ **Option 4**: `env.cfg` Legacy-Datei. | AWS-Administrator |
| Konfigurieren Sie die Authentifizierungsmethode. | Verwenden Sie für die von Ihnen gewählte Authentifizierungsmethode die folgenden Konfigurationsanweisungen:+ **Option 2 (Umgebungsvariablen)** — Vorbereiten `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, und optional`AWS_SESSION_TOKEN`.
+ **Option 3 (Anmeldeinformationsdatei)** — Verzeichnis und Datei mit Anmeldeinformationen erstellen:(a) Führen Sie den folgenden Befehl aus:
`mkdir -p ~/greengrass-v2-credentials`(b) Erstellen Sie die folgende Datei unter`~/greengrass-v2-credentials/credentials`:
`[default]`
`aws_access_key_id=YourAccessKey`
`aws_secret_access_key=YourSecretKey`(c) Sichern Sie die Datei wie folgt:
`chmod 600 ~/greengrass-v2-credentials/credentials`
+ **Option 4 (`env.cfg`****)** — Erstellen Sie die `env.cfg` Datei im `docker` Verzeichnis wie folgt:
`GGC_ROOT_PATH=/greengrass/v2`
`AWS_REGION=us-east-1`
`PROVISION=true`
`THING_NAME=MyGreengrassCore`
`THING_GROUP_NAME=MyGreengrassCoreGroup`
`TES_ROLE_NAME=GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER=ggc_user:ggc_group` | AWS-Administrator |
### Mit Docker Compose ausführen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konfiguration `docker-compose.yml`. | Aktualisieren Sie die `docker-compose.yml` Datei wie folgt mit Umgebungsvariablen:+ Schlüsselvariablen: `PROVISION,` `AWS_REGION``THING_NAME`,`THING_GROUP_NAME`,`TES_ROLE_NAME`, `TES_ROLE_ALIAS_NAME`
+ Wenn Sie Anmeldeinformationen mithilfe von Umgebungsvariablen verwenden möchten, entfernen Sie den Kommentar zu den folgenden Angaben:
`environment:`
` - AWS_ACCESS_KEY_ID=YourKey`
` - AWS_SECRET_ACCESS_KEY=YourSecret`+ Entfernen Sie bei der Datei mit den Anmeldeinformationen Folgendes aus:
`volumes:`
` - ~/greengrass-v2-credentials:/root/.aws/:ro`+ Fügen Sie für die Protokollpersistenz Folgendes hinzu:
`volumes:`
` - ./logs:/greengrass/v2/logs` | DevOps Ingenieur |
| Container starten und verifizieren. | Führen Sie den folgenden Befehl aus, um im Vordergrund zu starten:
`docker-compose up --build`
Oder führen Sie den folgenden Befehl aus, um im Hintergrund zu starten:
`docker-compose up --build -d`
Führen Sie den folgenden Befehl aus, um den Status zu überprüfen:
`docker-compose ps`
Führen Sie den folgenden Befehl aus, um Protokolle zu überwachen:
`docker-compose logs -f` | DevOps Ingenieur |
### Mit Docker CLI ausführen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie den Container mit Docker CLI aus. | + Führen Sie den folgenden Befehl aus, um einen Basislauf ohne Bereitstellung zu initiieren:
`docker run --init --privileged -it --name aws-iot-greengrass x86_64/aws-iot-greengrass:latest`+ Führen Sie den folgenden Befehl aus, um einen Lauf mit Umgebungsvariablen zu initiieren:
`docker run --init --privileged -it --name aws-iot-greengrass -e PROVISION=true -e AWS_REGION=us-east-1 -e AWS_ACCESS_KEY_ID=YourKey -e AWS_SECRET_ACCESS_KEY=YourSecret -e THING_NAME=MyGreengrassCore -e THING_GROUP_NAME=MyGreengrassCoreGroup -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Führen Sie den folgenden Befehl aus, um einen Lauf mit einer Anmeldeinformationsdatei zu initiieren:
`docker run --init --privileged -it --name aws-iot-greengrass -v ~/greengrass-v2-credentials:/root/.aws:ro -e PROVISION=true -e AWS_REGION=us-east-1 -e THING_NAME=MyGreengrassCore -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Führen Sie den folgenden Befehl aus, um einen Lauf mit einer `env.cfg` Datei zu starten:
`docker run --init --privileged -it --name aws-iot-greengrass -v ~/greengrass-v2-credentials:/root/.aws:ro --env-file env.cfg -p 8883:8883 x86_64/aws-iot-greengrass:latest`+ Führen Sie den folgenden Befehl aus, um einen Lauf mit persistenten Protokollen zu initiieren:
`docker run --init --privileged -it --name aws-iot-greengrass -v \$(pwd)/logs:/greengrass/v2/logs x86_64/aws-iot-greengrass:latest` | DevOps Ingenieur |
| Behälter verifizieren. | + Führen Sie den folgenden Befehl aus, um den Status des Containers zu überprüfen:
`docker ps \| grep aws-iot-greengrass`+ Führen Sie den folgenden Befehl aus, um Protokolle zu überwachen:
`docker logs -f aws-iot-greengrass` | DevOps Ingenieur |
### Container-Anwendungen verwalten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie Anwendungen bereit. | + Führen Sie den folgenden Befehl aus, um den Anwendungscontainer bereitzustellen:
`docker run -d --name my-app nginx:alpine`+ Führen Sie den folgenden Befehl aus, um die Bereitstellung zu überprüfen:
`docker ps`+ Führen Sie den folgenden Befehl aus, um auf Protokolle zuzugreifen:
`cd /greengrass/v2/logs && cat greengrass.log` | App-Developer |
| Zugreifen und testen Docker-in-Docker. | 1. Führen Sie den folgenden Befehl aus, um eine Shell im Container zu öffnen:
`docker exec -it aws-iot-greengrass sh`
2. Führen Sie die folgenden Befehle aus, um Docker zu verifizieren:
`docker --version`
`docker ps`
3. Führen Sie zum Testen Docker-in-Docker den folgenden Befehl aus:
`docker run --rm hello-world` | DevOps Ingenieur |
### (Optional) Integration mit Amazon ECS Anywhere
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Richten Sie den Amazon ECS-Cluster ein. | + Führen Sie den folgenden Befehl aus, um einen Amazon ECS-Cluster zu erstellen:
`aws ecs create-cluster --cluster-name greengrass-cluster --region us-east-1`+ Führen Sie den folgenden Befehl aus, um eine SSM-Aktivierung zu erstellen:
`aws ssm create-activation --default-instance-name greengrass-edge --iam-role GreengrassECSAnywhereRole --registration-limit 10 --region us-east-1`+ Führen Sie den folgenden Befehl aus, um den SSM-Agent auf einem Edge-Gerät zu installieren:
`curl -o install.sh https://s3.amazonaws.com/aws-ssm-downloads/latest/linux_amd64/install.sh`
`chmod +x install.sh`
`./install.sh activation-code activation-id us-east-1` | AWS-Administrator |
| Stellen Sie die Amazon ECS-Aufgabe bereit. | + Erstellen Sie `greengrass-task-definition.json` mit Aufgabenkonfiguration, einschließlich `containerDefinitions` mit`privileged:true`, Umgebungsvariablen und Volume-Mounts für `/var/lib/docker` und `/greengrass/v2.Register` Aufgabe. Führen Sie den folgenden Befehl aus:
`aws ecs register-task-definition --cli-input-json file://greengrass-task-definition.json`+ Führen Sie den folgenden Befehl aus, um den Dienst zu erstellen:
`aws ecs create-service --cluster greengrass-cluster --service-name greengrass-service --task-definition greengrass-dind --desired-count 1 --launch-type EXTERNAL --region us-east-1`+ Führen Sie den folgenden Befehl aus, um die Bereitstellung zu überprüfen:
`aws ecs describe-services --cluster greengrass-cluster --services greengrass-service --region us-east-1` | AWS-Administrator |
### Stoppen und aufräumen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stoppen Sie den Behälter. | + Führen Sie die folgenden Befehle aus, um den Container mithilfe von Docker Compose zu beenden:
`docker-compose stop`
`docker-compose down`
`docker-compose down -v`+ Führen Sie die folgenden Befehle aus, um den Container mithilfe der Docker-CLI zu stoppen (Volumes zu entfernen):
`docker stop aws-iot-greengrass`
`docker rm aws-iot-greengrass`+ Führen Sie den folgenden Befehl aus, um den Container mithilfe von Force Remove zu beenden:
`docker rm -f aws-iot-greengrass` | DevOps Ingenieur |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| Der Container kann mit Berechtigungsfehlern nicht gestartet werden. | 1. Führen Sie den folgenden Befehl aus, um sicherzustellen Docker-in-Docker, dass der Container mit dem für erforderlichen `--privileged` Flag ausgeführt wird:
`docker run --init --privileged -it --name aws-iot-greengrass x86_64/aws-iot-greengrass:latest`
2. Stellen Sie in der `docker-compose.yml` Datei Folgendes ein:
`privileged: true``--privileged`gewährt dem Container erweiterte Rechte. |
| Die Bereitstellung schlägt mit Fehlern bei den Anmeldeinformationen fehl. | Gehen Sie wie folgt vor, um zu überprüfen, ob die Anmeldeinformationen korrekt konfiguriert sind:1. Überprüfen Sie die IAM-Rolle:
`aws sts get-caller-identity`
2. Überprüfen Sie die Umgebungsvariablen:
`docker exec -it aws-iot-greengrass sh -c 'echo \$AWS_ACCESS_KEY_ID'`
3. Überprüfen Sie die Datei mit den Anmeldeinformationen:
`docker exec -it aws-iot-greengrass sh -c 'cat /root/.aws/credentials'`
Stellen Sie sicher, dass die IAM-Berechtigungen`iot:CreateThing`,`iot:CreatePolicy`, `iot:AttachPolicy``iam:CreateRole`, und `iam:AttachRolePolicy` enthalten. |
| Es kann keine Verbindung zum Docker-Daemon im Container hergestellt werden. | 1. Überprüfen Sie den Status des Docker-Daemons:
`docker exec -it aws-iot-greengrass sh -c 'ps aux \| grep dockerd'`
2. Stellen Sie sicher, dass der Docker-Socket vorhanden ist:
`docker exec -it aws-iot-greengrass sh -c 'ls -la /var/run/docker.sock'`
3. Bei Bedarf manuell starten:
`docker exec -it aws-iot-greengrass sh -c 'dockerd > /var/log/docker.log 2>&1 &'` |
| Der Container hat nicht mehr genügend Speicherplatz. | 1. Überprüfen Sie den Festplattenspeicher:
`df -h`
2. Docker-Ressourcen reinigen:
`docker system prune -a --volumes`
3. Entferne alte Greengrass-Artefakte:
`docker exec -it aws-iot-greengrass sh -c 'rm -rf /greengrass/v2/work/*`'Stellen Sie sicher, dass der Festplattenspeicher mindestens 5 GB für Basisoperationen und 50 GB für AWS IoT SiteWise Edge beträgt |
| Probleme beim Erstellen. | 1. Stellen Sie sicher, dass Sie sich im `docker` Verzeichnis befinden:
`cd docker && pwd`
2. Stellen Sie sicher, dass `Dockerfile` es existiert:
`ls -la Dockerfile`
3. Prüfen Sie, ob Docker installiert ist und läuft:
`docker --version && docker ps` |
| Probleme mit der Netzwerkverbindung. | 1. Testen Sie die DNS-Auflösung:
`docker exec -it aws-iot-greengrass sh -c 'nslookup google.com'`
2. AWS Konnektivität testen:
`docker exec -it aws-iot-greengrass sh -c 'curl https://iot.us-east-1.amazonaws.com'`Stellen Sie sicher, dass die Firewall ausgehenden HTTPS- (443) und MQTT- (8883) -Verkehr zulässt. |
| Greengrass-Komponenten können nicht bereitgestellt werden. | 1. Überprüfen Sie die Greengrass-Protokolle:
`docker exec -it aws-iot-greengrass sh -c 'cat /greengrass/v2/logs/greengrass.log'`
2. Überprüfen Sie die TES-Rollenkonfiguration:
`aws iot describe-role-alias --role-alias TES_ROLE_ALIAS_NAME`Überprüfen Sie die komponentenspezifischen Protokolle im `/greengrass/v2/logs/` Verzeichnis. |
| Der Container wird sofort nach dem Start beendet. | 1. Überprüfen Sie die Container-Protokolle auf Fehler:
`docker logs aws-iot-greengrass`
2. Zum Debuggen mit interaktiver Shell ausführen:
`docker run --init --privileged -it --entrypoint sh x86_64/aws-iot-greengrass:latest`Stellen Sie sicher, dass alle erforderlichen Umgebungsvariablen korrekt gesetzt sind, wenn`PROVISION=true`. Stellen Sie sicher, dass das `--init` Flag beim Starten des Containers verwendet wird. |
## Zugehörige Ressourcen
**AWS Ressourcen**
+ [Amazon Elastic Container Service](https://aws.amazon.com/ecs/)
+ [Konfigurieren Sie die Edge-Datenverarbeitung für AWS IoT SiteWise Modelle und Anlagen](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/edge-processing.html)
+ [Was ist AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html)
**Sonstige Ressourcen**
+ [Docker-Dokumentation](https://docs.docker.com/)
## Zusätzliche Informationen
+ Für die AWS IoT SiteWise Edge-Datenverarbeitung muss Docker in der AWS IoT Greengrass Umgebung verfügbar sein.
+ Um einen verschachtelten Container auszuführen, müssen Sie den AWS IoT Greengrass Container mit Anmeldeinformationen auf Administratorebene ausführen.