Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Jalankan kontainer Docker
Anda dapat mengonfigurasi AWS IoT Greengrass komponen untuk menjalankan wadah [Docker](https://www.docker.com/) dari gambar yang disimpan di lokasi berikut:
+ Repositori gambar publik dan pribadi di Amazon Elastic Container Registry (Amazon ECR)
+ Repositori Hub Docker publik
+ Registri Terpercaya Docker publik
+ Bucket S3
Dalam komponen kustom Anda, sertakan URI gambar Docker sebagai artefak untuk mengambil gambar dan menjalankannya pada perangkat inti. Untuk gambar Amazon ECR dan Hub Docker, Anda dapat menggunakan komponen [Manajer aplikasi Docker](docker-application-manager-component.md) untuk men-download gambar dan mengelola kredensial untuk repositori Amazon ECR privat.
**Topics**
+ [Persyaratan](#run-docker-container-requirements)
+ [Jalankan kontainer Docker dari gambar publik di Amazon ECR atau Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Jalankan kontainer Docker dari gambar privat di Amazon ECR](#run-docker-container-private-ecr)
+ [Jalankan kontainer Docker dari gambar di Amazon S3](#run-docker-container-s3)
+ [Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
+ [Gunakan AWS kredensil dalam komponen wadah Docker (Linux)](#docker-container-token-exchange-service)
+ [Gunakan pengelola aliran di komponen wadah Docker (Linux)](#docker-container-stream-manager)
## Persyaratan
Untuk menjalankan kontainer Docker dalam komponen, Anda memerlukan hal berikut:
+ Sebuah perangkat inti Greengrass. Jika Anda tidak memilikinya, lihat [Tutorial: Memulai dengan AWS IoT Greengrass V2](getting-started.md).
+ [Docker Engine](https://docs.docker.com/engine/) 1.9.1 atau yang lebih baru diinstal pada perangkat inti Greengrass. Versi 20.10 adalah versi terbaru yang diverifikasi untuk bekerja dengan perangkat lunak AWS IoT Greengrass Core. Anda harus menginstal Docker langsung pada perangkat inti sebelum Anda menyebarkan komponen yang menjalankan kontainer Docker.
**Tip**
Anda juga dapat mengonfigurasi perangkat inti untuk menginstal Docker Engine saat komponen diinstal. Sebagai contoh, script install berikut menginstal Docker Engine sebelum memuat gambar Docker. Skrip install ini bekerja pada distribusi Linux berbasis Debian, seperti Ubuntu. Jika Anda mengonfigurasi komponen untuk menginstal Docker Engine dengan perintah ini, Anda mungkin perlu mengatur `RequiresPrivilege` ke `true` dalam skrip siklus hidup untuk menjalankan instalasi dan perintah. `docker` Untuk informasi selengkapnya, lihat [AWS IoT Greengrass referensi resep komponen](component-recipe-reference.md).
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ Pengguna sistem yang menjalankan komponen kontainer Docker harus memiliki izin root atau administrator, atau Anda harus mengonfigurasi Docker untuk menjalankannya sebagai pengguna non-root atau non-admistrator.
+ Pada perangkat Linux, Anda dapat menambahkan pengguna ke `docker` grup untuk memanggil `docker` perintah tanpa`sudo`.
+ Pada perangkat Windows, Anda dapat menambahkan pengguna ke `docker-users` grup untuk memanggil `docker` perintah tanpa hak istimewa adminstrator.
------
#### [ Linux or Unix ]
Untuk menambahkan`ggc_user`, atau pengguna non-root yang Anda gunakan untuk menjalankan komponen kontainer Docker, ke `docker` grup, jalankan perintah berikut.
```
sudo usermod -aG docker ggc_user
```
Untuk informasi selengkapnya, lihat [Mengelola Docker sebagai pengguna non-root](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user).
------
#### [ Windows Command Prompt (CMD) ]
Untuk menambahkan`ggc_user`, atau pengguna yang Anda gunakan untuk menjalankan komponen kontainer Docker, ke `docker-users` grup, jalankan perintah berikut sebagai administrator.
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Untuk menambahkan`ggc_user`, atau pengguna yang Anda gunakan untuk menjalankan komponen kontainer Docker, ke `docker-users` grup, jalankan perintah berikut sebagai administrator.
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ File diakses oleh komponen kontainer Docker [yang dipasang sebagai volume](https://docs.docker.com/storage/volumes/) dalam kontainer Docker.
+ Jika Anda [mengkonfigurasi perangkat lunak AWS IoT Greengrass Core untuk menggunakan proxy jaringan](configure-greengrass-core-v2.md#configure-alpn-network-proxy), Anda harus [mengkonfigurasi Docker untuk menggunakan server proxy yang sama](https://docs.docker.com/network/proxy/).
Selain persyaratan ini, Anda juga harus memenuhi persyaratan berikut jika hal itu berlaku pada lingkungan Anda:
+ Untuk menggunakan [Docker Compose](https://docs.docker.com/compose/) untuk membuat dan memulai kontainer Docker Anda, instal Docker Compose pada perangkat inti Greengrass Anda, dan upload file Docker Compose ke bucket S3. Anda harus menyimpan file Compose Anda dalam bucket S3 yang sama Akun AWS dan Wilayah AWS sebagai komponen. Untuk contoh yang menggunakan perintah `docker-compose up` dalam komponen kustom, lihat [Jalankan kontainer Docker dari gambar publik di Amazon ECR atau Docker Hub](#run-docker-container-public-ecr-dockerhub).
+ [Jika Anda menjalankan AWS IoT Greengrass di belakang proxy jaringan, konfigurasikan daemon Docker untuk menggunakan server proxy.](https://docs.docker.com/network/proxy/)
+ Jika gambar Docker Anda disimpan di Amazon ECR atau Docker Hub, sertakan komponen [manajer komponen Docker](docker-application-manager-component.md) sebagai dependensi dalam komponen kontainer Docker Anda. Anda harus memulai daemon Docker pada perangkat inti sebelum Anda men-deploy komponen Anda.
Juga, sertakan gambar URIs sebagai artefak komponen. Gambar URIs harus dalam format `docker:registry/image[:tag|@digest]` seperti yang ditunjukkan pada contoh berikut:
+ Gambar Amazon ECR privat: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ Citra Amazon ECR publik: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ Citra Hub Docker publik: `docker:name[:tag|@digest]`
Untuk informasi selengkapnya tentang menjalankan kontainer Docker dari gambar yang disimpan di repositori publik, lihat. [Jalankan kontainer Docker dari gambar publik di Amazon ECR atau Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ Jika gambar Docker Anda disimpan dalam repositori privat Amazon ECR, maka Anda harus menyertakan komponen layanan pertukaran token sebagai dependensi dalam komponen kontainer Docker. Juga, [Peran perangkat Greengrass](device-service-role.md) harus mengizinkan tindakan `ecr:GetAuthorizationToken`, `ecr:BatchGetImage`, dan `ecr:GetDownloadUrlForLayer`, seperti yang ditunjukkan dalam contoh kebijakan IAM berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Untuk informasi tentang cara menjalankan kontainer Docker dari gambar yang disimpan dalam repositori privat Amazon ECR, lihat [Jalankan kontainer Docker dari gambar privat di Amazon ECR](#run-docker-container-private-ecr).
+ Untuk menggunakan gambar Docker yang disimpan dalam repositori pribadi Amazon ECR, repositori pribadi harus sama dengan perangkat inti. Wilayah AWS
+ Jika citra Docker atau file Compose disimpan dalam bucket S3, [peran perangkat Greengrass](device-service-role.md) harus memungkinkan izin `s3:GetObject` untuk memungkinkan perangkat inti mengunduh citra tersebut sebagai artefak komponen, seperti yang ditunjukkan dalam kebijakan IAM contoh berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Untuk informasi tentang cara menjalankan kontainer Docker dari gambar yang disimpan dalam Amazon S3, lihat [Jalankan kontainer Docker dari gambar di Amazon S3](#run-docker-container-s3).
+ Untuk menggunakan interprocess communication (IPC), AWS credentials, atau stream manager di komponen container Docker Anda, Anda harus menentukan opsi tambahan saat menjalankan container Docker. Untuk informasi selengkapnya, lihat berikut ini:
+ [Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
+ [Gunakan AWS kredensil dalam komponen wadah Docker (Linux)](#docker-container-token-exchange-service)
+ [Gunakan pengelola aliran di komponen wadah Docker (Linux)](#docker-container-stream-manager)
## Jalankan kontainer Docker dari gambar publik di Amazon ECR atau Docker Hub
Bagian ini menjelaskan bagaimana Anda dapat membuat komponen kustom yang menggunakan Docker Compose untuk menjalankan kontainer Docker dari gambar Docker yang disimpan di Amazon ECR dan Docker Hub.
**Untuk menjalankan kontainer Docker menggunakan Docker Compose**
1. Buat dan unggah file Docker Compose ke bucket Amazon S3. Pastikan bahwa [peran perangkat Greengrass](device-service-role.md) memungkinkan izin `s3:GetObject` untuk mengaktifkan perangkat untuk mengakses file Compose. Contoh file Compose yang ditampilkan dalam contoh berikut mencakup image Amazon CloudWatch Agent dari Amazon ECR dan image MySQL dari Docker Hub.
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. [Buat komponen khusus](create-components.md) di perangkat AWS IoT Greengrass inti Anda. Contoh resep yang ditunjukkan dalam contoh berikut memiliki sifat berikut:
+ Komponen manajer aplikasi Docker sebagai dependensi. Komponen ini memungkinkan AWS IoT Greengrass untuk mengunduh gambar dari repositori Amazon ECR dan Docker Hub publik.
+ Artefak komponen yang menentukan gambar Docker dalam repositori Amazon ECR publik.
+ Artefak komponen yang menentukan gambar Docker dalam repositori Docker Hub publik.
+ Komponen artefak yang menentukan file Docker Compose yang mencakup kontainer untuk gambar Docker yang ingin Anda jalankan.
+ Skrip lifecycle run yang menggunakan [docker-compose up](https://docs.docker.com/compose/reference/up/) untuk membuat dan memulai sebuah kontainer dari citra yang ditentukan.
------
#### [ 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://amzn-s3-demo-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://amzn-s3-demo-bucket/folder/docker-compose.yaml"
```
------
**catatan**
Untuk menggunakan interprocess communication (IPC), AWS credentials, atau stream manager di komponen container Docker Anda, Anda harus menentukan opsi tambahan saat menjalankan container Docker. Untuk informasi selengkapnya, lihat berikut ini:
[Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
[Gunakan AWS kredensil dalam komponen wadah Docker (Linux)](#docker-container-token-exchange-service)
[Gunakan pengelola aliran di komponen wadah Docker (Linux)](#docker-container-stream-manager)
1. [Uji komponen](test-components.md) untuk memverifikasi bahwa ia bekerja seperti yang diharapkan.
**penting**
Anda harus memulai daemon Docker sebelum Anda men-deploy komponen.
Setelah Anda men-deploy komponen lokal, Anda dapat menjalankan perintah [kontainer docker ls](https://docs.docker.com/engine/reference/commandline/container_ls/) untuk memverifikasi bahwa kontainer Anda berjalan.
```
docker container ls
```
1. Saat komponen sudah siap, unggah komponen untuk digunakan AWS IoT Greengrass ke perangkat inti lainnya. Untuk informasi selengkapnya, lihat [Publikasikan komponen untuk diterapkan ke perangkat inti Anda](publish-components.md).
## Jalankan kontainer Docker dari gambar privat di Amazon ECR
Bagian ini menjelaskan bagaimana Anda dapat membuat komponen kustom yang menjalankan kontainer Docker dari gambar Docker yang disimpan dalam repositori privat di Amazon ECR.
**Untuk menjalankan kontainer Docker**
1. [Buat komponen khusus](create-components.md) di perangkat AWS IoT Greengrass inti Anda. Gunakan contoh berikut resep, yang memiliki properti berikut:
+ Komponen manajer aplikasi Docker sebagai dependensi. Komponen ini memungkinkan AWS IoT Greengrass untuk mengelola kredensial untuk mengunduh gambar dari repositori privat.
+ Komponen layanan pertukaran token sebagai dependensi. Komponen ini memungkinkan AWS IoT Greengrass untuk mengambil AWS kredensil untuk berinteraksi dengan Amazon ECR.
+ Artefak komponen yang menentukan gambar Docker dalam repositori Amazon ECR privat.
+ Skrip lifecycle run yang menggunakan [docker run](https://docs.docker.com/engine/reference/commandline/run/) untuk membuat dan memulai sebuah kontainer dari gambar.
------
#### [ 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]"
```
------
**catatan**
Untuk menggunakan interprocess communication (IPC), AWS credentials, atau stream manager di komponen container Docker Anda, Anda harus menentukan opsi tambahan saat menjalankan container Docker. Untuk informasi selengkapnya, lihat berikut ini:
[Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
[Gunakan AWS kredensil dalam komponen wadah Docker (Linux)](#docker-container-token-exchange-service)
[Gunakan pengelola aliran di komponen wadah Docker (Linux)](#docker-container-stream-manager)
1. [Uji komponen](test-components.md) untuk memverifikasi bahwa ia bekerja seperti yang diharapkan.
**penting**
Anda harus memulai daemon Docker sebelum Anda men-deploy komponen.
Setelah Anda men-deploy komponen lokal, Anda dapat menjalankan perintah [kontainer docker ls](https://docs.docker.com/engine/reference/commandline/container_ls/) untuk memverifikasi bahwa kontainer Anda berjalan.
```
docker container ls
```
1. Unggah komponen AWS IoT Greengrass untuk disebarkan ke perangkat inti lainnya. Untuk informasi selengkapnya, lihat [Publikasikan komponen untuk diterapkan ke perangkat inti Anda](publish-components.md).
## Jalankan kontainer Docker dari gambar di Amazon S3
Bagian ini menjelaskan bagaimana Anda dapat menjalankan kontainer Docker dalam komponen dari gambar Docker yang disimpan di Amazon S3.
**Jalankan kontainer Docker dalam komponen dari gambar di Amazon S3**
1. Jalankan perintah [docker save](https://docs.docker.com/engine/reference/commandline/save/) untuk membuat cadangan kontainer Docker. Anda menyediakan cadangan ini sebagai artefak komponen untuk menjalankan kontainer pada AWS IoT Greengrass. Ganti *hello-world* dengan nama gambar, dan ganti *hello-world.tar* dengan nama file arsip yang akan dibuat.
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. [Buat komponen khusus](create-components.md) di perangkat AWS IoT Greengrass inti Anda. Gunakan contoh resep berikut, yang memiliki properti berikut:
+ Skrip lifecycle install yang menggunakan [docker load](https://docs.docker.com/engine/reference/commandline/load/) untuk memuat gambar Docker dari arsip.
+ Skrip lifecycle run yang menggunakan [docker run](https://docs.docker.com/engine/reference/commandline/run/) untuk membuat dan memulai sebuah kontainer dari gambar. Opsi `--rm` membersihkan kontainer ketika keluar.
------
#### [ 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
```
------
**catatan**
Untuk menggunakan interprocess communication (IPC), AWS credentials, atau stream manager di komponen container Docker Anda, Anda harus menentukan opsi tambahan saat menjalankan container Docker. Untuk informasi selengkapnya, lihat berikut ini:
[Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
[Gunakan AWS kredensil dalam komponen wadah Docker (Linux)](#docker-container-token-exchange-service)
[Gunakan pengelola aliran di komponen wadah Docker (Linux)](#docker-container-stream-manager)
1. [Uji komponen](test-components.md) untuk memverifikasi bahwa ia bekerja seperti yang diharapkan.
Setelah Anda men-deploy komponen lokal, Anda dapat menjalankan perintah [kontainer docker ls](https://docs.docker.com/engine/reference/commandline/container_ls/) untuk memverifikasi bahwa kontainer Anda berjalan.
```
docker container ls
```
1. Ketika komponen sudah siap, unggah arsip gambar Docker ke bucket S3, dan tambahkan URI ke resep komponen. Kemudian, Anda dapat mengunggah komponen AWS IoT Greengrass untuk menyebarkan ke perangkat inti lainnya. Untuk informasi selengkapnya, lihat [Publikasikan komponen untuk diterapkan ke perangkat inti Anda](publish-components.md).
Setelah selesai, resep komponen akan terlihat seperti contoh berikut.
------
#### [ 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://amzn-s3-demo-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://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
------
## Gunakan interprocess communication dalam komponen kontainer Docker
Anda dapat menggunakan perpustakaan Greengrass interprocess communication (IPC) AWS IoT Device SDK untuk berkomunikasi dengan inti Greengrass, komponen Greengrass lainnya, dan. AWS IoT Core Untuk informasi selengkapnya, lihat [Gunakan AWS IoT Device SDK untuk berkomunikasi dengan inti Greengrass, komponen lain, dan AWS IoT CoreBerkomunikasi dengan inti Greengrass, komponen lain, dan AWS IoT Core](interprocess-communication.md).
Untuk menggunakan IPC dalam komponen kontainer Docker, Anda harus menjalankan wadah Docker dengan parameter berikut:
+ Pasang soket IPC di wadah. Inti Greengrass menyediakan jalur file soket IPC dalam variabel lingkungan. `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
+ Atur variabel `SVCUID` dan `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` lingkungan ke nilai yang disediakan oleh inti Greengrass ke komponen. Komponen Anda menggunakan variabel lingkungan ini untuk mengautentikasi koneksi ke inti Greengrass.
**Example Contoh resep: Publikasikan pesan MQTT ke (Python) AWS IoT Core**
Resep berikut mendefinisikan contoh komponen kontainer Docker yang menerbitkan pesan MQTT ke. AWS IoT Core Resep ini memiliki sifat sebagai berikut:
+ Kebijakan otorisasi (`accessControl`) yang memungkinkan komponen untuk mempublikasikan pesan MQTT pada semua topik. AWS IoT Core Untuk informasi lebih lanjut, lihat [Otorisasi komponen untuk melakukan operasi IPC](interprocess-communication.md#ipc-authorization-policies) dan otorisasi [AWS IoT Core MQTT IPC](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization).
+ Artefak komponen yang menentukan image Docker sebagai arsip TAR di Amazon S3.
+ Skrip penginstalan siklus hidup yang memuat gambar Docker dari arsip TAR.
+ Skrip proses siklus hidup yang menjalankan wadah Docker dari gambar. Perintah [Docker run](https://docs.docker.com/engine/reference/run/) memiliki argumen berikut:
+ `-v`Argumen memasang soket Greengrass IPC di wadah.
+ Dua `-e` argumen pertama mengatur variabel lingkungan yang diperlukan dalam wadah Docker.
+ `-e`Argumen tambahan mengatur variabel lingkungan yang digunakan oleh contoh ini.
+ `--rm`Argumen membersihkan wadah saat keluar.
```
{
"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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
}
]
}
]
}
```
```
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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar
```
## Gunakan AWS kredensil dalam komponen wadah Docker (Linux)
Anda dapat menggunakan [komponen layanan pertukaran token untuk berinteraksi dengan AWS layanan di komponen](token-exchange-service-component.md) Greengrass. Komponen ini menyediakan AWS kredensyal dari [peran pertukaran token](device-service-role.md) perangkat inti menggunakan server kontainer lokal. Untuk informasi selengkapnya, lihat [Berinteraksi dengan AWS layanan](interact-with-aws-services.md).
**catatan**
Contoh di bagian ini hanya berfungsi pada perangkat inti Linux.
Untuk menggunakan AWS kredensyal dari layanan pertukaran token dalam komponen kontainer Docker, Anda harus menjalankan container Docker dengan parameter berikut:
+ Berikan akses ke jaringan host menggunakan `--network=host` argumen. Opsi ini memungkinkan kontainer Docker untuk terhubung ke layanan pertukaran token lokal untuk mengambil kredensyal AWS . Argumen ini hanya berfungsi pada Docker untuk Linux.
**Awas**
Opsi ini memberikan akses kontainer ke semua antarmuka jaringan lokal pada host, jadi opsi ini kurang aman daripada jika Anda menjalankan kontainer Docker tanpa akses ini ke jaringan host. Pertimbangkan ini saat Anda mengembangkan dan menjalankan komponen kontainer Docker yang menggunakan opsi ini. Untuk informasi selengkapnya, lihat [Jaringan: host](https://docs.docker.com/engine/reference/run/#network-host) di *Dokumentasi Docker*.
+ Atur variabel `AWS_CONTAINER_CREDENTIALS_FULL_URI` dan `AWS_CONTAINER_AUTHORIZATION_TOKEN` lingkungan ke nilai yang disediakan oleh inti Greengrass ke komponen. AWS SDKs gunakan variabel lingkungan ini untuk mengambil AWS kredensil.
**Example Contoh resep: Daftar bucket S3 dalam komponen wadah Docker (Python)**
Resep berikut mendefinisikan contoh komponen kontainer Docker yang mencantumkan bucket S3 di bucket Anda. Akun AWS Resep ini memiliki sifat sebagai berikut:
+ Komponen layanan pertukaran token sebagai dependensi. Ketergantungan ini memungkinkan komponen untuk mengambil AWS kredensi untuk berinteraksi dengan layanan lain. AWS
+ Artefak komponen yang menentukan image Docker sebagai arsip tar di Amazon S3.
+ Skrip penginstalan siklus hidup yang memuat gambar Docker dari arsip TAR.
+ Skrip proses siklus hidup yang menjalankan wadah Docker dari gambar. Perintah [Docker run](https://docs.docker.com/engine/reference/run/) memiliki argumen berikut:
+ `--network=host`Argumen menyediakan akses kontainer ke jaringan host, sehingga wadah dapat terhubung ke layanan pertukaran token.
+ `-e`Argumen menetapkan variabel lingkungan yang diperlukan dalam wadah Docker.
+ `--rm`Argumen membersihkan wadah saat keluar.
```
{
"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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
}
]
}
]
}
```
```
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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar
```
## Gunakan pengelola aliran di komponen wadah Docker (Linux)
Anda dapat menggunakan [komponen pengelola aliran](stream-manager-component.md) untuk mengelola aliran data di komponen Greengrass. Komponen ini memungkinkan Anda untuk memproses aliran data dan mentransfer data IoT volume tinggi ke file. AWS Cloud AWS IoT Greengrass menyediakan SDK manajer aliran yang Anda gunakan untuk berinteraksi dengan komponen pengelola aliran. Untuk informasi selengkapnya, lihat [Kelola aliran data di perangkat inti Greengrass](manage-data-streams.md).
**catatan**
Contoh di bagian ini hanya berfungsi pada perangkat inti Linux.
Untuk menggunakan SDK manajer aliran dalam komponen kontainer Docker, Anda harus menjalankan container Docker dengan parameter berikut:
+ Berikan akses ke jaringan host menggunakan `--network=host` argumen. Opsi ini memungkinkan wadah Docker untuk berinteraksi dengan komponen pengelola aliran melalui koneksi TLS lokal. Argumen ini hanya berfungsi pada Docker untuk Linux
**Awas**
Opsi ini memberikan akses kontainer ke semua antarmuka jaringan lokal pada host, jadi opsi ini kurang aman daripada jika Anda menjalankan kontainer Docker tanpa akses ini ke jaringan host. Pertimbangkan ini saat Anda mengembangkan dan menjalankan komponen kontainer Docker yang menggunakan opsi ini. Untuk informasi selengkapnya, lihat [Jaringan: host](https://docs.docker.com/engine/reference/run/#network-host) di *Dokumentasi Docker*.
+ Jika Anda mengonfigurasi komponen pengelola aliran agar memerlukan otentikasi, yang merupakan perilaku default, setel variabel `AWS_CONTAINER_CREDENTIALS_FULL_URI` lingkungan ke nilai yang disediakan inti Greengrass ke komponen. Untuk informasi selengkapnya, lihat [konfigurasi manajer aliran](stream-manager-component.md#stream-manager-component-configuration).
+ Jika Anda mengonfigurasi komponen pengelola aliran untuk menggunakan port non-default, gunakan [komunikasi antarproses (IPC)](interprocess-communication.md) untuk mendapatkan port dari konfigurasi komponen manajer aliran. Anda harus menjalankan wadah Docker dengan opsi tambahan untuk menggunakan IPC. Untuk informasi selengkapnya, lihat berikut ini:
+ [Hubungkan ke manajer pengaliran dalam kode aplikasi](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Gunakan interprocess communication dalam komponen kontainer Docker](#docker-container-ipc)
**Example Contoh resep: Streaming file ke bucket S3 dalam komponen wadah Docker (Python)**
Resep berikut mendefinisikan contoh komponen kontainer Docker yang membuat file dan mengalirkannya ke bucket S3. Resep ini memiliki sifat sebagai berikut:
+ Komponen stream manager sebagai dependensi. Ketergantungan ini memungkinkan komponen menggunakan SDK manajer aliran untuk berinteraksi dengan komponen pengelola aliran.
+ Artefak komponen yang menentukan image Docker sebagai arsip TAR di Amazon S3.
+ Skrip penginstalan siklus hidup yang memuat gambar Docker dari arsip TAR.
+ Skrip proses siklus hidup yang menjalankan wadah Docker dari gambar. Perintah [Docker run](https://docs.docker.com/engine/reference/run/) memiliki argumen berikut:
+ `--network=host`Argumen menyediakan akses kontainer ke jaringan host, sehingga kontainer dapat terhubung ke komponen manajer aliran.
+ `-e`Argumen pertama menetapkan variabel `AWS_CONTAINER_AUTHORIZATION_TOKEN` lingkungan yang diperlukan dalam wadah Docker.
+ `-e`Argumen tambahan mengatur variabel lingkungan yang digunakan oleh contoh ini.
+ `-v`Argumen memasang [folder kerja](component-recipe-reference.md#component-recipe-work-path) komponen di wadah. Contoh ini membuat file di folder kerja untuk mengunggah file itu ke Amazon S3 menggunakan pengelola aliran.
+ `--rm`Argumen membersihkan wadah saat keluar.
```
{
"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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
}
]
}
]
}
```
```
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://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar
```