Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Memulai dengan AWS IoT Greengrass V2
Anda dapat menyelesaikan tutorial memulai ini untuk mempelajari fitur-fitur dasar AWS IoT Greengrass V2. Dalam tutorial ini, Anda akan melakukan hal-hal berikut:
1. Instal dan konfigurasikan perangkat lunak AWS IoT Greengrass Core pada perangkat Linux, seperti Raspberry Pi, atau perangkat Windows. Perangkat ini adalah perangkat inti Greengrass.
1. Mengembangkan komponen Hello World pada perangkat inti Greengrass Anda. Komponen adalah modul perangkat lunak yang berjalan pada perangkat inti Greengrass.
1. Unggah komponen itu ke AWS IoT Greengrass V2 dalam AWS Cloud.
1. Terapkan komponen itu dari perangkat inti Greengrass Anda AWS Cloud ke perangkat inti Greengrass Anda.
**catatan**
Tutorial ini menjelaskan cara mengatur lingkungan pengembangan dan menjelajahi fitur-fiturnya AWS IoT Greengrass. Untuk informasi selengkapnya tentang cara mengatur dan mengonfigurasi perangkat produksi, lihat berikut ini:
[Menyiapkan perangkat AWS IoT Greengrass inti](setting-up.md)
[Instal perangkat lunak AWS IoT Greengrass Core](install-greengrass-core-v2.md)
Anda dapat mengharapkan untuk menghabiskan 20 hingga 30 menit pada tutorial ini.
**Topics**
+ [Prasyarat](getting-started-prerequisites.md)
+ [Langkah 1: Siapkan AWS akun](getting-started-set-up-aws-account.md)
+ [Langkah 2: Siapkan lingkungan Anda](getting-started-set-up-environment.md)
+ [Langkah 3: Instal perangkat lunak AWS IoT Greengrass Core](install-greengrass-v2.md)
+ [Langkah 4: Kembangkan dan uji komponen di perangkat Anda](create-first-component.md)
+ [Langkah 5: Buat komponen Anda dalam AWS IoT Greengrass layanan](upload-first-component.md)
+ [Langkah 6: Terapkan komponen Anda](deploy-first-component.md)
+ [Langkah selanjutnya](getting-started-next-steps.md)
# Prasyarat
Untuk menyelesaikan tutorial memulai ini, Anda memerlukan hal berikut ini:
+ Sebuah Akun AWS. Jika Anda tidak memilikinya, lihat [Langkah 1: Siapkan AWS akun](getting-started-set-up-aws-account.md).
+ Penggunaan sebuah [Wilayah AWS](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology)yang mendukung AWS IoT Greengrass V2. Untuk daftar Wilayah yang didukung, lihat [AWS IoT Greengrass V2 titik akhir dan kuota](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) di. *Referensi Umum AWS*
+ Pengguna AWS Identity and Access Management (IAM) dengan izin administrator.
+ Perangkat untuk diatur sebagai perangkat inti Greengrass, seperti Raspberry Pi [dengan Raspberry Pi OS (sebelumnya disebut Raspbian](https://www.raspberrypi.org/downloads/)), atau perangkat Windows 10. Anda harus memiliki izin administrator pada perangkat ini, atau kemampuan untuk memperoleh hak administrator, seperti melalui. `sudo` Perangkat ini harus memiliki koneksi internet.
Anda juga dapat memilih untuk menggunakan perangkat lain yang memenuhi persyaratan untuk menginstal dan menjalankan perangkat lunak AWS IoT Greengrass Core.
Jika komputer pengembangan Anda memenuhi persyaratan ini, Anda dapat mengaturnya sebagai perangkat inti Greengrass Anda dalam tutorial ini.
+ [Python](https://www.python.org/downloads/) 3.5 atau yang lebih baru diinstal untuk semua pengguna di perangkat dan ditambahkan ke variabel `PATH` lingkungan. Di Windows, Anda juga harus menginstal Python Launcher untuk Windows untuk semua pengguna.
**penting**
Di Windows, Python tidak menginstal untuk semua pengguna secara default. Ketika Anda menginstal Python, Anda harus menyesuaikan instalasi untuk mengkonfigurasinya untuk perangkat lunak AWS IoT Greengrass Core untuk menjalankan skrip Python. Misalnya, jika Anda menggunakan penginstal Python grafis, lakukan hal berikut:
Pilih **Instal peluncur untuk semua pengguna (disarankan)**.
Pilih **Customize installation**.
Pilih **Next**.
Pilih **Install for all users**.
Pilih **Add Python to environment variables**.
Pilih **Instal**.
Untuk informasi selengkapnya, lihat [Menggunakan Python di Windows](https://docs.python.org/3/using/windows.html) dalam dokumentasi *Python* 3.
+ AWS Command Line Interface (AWS CLI) diinstal dan dikonfigurasi dengan kredensi di komputer pengembangan Anda dan di perangkat Anda. Pastikan Anda menggunakan hal yang sama Wilayah AWS untuk mengkonfigurasi AWS CLI pada komputer pengembangan Anda dan pada perangkat Anda. Untuk menggunakannya AWS IoT Greengrass V2 AWS CLI, Anda harus memiliki salah satu versi berikut atau yang lebih baru:
+ Versi AWS CLI V1 minimum: v1.18.197
+ Versi AWS CLI V2 minimum: v2.1.11
**Tip**
Anda dapat menjalankan perintah berikut untuk memeriksa versi AWS CLI yang Anda miliki.
```
aws --version
```
Untuk informasi selengkapnya, lihat [Menginstal, memperbarui, dan melepas pemasangan AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dan [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) di *Panduan Pengguna AWS Command Line Interface *.
**catatan**
Jika Anda menggunakan perangkat ARM 32-bit, seperti Raspberry Pi dengan sistem operasi 32-bit, instal AWS CLI V1. AWS CLI V2 tidak tersedia untuk perangkat ARM 32-bit. Untuk informasi selengkapnya, lihat [Menginstal, memperbarui, dan menghapus instalan AWS CLI versi 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html).
# Langkah 1: Siapkan AWS akun
## Mendaftar untuk Akun AWS
Jika Anda tidak memiliki Akun AWS, selesaikan langkah-langkah berikut untuk membuatnya.
**Untuk mendaftar untuk Akun AWS**
1. Buka [https://portal.aws.amazon.com/billing/pendaftaran.](https://portal.aws.amazon.com/billing/signup)
1. Ikuti petunjuk online.
Bagian dari prosedur pendaftaran melibatkan menerima panggilan telepon atau pesan teks dan memasukkan kode verifikasi pada keypad telepon.
Saat Anda mendaftar untuk sebuah Akun AWS, sebuah *Pengguna root akun AWS*dibuat. Pengguna root memiliki akses ke semua Layanan AWS dan sumber daya di akun. Sebagai praktik keamanan terbaik, tetapkan akses administratif ke pengguna, dan gunakan hanya pengguna root untuk melakukan [tugas yang memerlukan akses pengguna root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS mengirimi Anda email konfirmasi setelah proses pendaftaran selesai. Kapan saja, Anda dapat melihat aktivitas akun Anda saat ini dan mengelola akun Anda dengan masuk [https://aws.amazon.com.rproxy.goskope.comke/](https://aws.amazon.com/) dan memilih **Akun Saya**.
## Buat pengguna dengan akses administratif
Setelah Anda mendaftar Akun AWS, amankan Pengguna root akun AWS, aktifkan AWS IAM Identity Center, dan buat pengguna administratif sehingga Anda tidak menggunakan pengguna root untuk tugas sehari-hari.
**Amankan Anda Pengguna root akun AWS**
1. Masuk ke [Konsol Manajemen AWS](https://console.aws.amazon.com/)sebagai pemilik akun dengan memilih **pengguna Root** dan memasukkan alamat Akun AWS email Anda. Di laman berikutnya, masukkan kata sandi.
Untuk bantuan masuk dengan menggunakan pengguna root, lihat [Masuk sebagai pengguna root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) di *AWS Sign-In Panduan Pengguna*.
1. Mengaktifkan autentikasi multi-faktor (MFA) untuk pengguna root Anda.
Untuk petunjuk, lihat [Mengaktifkan perangkat MFA virtual untuk pengguna Akun AWS root (konsol) Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) di Panduan Pengguna *IAM*.
**Buat pengguna dengan akses administratif**
1. Aktifkan Pusat Identitas IAM.
Untuk mendapatkan petunjuk, silakan lihat [Mengaktifkan AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) di *Panduan Pengguna AWS IAM Identity Center *.
1. Di Pusat Identitas IAM, berikan akses administratif ke pengguna.
Untuk tutorial tentang menggunakan Direktori Pusat Identitas IAM sebagai sumber identitas Anda, lihat [Mengkonfigurasi akses pengguna dengan default Direktori Pusat Identitas IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) di *Panduan AWS IAM Identity Center Pengguna*.
**Masuk sebagai pengguna dengan akses administratif**
+ Untuk masuk dengan pengguna Pusat Identitas IAM, gunakan URL masuk yang dikirim ke alamat email saat Anda membuat pengguna Pusat Identitas IAM.
Untuk bantuan masuk menggunakan pengguna Pusat Identitas IAM, lihat [Masuk ke portal AWS akses](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) di *Panduan AWS Sign-In Pengguna*.
**Tetapkan akses ke pengguna tambahan**
1. Di Pusat Identitas IAM, buat set izin yang mengikuti praktik terbaik menerapkan izin hak istimewa paling sedikit.
Untuk petunjuknya, lihat [Membuat set izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) di *Panduan AWS IAM Identity Center Pengguna*.
1. Tetapkan pengguna ke grup, lalu tetapkan akses masuk tunggal ke grup.
Untuk petunjuk, lihat [Menambahkan grup](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) di *Panduan AWS IAM Identity Center Pengguna*.
# Langkah 2: Siapkan lingkungan Anda
**catatan**
Langkah-langkah ini tidak berlaku untuk nucleus lite.
Ikuti langkah-langkah di bagian ini untuk menyiapkan perangkat Linux atau Windows untuk digunakan sebagai perangkat AWS IoT Greengrass inti Anda.
## Siapkan perangkat Linux (Raspberry Pi)
Langkah-langkah ini menganggap bahwa Anda menggunakan Raspberry Pi dengan Raspberry Pi OS. Jika Anda menggunakan perangkat atau sistem operasi yang berbeda, baca dokumentasi yang relevan untuk perangkat Anda.
**Untuk mengatur Raspberry Pi untuk AWS IoT Greengrass V2**
1. Aktifkan SSH pada Anda Raspberry Pi untuk terhubung secara jarak jauh dengannya. Untuk informasi selengkapnya, lihat, [SSH (Secure shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) dalam *Dokumentasi Raspberry Pi*.
1. Temukan alamat IP Raspberry Pi Anda untuk terhubung ke sana dengan SSH. Untuk melakukannya, Anda dapat menjalankan perintah berikut pada Raspberry Pi Anda.
```
hostname -I
```
1. Hubungkan ke Raspberry Pi Anda dengan SSH.
Pada komputer pengembangan Anda, jalankan perintah berikut. Ganti *username* dengan nama pengguna untuk masuk, dan ganti *pi-ip-address* dengan alamat IP yang Anda temukan di langkah sebelumnya.
```
ssh username@pi-ip-address
```
**penting**
Jika komputer pengembangan Anda menggunakan versi Windows yang lebih lama, Anda mungkin tidak memiliki perintah `ssh`, atau Anda mungkin memiliki `ssh` tetapi tidak dapat terhubung ke Raspberry Pi Anda. Untuk terhubung ke Raspberry Pi Anda, Anda dapat menginstal dan mengonfigurasi [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), yang merupakan klien SSH tanpa biaya dan open source. Baca [Dokumentasi PuTTY](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs) untuk terhubung ke Raspberry Pi Anda..
1. Instal runtime Java, yang dibutuhkan perangkat lunak AWS IoT Greengrass Core untuk dijalankan. Pada Raspberry Pi Anda, gunakan perintah berikut untuk menginstal Java 11.
```
sudo apt install default-jdk
```
Ketika instalasi selesai, jalankan perintah berikut untuk memverifikasi bahwa Java berjalan pada Raspberry Pi Anda.
```
java -version
```
Perintah mencetak versi Java yang berjalan pada perangkat. Output-nya akan terlihat serupa dengan yang berikut ini.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Tip: Atur parameter kernel pada Raspberry Pi**
Jika perangkat Anda adalah Raspberry Pi, Anda dapat menyelesaikan langkah-langkah berikut untuk melihat dan memperbarui parameter kernel Linux-nya:
Buka file `/boot/cmdline.txt`. File ini menentukan parameter kernel Linux untuk diterapkan ketika Raspberry Pi boot.
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuka file.
```
sudo nano /boot/cmdline.txt
```
Verifikasi bahwa `/boot/cmdline.txt` file tersebut berisi parameter kernel berikut. `systemd.unified_cgroup_hierarchy=0`Parameter menentukan untuk menggunakan cgroups v1 bukan cgroups v2.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Jika `/boot/cmdline.txt` file tidak berisi parameter ini, atau berisi parameter ini dengan nilai yang berbeda, perbarui file untuk berisi parameter dan nilai ini.
Jika Anda memperbarui `/boot/cmdline.txt` file, reboot Raspberry Pi untuk menerapkan perubahan.
```
sudo reboot
```
## Siapkan perangkat Linux (lainnya)
**Untuk mengatur perangkat Linux untuk AWS IoT Greengrass V2**
1. Instal runtime Java, yang dibutuhkan perangkat lunak AWS IoT Greengrass Core untuk dijalankan. Kami menyarankan Anda menggunakan versi dukungan jangka panjang [Amazon Corretto](https://aws.amazon.com/corretto/) [atau](https://openjdk.java.net/) OpenJDK. Versi 8 atau lebih tinggi diperlukan. Perintah berikut menunjukkan cara menginstal OpenJDK di perangkat Anda.
+ Untuk distribusi berbasis Debian atau berbasis Ubuntu:
```
sudo apt install default-jdk
```
+ Untuk distribusi berbasis Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ Untuk Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Untuk Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Ketika instalasi selesai, jalankan perintah berikut untuk memverifikasi bahwa Java berjalan pada perangkat Linux Anda.
```
java -version
```
Perintah mencetak versi Java yang berjalan pada perangkat. Misalnya, pada distribusi berbasis Debian, output mungkin terlihat mirip dengan sampel berikut.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opsional) Buat pengguna dan grup sistem default yang menjalankan komponen pada perangkat. Anda juga dapat memilih untuk membiarkan penginstal perangkat lunak AWS IoT Greengrass Core membuat pengguna dan grup ini selama instalasi dengan argumen `--component-default-user` installer. Untuk informasi selengkapnya, lihat [Argumen penginstal](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Verifikasi bahwa pengguna yang menjalankan perangkat lunak AWS IoT Greengrass Core (biasanya`root`), memiliki izin untuk menjalankan `sudo` dengan pengguna dan grup apa pun.
1. Jalankan perintah berikut untuk membuka `/etc/sudoers` file.
```
sudo visudo
```
1. Verifikasi bahwa izin untuk pengguna terlihat seperti contoh berikut.
```
root ALL=(ALL:ALL) ALL
```
1. **(Opsional) Untuk [menjalankan fungsi Lambda kontainer](run-lambda-functions.md), Anda harus mengaktifkan [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1, dan Anda harus mengaktifkan dan memasang memori dan perangkat cgroups.** Jika Anda tidak berencana untuk menjalankan fungsi Lambda kontainer, Anda dapat melewati langkah ini.
Untuk mengaktifkan opsi cgroups ini, boot perangkat dengan parameter kernel Linux berikut.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Untuk informasi tentang melihat dan menyetel parameter kernel untuk perangkat Anda, lihat dokumentasi untuk sistem operasi dan boot loader Anda. Ikuti instruksi untuk mengatur parameter kernel secara permanen.
1. Instal semua dependensi lain yang diperlukan pada perangkat Anda seperti yang ditunjukkan oleh daftar persyaratan di. [Persyaratan perangkat](greengrass-nucleus-component.md#greengrass-v2-requirements)
## Siapkan perangkat Windows
**Untuk mengatur perangkat Windows untuk AWS IoT Greengrass V2**
1. Instal runtime Java, yang dibutuhkan perangkat lunak AWS IoT Greengrass Core untuk dijalankan. Kami menyarankan Anda menggunakan versi dukungan jangka panjang [Amazon Corretto](https://aws.amazon.com/corretto/) [atau](https://openjdk.java.net/) OpenJDK. Versi 8 atau lebih tinggi diperlukan.
1. Periksa apakah Java tersedia pada variabel sistem [PATH](https://en.wikipedia.org/wiki/PATH_(variable)), dan tambahkan jika tidak. LocalSystem Akun menjalankan perangkat lunak AWS IoT Greengrass Core, jadi Anda harus menambahkan Java ke variabel sistem PATH alih-alih variabel pengguna PATH untuk pengguna Anda. Lakukan hal-hal berikut:
1. Tekan tombol Windows untuk membuka menu mulai.
1. Ketik **environment variables** untuk mencari opsi sistem dari menu mulai.
1. Di hasil pencarian menu mulai, pilih **Edit variabel lingkungan sistem** untuk membuka jendela **Properti sistem**.
1. Pilih **variabel Lingkungan...** untuk membuka jendela **Variabel Lingkungan**.
1. Di bawah **Variabel sistem**, pilih **Path**, lalu pilih **Edit**. Di jendela **variabel Edit lingkungan**, Anda dapat melihat setiap jalur pada baris terpisah.
1. Periksa apakah jalur ke `bin` folder instalasi Java ada. Jalannya mungkin terlihat mirip dengan contoh berikut.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Jika `bin` folder instalasi Java hilang dari **Path**, pilih **Baru** untuk menambahkannya, lalu pilih **OK**.
1. Buka Windows Command Prompt (`cmd.exe`) sebagai administrator.
1. Buat pengguna default di LocalSystem akun di perangkat Windows. Ganti *password* dengan kata sandi yang aman.
```
net user /add ggc_user password
```
**Tip**
Bergantung pada konfigurasi Windows Anda, kata sandi pengguna mungkin diatur untuk kedaluwarsa pada tanggal di masa mendatang. Untuk memastikan aplikasi Greengrass Anda terus beroperasi, lacak kapan kata sandi kedaluwarsa, dan perbarui sebelum kedaluwarsa. Anda juga dapat mengatur kata sandi pengguna agar tidak pernah kedaluwarsa.
Untuk memeriksa kapan pengguna dan kata sandinya kedaluwarsa, jalankan perintah berikut.
```
net user ggc_user | findstr /C:expires
```
Untuk mengatur kata sandi pengguna agar tidak pernah kedaluwarsa, jalankan perintah berikut.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Jika Anda menggunakan Windows 10 atau yang lebih baru di mana [`wmic`perintah tidak digunakan lagi](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), jalankan perintah berikut. PowerShell
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Unduh dan instal [PsExecutilitas](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) dari Microsoft pada perangkat.
1. Gunakan PsExec utilitas untuk menyimpan nama pengguna dan kata sandi untuk pengguna default dalam contoh Credential Manager untuk LocalSystem akun tersebut. Ganti *password* dengan kata sandi pengguna yang Anda tetapkan sebelumnya.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Jika **PsExec License Agreement**terbuka, pilih **Accept**untuk menyetujui lisensi dan jalankan perintah.
**catatan**
Pada perangkat Windows, LocalSystem akun menjalankan inti Greengrass, dan Anda harus menggunakan utilitas untuk menyimpan PsExec informasi pengguna default di akun. LocalSystem Menggunakan aplikasi Credential Manager menyimpan informasi ini di akun Windows dari pengguna yang saat ini masuk, bukan LocalSystem akun.
# Langkah 3: Instal perangkat lunak AWS IoT Greengrass Core
**Tip**
Kami menyarankan Anda mencoba [Paket Konteks Agen AI AWS Greengrass IoT untuk menyiapkan dan bereksperimen dengan IoT Greengrass](https://github.com/aws-greengrass/greengrass-agent-context-pack) dengan cepat. AWS Paket konteks agen akan memungkinkan agen AI untuk menyiapkan Greengrass Nucleus dan Nucleus Lite, menyebarkan komponen, dan memecahkan masalah umum.
Ikuti langkah-langkah di bagian ini untuk mengatur Raspberry Pi Anda sebagai perangkat AWS IoT Greengrass inti yang dapat Anda gunakan untuk pengembangan lokal. Di bagian ini, Anda mengunduh dan menjalankan penginstal yang melakukan hal berikut untuk mengonfigurasi perangkat lunak AWS IoT Greengrass Core untuk perangkat Anda:
+ Memasang komponen inti Greengrass. Nukleus adalah komponen wajib dan merupakan persyaratan minimum untuk menjalankan perangkat lunak AWS IoT Greengrass Core pada perangkat. Untuk informasi selengkapnya, lihat, [komponen nukleus Greengrass](greengrass-nucleus-component.md).
+ Mendaftarkan perangkat Anda sebagai AWS IoT sesuatu dan mengunduh sertifikat digital yang memungkinkan perangkat Anda terhubung AWS. Untuk informasi selengkapnya, lihat [Otentikasi dan otorisasi perangkat untuk AWS IoT Greengrass](device-auth.md).
+ Menambahkan AWS IoT benda perangkat ke grup benda, yang merupakan kelompok atau armada AWS IoT benda. Grup objek memungkinkan Anda untuk mengelola armada perangkat inti Greengrass. Saat men-deploy komponen perangkat lunak ke perangkat, Anda dapat memilih untuk men-deploy ke perangkat individual atau ke grup perangkat. Untuk informasi selengkapnya, lihat, [Mengelola perangkat dengan AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html) di *Panduan Developer AWS IoT Core *.
+ Buat IAM role yang memungkinkan perangkat inti Greengrass Anda untuk berinteraksi dengan layanan AWS . Secara default, peran ini memungkinkan perangkat Anda berinteraksi AWS IoT dan mengirim log ke Amazon CloudWatch Logs. Untuk informasi selengkapnya, lihat [Otorisasi perangkat inti untuk berinteraksi dengan layanan AWS](device-service-role.md).
+ Menginstal antarmuka baris AWS IoT Greengrass perintah (`greengrass-cli`), yang dapat Anda gunakan untuk menguji komponen kustom yang Anda kembangkan pada perangkat inti. Untuk informasi selengkapnya, lihat [Antarmuka Baris Perintah Greengrass](gg-cli.md).
# Instal perangkat lunak AWS IoT Greengrass Core (konsol)
1. Masuk ke [konsol AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) tersebut.
1. **Di bawah **Memulai Greengrass**, pilih Siapkan perangkat inti.**
1. Di bawah **Langkah 1: Daftarkan perangkat inti Greengrass, untuk nama perangkat Core**, masukkan nama AWS IoT benda **untuk perangkat inti** Greengrass Anda. Jika objek tidak ada, installer akan membuatnya.
1. Di bawah **Langkah 2: Tambahkan ke grup hal untuk menerapkan penerapan berkelanjutan**, untuk **grup Thing**, pilih grup AWS IoT hal yang ingin Anda tambahkan perangkat inti Anda.
+ Jika Anda memilih **Masukkan nama grup baru**, lalu di **Nama grup Thing**, masukkan nama grup baru yang akan dibuat. Installer membuat grup baru untuk Anda.
+ Jika Anda memilih **Pilih grup yang ada**, lalu di **Nama grup Thing**, pilih grup yang ada yang ingin Anda gunakan.
+ Jika Anda memilih **Tidak ada grup**, maka penginstal tidak menambahkan perangkat inti ke grup sesuatu.
1. Di bawah **Langkah 3: Instal perangkat lunak Greengrass Core**, selesaikan langkah-langkah berikut.
------
#### [ Nucleus classic ]
1. Pilih **Nucleus classic** sebagai runtime perangkat lunak inti Anda.
1. Pilih sistem operasi perangkat inti Anda: **Linux** atau **Windows**.
1. Berikan AWS kredensi Anda ke perangkat sehingga penginstal dapat menyediakan sumber daya AWS IoT dan IAM untuk perangkat inti Anda. Untuk meningkatkan keamanan, sebaiknya Anda mendapatkan kredensi sementara untuk peran IAM yang hanya mengizinkan izin minimum yang diperlukan untuk penyediaan. Untuk informasi selengkapnya, lihat [Kebijakan IAM minimal untuk penginstal untuk menyediakan sumber daya](provision-minimal-iam-policy.md).
**catatan**
Penginstal tidak menyimpan atau menyimpan kredensial Anda.
Di perangkat Anda, lakukan salah satu hal berikut untuk mengambil kredensi dan membuatnya tersedia untuk penginstal perangkat lunak AWS IoT Greengrass Core:
+ (Disarankan) Gunakan kredensi sementara dari AWS IAM Identity Center
1. Berikan ID kunci akses, kunci akses rahasia, dan token sesi dari Pusat Identitas IAM. Untuk informasi selengkapnya, lihat **Penyegaran kredenal manual** di [Mendapatkan dan menyegarkan kredenal sementara](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) di panduan pengguna Pusat Identitas *IAM*.
1. Jalankan perintah berikut untuk memberikan kredensi ke perangkat lunak AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Gunakan kredenal keamanan sementara dari peran IAM:
1. Berikan access key ID, secret access key, dan token sesi dari IAM role yang Anda teruskan. *Untuk informasi selengkapnya tentang cara mengambil kredenal ini, lihat [Meminta kredenal keamanan sementara di Panduan Pengguna IAM.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)*
1. Jalankan perintah berikut untuk memberikan kredensi ke perangkat lunak AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Gunakan kredensial jangka panjang dari pengguna IAM:
1. Berikan access key ID dan secret access key untuk pengguna IAM Anda. Anda dapat membuat pengguna IAM untuk penyediaan yang kemudian Anda hapus. Untuk kebijakan IAM untuk memberikan pengguna, lihat[Kebijakan IAM minimal untuk penginstal untuk menyediakan sumber daya](provision-minimal-iam-policy.md). Untuk informasi selengkapnya tentang cara mengambil kredensial jangka panjang, lihat [Mengelola access key untuk pengguna IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) di *Panduan Pengguna IAM*.
1. Jalankan perintah berikut untuk memberikan kredensi ke perangkat lunak AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (Opsional) Jika Anda membuat pengguna IAM untuk menyediakan perangkat Greengrass Anda, hapus pengguna tersebut.
1. (Opsional) Jika Anda menggunakan ID kunci akses dan kunci akses rahasia dari pengguna IAM yang ada, perbarui kunci untuk pengguna sehingga tidak lagi valid. Untuk informasi selengkapnya, lihat [Memperbarui kunci akses](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) di *panduan AWS Identity and Access Management pengguna*.
1. Di bawah **Jalankan penginstal**, selesaikan langkah-langkah berikut.
1. Di bawah **Unduh penginstal**, pilih **Salin** dan jalankan perintah yang disalin pada perangkat inti Anda. Perintah ini mengunduh versi terbaru dari perangkat lunak AWS IoT Greengrass Core dan membuka ritsletingnya di perangkat Anda.
1. Di bawah **Jalankan penginstal**, pilih **Salin**, dan jalankan perintah yang disalin pada perangkat inti Anda. Perintah ini menggunakan nama grup AWS IoT benda dan benda yang Anda tentukan sebelumnya untuk menjalankan penginstal perangkat lunak AWS IoT Greengrass Core dan menyiapkan AWS sumber daya untuk perangkat inti Anda.
Perintah ini juga melakukan hal berikut:
+ Siapkan perangkat lunak AWS IoT Greengrass Core sebagai layanan sistem yang berjalan saat boot. Pada perangkat Linux, ini membutuhkan sistem init [Systemd](https://en.wikipedia.org/wiki/Systemd).
**penting**
Pada perangkat inti Windows, Anda harus mengatur perangkat lunak AWS IoT Greengrass inti sebagai layanan sistem.
+ Terapkan komponen [AWS IoT Greengrass CLI](gg-cli.md), yang merupakan alat baris perintah yang memungkinkan Anda mengembangkan komponen Greengrass khusus pada perangkat inti.
+ Tentukan untuk menggunakan pengguna `ggc_user` sistem untuk menjalankan komponen perangkat lunak pada perangkat inti. Pada perangkat Linux, perintah ini juga menentukan untuk menggunakan grup `ggc_group` sistem, dan penginstal membuat pengguna dan grup sistem untuk Anda.
Ketika Anda menjalankan perintah ini, Anda akan melihat pesan berikut untuk menunjukkan bahwa installer berhasil.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**catatan**
Jika Anda memiliki perangkat Linux dan tidak memiliki [systemd](https://en.wikipedia.org/wiki/Systemd), penginstal tidak akan mengatur perangkat lunak sebagai layanan sistem, dan Anda tidak akan melihat pesan sukses untuk menyiapkan inti sebagai layanan sistem.
------
#### [ Nucleus lite ]
1. Pilih **Nucleus lite** sebagai runtime perangkat lunak inti Anda.
1. Pilih metode penyiapan perangkat Anda untuk menyediakan perangkat Anda ke perangkat inti Greengrass.
**Opsi 1: Siapkan perangkat dengan unduhan paket (sekitar 1MB)**
1. Buat AWS IoT sesuatu dan peran untuk Greengrass.
1. Unduh file zip yang berisi AWS IoT sumber daya yang perlu disambungkan oleh perangkat Anda AWS IoT:
+ Sertifikat dan kunci pribadi yang dihasilkan menggunakan AWS IoT otoritas sertifikat.
+ File skema untuk memulai instalasi Greengrass untuk perangkat Anda.
1. Unduh paket yang akan menginstal runtime Greengrass Nucleus lite terbaru ke Raspberry Pi Anda.
1. Menyediakan perangkat Anda untuk menjadi perangkat AWS IoT Greengrass Core dan menghubungkannya ke AWS IoT:
1. sebuah. Transfer paket Greengrass dan kit koneksi ke perangkat Anda menggunakan USB thumb drive, SCP/FTP, atau kartu SD.
1. b. Buka zip file greengrass-package.zip di GreengrassInstaller direktori/pada perangkat.
1. c. Buka zip file zip kit koneksi di direktori /pada perangkat.
1. d. Jalankan perintah yang disediakan pada perangkat untuk menginstal AWS IoT Greengrass
1. Kemudian, pilih **Lihat perangkat inti**.
**Opsi 2: Siapkan perangkat dengan unduhan gambar sampel seluruh disk yang telah dikonfigurasi sebelumnya (sekitar 100MB)**
1. Buat AWS IoT sesuatu dan peran untuk Greengrass.
1. Unduh file zip yang berisi AWS IoT sumber daya yang perlu disambungkan oleh perangkat Anda AWS IoT:
+ Sertifikat dan kunci pribadi yang dihasilkan menggunakan AWS IoT otoritas sertifikat.
+ File skema untuk memulai instalasi Greengrass untuk perangkat Anda.
1. Unduh gambar sampel seluruh disk yang telah dikonfigurasi sebelumnya yang berisi Greengrass dan sistem operasi.
1. Untuk mentransfer kit koneksi dan mem-flash gambar ke perangkat Anda, ikuti file readme yang diunduh dengan gambar.
1. Untuk memulai instalasi Greengrass, nyalakan dan boot perangkat dari gambar yang di-flash
1. Kemudian, pilih **Lihat perangkat inti**.
**Opsi 3: Siapkan perangkat dengan build kustom Anda sendiri**
1. Buat AWS IoT sesuatu dan peran untuk Greengrass.
1. Unduh file zip yang berisi AWS IoT sumber daya yang perlu disambungkan oleh perangkat Anda AWS IoT:
+ Sertifikat dan kunci pribadi yang dihasilkan menggunakan AWS IoT otoritas sertifikat.
+ File skema untuk memulai instalasi Greengrass untuk perangkat Anda.
1. Untuk menyesuaikan dan membuat gambar Anda sendiri menggunakan Yocto dari kode sumber, lalu gunakan kit koneksi untuk menginstal nucleus lite, ikuti instruksi di. GitHub
1. Kemudian, pilih **Lihat perangkat inti**.
------
# Instal perangkat lunak AWS IoT Greengrass inti (CLI)
**catatan**
Langkah-langkah ini tidak berlaku untuk nucleus lite.
**Untuk menginstal dan mengkonfigurasi perangkat lunak AWS IoT Greengrass Core**
1. Pada perangkat inti Greengrass Anda, jalankan perintah berikut untuk beralih ke direktori home.
------
#### [ Linux or Unix ]
```
cd ~
```
------
#### [ Windows Command Prompt (CMD) ]
```
cd %USERPROFILE%
```
------
#### [ PowerShell ]
```
cd ~
```
------
1. Di perangkat inti Anda, unduh perangkat lunak AWS IoT Greengrass Core ke file bernama`greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Dengan mengunduh perangkat lunak ini, Anda menyetujui [Perjanjian Lisensi Perangkat Lunak Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. Buka zip perangkat lunak AWS IoT Greengrass Core ke folder di perangkat Anda. Ganti *GreengrassInstaller* dengan folder yang ingin Anda gunakan.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. Jalankan perintah berikut untuk meluncurkan penginstal perangkat lunak AWS IoT Greengrass inti. Perintah ini melakukan hal berikut:
+ Buat AWS sumber daya yang dibutuhkan perangkat inti untuk beroperasi.
+ Siapkan perangkat lunak AWS IoT Greengrass Core sebagai layanan sistem yang berjalan saat boot. Pada perangkat Linux, ini membutuhkan sistem init [Systemd](https://en.wikipedia.org/wiki/Systemd).
**penting**
Pada perangkat inti Windows, Anda harus mengatur perangkat lunak AWS IoT Greengrass inti sebagai layanan sistem.
+ Terapkan komponen [AWS IoT Greengrass CLI](gg-cli.md), yang merupakan alat baris perintah yang memungkinkan Anda mengembangkan komponen Greengrass khusus pada perangkat inti.
+ Tentukan untuk menggunakan pengguna `ggc_user` sistem untuk menjalankan komponen perangkat lunak pada perangkat inti. Pada perangkat Linux, perintah ini juga menentukan untuk menggunakan grup `ggc_group` sistem, dan penginstal membuat pengguna dan grup sistem untuk Anda.
Ganti nilai argumen dalam perintah Anda sebagai berikut.
1. `/greengrass/v2`atau*C:\$1greengrass\$1v2*: Jalur ke folder root yang akan digunakan untuk menginstal perangkat lunak AWS IoT Greengrass Core.
1. *GreengrassInstaller*. Jalur ke folder tempat Anda membongkar penginstal perangkat lunak AWS IoT Greengrass Core.
1. *region*. Wilayah AWS Di mana untuk menemukan atau membuat sumber daya.
1. *MyGreengrassCore*. Nama AWS IoT benda untuk perangkat inti Greengrass Anda. Jika objek tidak ada, installer akan membuatnya. Pemasang mengunduh sertifikat untuk diautentikasi sebagai masalahnya. AWS IoT Untuk informasi selengkapnya, lihat [Otentikasi dan otorisasi perangkat untuk AWS IoT Greengrass](device-auth.md).
**catatan**
Nama objek tidak dapat berisi karakter titik dua (`:`).
1. *MyGreengrassCoreGroup*. Nama grup AWS IoT benda untuk perangkat inti Greengrass Anda. Jika grup objek tidak ada, installer akan membuatnya dan menambahkan objek padanya. Jika grup objek ada dan memiliki deployment yang aktif, perangkat inti akan men-download dan menjalankan perangkat lunak yang ditetapkan oleh deployment.
**catatan**
Nama grup objek tidak dapat berisi karakter titik dua (`:`).
1. *GreengrassV2IoTThingPolicy*. Nama AWS IoT kebijakan yang memungkinkan perangkat inti Greengrass untuk berkomunikasi dengan dan. AWS IoT AWS IoT Greengrass Jika AWS IoT kebijakan tidak ada, penginstal akan membuat AWS IoT kebijakan permisif dengan nama ini. Anda dapat membatasi izin kebijakan ini untuk kasus penggunaan Anda. Untuk informasi selengkapnya, lihat [AWS IoT Kebijakan minimal untuk perangkat AWS IoT Greengrass V2 inti](device-auth.md#greengrass-core-minimal-iot-policy).
1. *GreengrassV2TokenExchangeRole*. Nama peran IAM yang memungkinkan perangkat inti Greengrass mendapatkan kredensi sementara. AWS Jika peran itu tidak ada, penginstal akan membuatnya dan membuat serta melampirkan kebijakan bernama `GreengrassV2TokenExchangeRoleAccess`. Untuk informasi selengkapnya, lihat [Otorisasi perangkat inti untuk berinteraksi dengan layanan AWS](device-service-role.md).
1. *GreengrassCoreTokenExchangeRoleAlias*. Alias untuk peran IAM yang memungkinkan perangkat inti Greengrass untuk mendapatkan kredensi sementara nanti. Jika alias peran tidak ada, penginstal akan membuatnya dan mengarahkannya ke IAM role yang Anda tentukan. Untuk informasi selengkapnya, lihat [Otorisasi perangkat inti untuk berinteraksi dengan layanan AWS](device-service-role.md).
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true \
--deploy-dev-tools true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true ^
--deploy-dev-tools true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true `
--deploy-dev-tools true
```
------
**catatan**
Jika Anda menjalankan AWS IoT Greengrass perangkat dengan memori terbatas, Anda dapat mengontrol jumlah memori yang digunakan perangkat lunak AWS IoT Greengrass Core. Untuk mengontrol alokasi memori, Anda dapat mengatur pilihan ukuran tumpukan JVM di konfigurasi parameter `jvmOptions` dalam komponen nukleus anda. Untuk informasi selengkapnya, lihat [Kontrol alokasi memori dengan opsi JVM](configure-greengrass-core-v2.md#jvm-tuning).
Ketika Anda menjalankan perintah ini, Anda akan melihat pesan berikut untuk menunjukkan bahwa installer berhasil.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**catatan**
Jika Anda memiliki perangkat Linux dan tidak memiliki [systemd](https://en.wikipedia.org/wiki/Systemd), penginstal tidak akan mengatur perangkat lunak sebagai layanan sistem, dan Anda tidak akan melihat pesan sukses untuk menyiapkan inti sebagai layanan sistem.
# (Opsional) Jalankan perangkat lunak Greengrass (Linux)
**catatan**
Langkah-langkah ini tidak berlaku untuk nucleus lite.
Jika Anda menginstal perangkat lunak sebagai layanan sistem, installer akan menjalankan perangkat lunak untuk Anda. Jika tidak, Anda harus menjalankan perangkat lunak itu. Untuk melihat apakah installer mengatur perangkat lunak sebagai layanan sistem, cari baris berikut dalam output installer.
```
Successfully set up Nucleus as a system service
```
Jika Anda tidak melihat pesan ini, lakukan langkah-langkah berikut untuk menjalankan perangkat lunak:
1. Jalankan perintah berikut untuk menjalankan perangkat lunak tersebut.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
Perangkat lunak mencetak pesan berikut jika berhasil meluncurkan.
```
Launched Nucleus successfully.
```
1. Anda harus membiarkan shell perintah saat ini terbuka untuk menjaga perangkat lunak AWS IoT Greengrass Core tetap berjalan. Jika Anda menggunakan SSH untuk terhubung ke perangkat inti, jalankan perintah berikut di komputer pengembangan Anda untuk membuka sesi SSH kedua yang dapat Anda gunakan untuk menjalankan perintah tambahan pada perangkat inti. Ganti *username* dengan nama pengguna untuk masuk, dan ganti *pi-ip-address* dengan alamat IP perangkat.
```
ssh username@pi-ip-address
```
Untuk informasi lebih lanjut tentang cara berinteraksi dengan layanan sistem Greengrass, lihat [Konfigurasikan inti Greengrass sebagai layanan sistem](configure-greengrass-core-v2.md#configure-system-service).
# Verifikasi instalasi CLI Greengrass di perangkat
**catatan**
Langkah-langkah ini tidak berlaku untuk nucleus lite.
CLI Greengrass dapat memakan waktu hingga satu menit untuk digunakan. Jalankan perintah berikut untuk memeriksa status penyebaran. Ganti *MyGreengrassCore* dengan nama perangkat inti Anda.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore
```
`coreDeviceExecutionStatus` menunjukkan status deployment ke perangkat inti. Ketika statusnya adalah `SUCCEEDED`, jalankan perintah berikut untuk memverifikasi bahwa Greengrass CLI terinstal dan berjalan. Ganti `/greengrass/v2` dengan jalur ke folder root.
------
#### [ Linux or Unix ]
```
/greengrass/v2/bin/greengrass-cli help
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
Perintah output membantu informasi untuk Greengrass CLI. Jika `greengrass-cli` tidak ditemukan, deployment mungkin gagal untuk menginstal Greengrass CLI. Untuk informasi selengkapnya, lihat [Pemecahan masalah AWS IoT Greengrass V2](troubleshooting.md).
Anda juga dapat menjalankan perintah berikut untuk menyebarkan AWS IoT Greengrass CLI secara manual ke perangkat Anda.
+ Ganti *region* dengan Wilayah AWS yang Anda gunakan. Pastikan Anda menggunakan yang sama dengan Wilayah AWS yang Anda gunakan untuk mengonfigurasi AWS CLI pada perangkat Anda.
+ Ganti *account-id* dengan Akun AWS ID Anda.
+ Ganti *MyGreengrassCore* dengan nama perangkat inti Anda.
------
#### [ Linux, macOS, or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--components '{
"aws.greengrass.Cli": {
"componentVersion": "2.16.1"
}
}'
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}"
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}'
```
------
**Tip**
Anda dapat menambahkan `/greengrass/v2/bin` (Linux) atau `C:\greengrass\v2\bin` (Windows) ke variabel `PATH` lingkungan Anda untuk berjalan `greengrass-cli` tanpa jalur absolutnya.
Perangkat lunak AWS IoT Greengrass inti dan alat pengembangan lokal berjalan di perangkat Anda. Selanjutnya, Anda dapat mengembangkan AWS IoT Greengrass komponen Hello World di perangkat Anda.
# Langkah 4: Kembangkan dan uji komponen di perangkat Anda
Komponen adalah modul perangkat lunak yang berjalan pada perangkat AWS IoT Greengrass inti. Komponen memungkinkan Anda untuk membuat dan mengelola aplikasi yang kompleks sebagai blok bangunan diskrit yang dapat Anda gunakan kembali dari satu perangkat inti Greengrass ke yang lain. Setiap komponen terdiri atas *resep* dan *artifact*.
+ **Resep**
Setiap komponen berisi file resep, yang mendefinisikan metadata nya. Resep ini juga menentukan parameter konfigurasi komponen, dependensi komponen, siklus hidup, dan kompatibilitas platform. Siklus hidup komponen menentukan perintah yang menginstal, menjalankan, dan menutup komponen. Untuk informasi selengkapnya, lihat [AWS IoT Greengrass referensi resep komponen](component-recipe-reference.md).
Anda bisa menentukan resep dalam format [JSON](https://en.wikipedia.org/wiki/JSON) atau [YAML](https://en.wikipedia.org/wiki/YAML).
+ **Artefak**
Komponen dapat memiliki sejumlah artifact, yang merupakan komponen biner. Artifact dapat mencakup skrip, kode yang dikompilasi, sumber daya statis, dan file lain yang dikonsumsi komponen. Komponen juga dapat mengonsumsi artifact dari dependensi komponen.
Dengan AWS IoT Greengrass, Anda dapat menggunakan CLI Greengrass untuk mengembangkan dan menguji komponen secara lokal pada perangkat inti Greengrass tanpa interaksi dengan Cloud. AWS Saat menyelesaikan komponen lokal, Anda dapat menggunakan resep komponen dan artefak untuk membuat komponen tersebut di AWS IoT Greengrass layanan di AWS Cloud, lalu menerapkannya ke semua perangkat inti Greengrass Anda. Untuk informasi selengkapnya tentang komponen, lihat[Kembangkan AWS IoT Greengrass komponen](develop-greengrass-components.md).
Di bagian ini, Anda mempelajari cara membuat dan menjalankan komponen Hello World dasar secara lokal di perangkat inti Anda.
**Untuk mengembangkan komponen Hello World di perangkat Anda**
1. Buat folder untuk komponen Anda dengan subfolder untuk resep dan artefak. Jalankan perintah berikut pada perangkat inti Greengrass Anda untuk membuat folder ini dan mengubah ke folder komponen. Ganti *\$1/greengrassv2* atau *%USERPROFILE%\$1greengrassv2* dengan jalur ke folder yang akan digunakan untuk pengembangan lokal.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Gunakan editor teks untuk membuat file resep yang mendefinisikan metadata, parameter, dependensi, siklus hidup, dan kemampuan platform komponen Anda. Sertakan versi komponen dalam nama file resep agar Anda dapat mengidentifikasi resep yang mencerminkan versi komponen. Anda dapat memilih format YAML atau JSON untuk resep Anda.
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**catatan**
AWS IoT Greengrass menggunakan versi semantik untuk komponen. Versi semantik mengikuti sistem nomor *mayor*.*minor*.*patch*. Sebagai contoh, versi `1.0.0` merupakan rilis mayor pertama untuk sebuah komponen. Untuk informasi lebih lanjut, lihat [spesifikasi versi semantik](https://semver.org/).
1. Tempel resep berikut ke file.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
Bagian `ComponentConfiguration` resep ini menentukan parameter, `Message`, yang default -nya adalah `world`. Bagian `Manifests` menentukan *manifes*, yang merupakan serangkaian instruksi siklus hidup dan artifact untuk platform. Anda dapat menentukan beberapa manifes untuk menentukan petunjuk pemasangan yang berbeda untuk berbagai platform, misalnya. Dalam manifes, bagian `Lifecycle` memerintahkan perangkat inti Greengrass untuk menjalankan skrip Hello World dengan nilai parameter `Message` sebagai argumen.
1. Jalankan perintah berikut untuk membuat folder untuk komponen artifact.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
------
**penting**
Anda harus menggunakan format berikut untuk jalur folder artifact. Sertakan nama dan versi komponen yang Anda tentukan dalam resep.
```
artifacts/componentName/componentVersion/
```
1. Gunakan editor teks untuk membuat file artefak skrip Python untuk komponen Hello World Anda.
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.
```
nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Copy dan paste script Python berikut ke dalam file.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Gunakan AWS IoT Greengrass CLI lokal untuk mengelola komponen pada perangkat inti Greengrass Anda.
Jalankan perintah berikut untuk menyebarkan komponen ke AWS IoT Greengrass inti. Ganti `/greengrass/v2` atau *C:\$1greengrass\$1v2* dengan folder AWS IoT Greengrass V2 root Anda, dan ganti *\$1/greengrassv2* atau *%USERPROFILE%\$1greengrassv2* dengan folder pengembangan komponen Anda.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Perintah ini menambahkan komponen yang menggunakan resep di `recipes` dan skrip Python di `artifacts`. Opsi `--merge` menambahkan atau memperbarui komponen dan versi yang Anda tentukan.
1. Perangkat lunak AWS IoT Greengrass Core menyimpan stdout dari proses komponen ke file log di folder. `logs` Jalankan perintah berikut untuk memverifikasi bahwa komponen Hello World berjalan dan mencetak pesan.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Anda akan melihat pesan yang mirip dengan contoh berikut ini.
```
Hello, world!
```
**catatan**
Jika file tidak ada, penyebaran lokal mungkin belum lengkap. Jika file tidak ada dalam waktu 15 detik, deployment mungkin gagal. Hal ini dapat terjadi jika resep Anda tidak valid, misalnya. Jalankan perintah berikut untuk melihat file log AWS IoT Greengrass inti. File ini mencakup log dari layanan deployment perangkat inti Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\logs\greengrass.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
1. Ubah komponen lokal untuk mengiterasi dan menguji kode Anda. Buka `hello_world.py` di editor teks, dan tambahkan kode berikut pada baris 4 untuk mengedit pesan yang dicatat oleh AWS IoT Greengrass inti.
```
message += " Greetings from your first Greengrass component."
```
Skrip `hello_world.py` sekarang akan berisi konten berikut.
```
import sys
message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Jalankan perintah berikut untuk memperbarui komponen dengan perubahan Anda.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
Perintah ini memperbarui `com.example.HelloWorld` komponen dengan artefak Hello World terbaru.
1. Jalankan perintah berikut untuk me-restart komponen. Ketika Anda me-restart komponen, perangkat inti menggunakan perubahan terakhir.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component restart \
--names "com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component restart ^
--names "com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component restart `
--names "com.example.HelloWorld"
```
------
1. Periksa log lagi untuk memverifikasi bahwa komponen Hello World mencetak pesan baru.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Anda akan melihat pesan yang mirip dengan contoh berikut ini.
```
Hello, world! Greetings from your first Greengrass component.
```
1. Anda dapat memperbarui parameter konfigurasi komponen untuk menguji konfigurasi yang berbeda. Ketika Anda men-deploy komponen, Anda dapat menentukan *pembaruan konfigurasi*, yang menentukan cara mengubah konfigurasi komponen pada perangkat inti. Anda dapat menentukan nilai konfigurasi yang akan di-reset ke nilai default dan nilai-nilai konfigurasi baru yang akan digabungkan ke perangkat inti. Untuk informasi selengkapnya, lihat [Perbarui konfigurasi komponen](update-component-configurations.md).
Lakukan hal-hal berikut:
1. Gunakan editor teks untuk membuat file yang dipanggil `hello-world-config-update.json` untuk memuat pembaruan konfigurasi
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.
```
nano hello-world-config-update.json
```
1. Salin dan tempel objek JSON berikut ke dalam file. Objek JSON ini menentukan pembaruan konfigurasi yang menggabungkan nilai `friend` ke parameter `Message` untuk memperbarui nilainya. Pembaruan konfigurasi ini tidak menentukan nilai apa pun yang akan di-reset. Anda tidak perlu mengatur ulang parameter `Message` karena pembaruan merge menggantikan nilai yang ada.
```
{
"com.example.HelloWorld": {
"MERGE": {
"Message": "friend"
}
}
}
```
1. Jalankan perintah berikut untuk men-deploy pembaruan konfigurasi pada komponen Hello World.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--merge "com.example.HelloWorld=1.0.0" \
--update-config hello-world-config-update.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--merge "com.example.HelloWorld=1.0.0" ^
--update-config hello-world-config-update.json
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--merge "com.example.HelloWorld=1.0.0" `
--update-config hello-world-config-update.json
```
------
1. Periksa log lagi untuk memverifikasi bahwa komponen Hello World mengeluarkan pesan baru.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Anda akan melihat pesan yang mirip dengan contoh berikut ini.
```
Hello, friend! Greetings from your first Greengrass component.
```
1. Setelah Anda selesai menguji komponen, lepaskan komponen tersebut dari perangkat inti Anda. Jalankan perintah berikut.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
------
**penting**
Langkah ini diperlukan bagi Anda untuk men-deploy komponen kembali ke perangkat inti setelah Anda mengunggahnya ke AWS IoT Greengrass. Jika tidak, deployment akan gagal dengan kesalahan kompatibilitas versi karena deployment lokal menentukan versi yang berbeda dari komponen.
Jalankan perintah berikut dan verifikasi bahwa perintah `com.example.HelloWorld` tidak muncul dalam daftar komponen di perangkat Anda.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component list
```
------
Komponen Hello World Anda selesai, dan sekarang Anda dapat mengunggahnya ke layanan AWS IoT Greengrass cloud. Kemudian, Anda dapat menerapkan komponen ke perangkat inti Greengrass.
# Langkah 5: Buat komponen Anda dalam AWS IoT Greengrass layanan
Ketika Anda selesai mengembangkan komponen pada perangkat inti Anda, Anda dapat mengunggahnya ke AWS IoT Greengrass layanan di AWS Cloud. Anda juga dapat langsung membuat komponen di [AWS IoT Greengrass konsol](https://console.aws.amazon.com/greengrass). AWS IoT Greengrass menyediakan layanan manajemen komponen yang menghosting komponen Anda sehingga Anda dapat menyebarkannya ke perangkat individual atau armada perangkat. Untuk mengunggah komponen ke AWS IoT Greengrass layanan, Anda menyelesaikan langkah-langkah berikut:
+ Unggah artefak komponen ke bucket S3.
+ Tambahkan setiap URI Amazon Simple Storage Service (Amazon S3) artefak ke resep komponen.
+ Buat komponen AWS IoT Greengrass dari resep komponen.
Di bagian ini, Anda menyelesaikan langkah-langkah ini pada perangkat inti Greengrass Anda untuk mengunggah komponen Hello World Anda ke layanan. AWS IoT Greengrass
## Buat komponen Anda di AWS IoT Greengrass (konsol)
1. Gunakan bucket S3 di AWS akun Anda untuk meng-host artefak AWS IoT Greengrass komponen. Saat Anda men-deploy komponen ke perangkat inti, perangkat akan mengunduh artefak komponen dari bucket.
Anda dapat menggunakan bucket S3 yang sudah ada, atau Anda dapat membuat bucket baru.
1. **Di [konsol Amazon S3](https://console.aws.amazon.com/s3), di bawah **Bucket, pilih Buat ember**.**
1. Untuk **nama Bucket**, masukkan nama bucket yang unik. Misalnya, Anda dapat menggunakan**greengrass-component-artifacts-*region*-*123456789012***. Ganti *123456789012* dengan ID AWS akun Anda dan *region* dengan Wilayah AWS yang Anda gunakan untuk tutorial ini.
1. Untuk **AWS wilayah**, pilih AWS Wilayah yang Anda gunakan untuk tutorial ini.
1. Pilih **Buat bucket**.
1. Di bawah **Bucket**, pilih bucket yang Anda buat, unggah `hello_world.py` skrip ke `artifacts/com.example.HelloWorld/1.0.0` folder di bucket. Untuk informasi tentang mengunggah objek ke bucket S3, lihat [Mengunggah objek di Panduan Pengguna](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) Layanan *Penyimpanan Sederhana Amazon*.
1. Salin URI S3 `hello_world.py` objek di bucket S3. URI ini akan terlihat serupa dengan contoh berikut. Ganti amzn-s3-demo-bucket dengan nama bucket S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
1. Izinkan perangkat inti mengakses artefak komponen dalam bucket S3.
Setiap perangkat [inti memiliki peran IAM perangkat inti](device-service-role.md) yang memungkinkannya berinteraksi dengan AWS IoT dan mengirim log ke AWS Cloud. Peran perangkat ini tidak mengizinkan akses ke bucket S3 secara default, sehingga Anda harus membuat dan melampirkan kebijakan yang memungkinkan perangkat inti mengambil artefak komponen dari bucket S3.
Jika peran perangkat Anda sudah memungkinkan akses ke bucket S3, Anda dapat melewati langkah ini. Jika tidak, buat kebijakan IAM yang memungkinkan akses dan melampirkannya pada peran, sebagai berikut:
1. Di menu navigasi [konsol IAM](https://console.aws.amazon.com/iam), pilih **Kebijakan**, lalu pilih **Buat kebijakan**.
1. Pada tab **JSON**, ganti placeholder konten dengan kebijakan berikut. Ganti amzn-s3-demo-bucket dengan nama bucket S3 yang berisi artefak komponen untuk diunduh perangkat inti.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Pilih **Berikutnya**.
1. Di **bagian Detail kebijakan**, untuk **Nama**, masukkan**MyGreengrassV2ComponentArtifactPolicy**.
1. Pilih **Buat kebijakan**.
1. Di menu navigasi [konsol IAM](https://console.aws.amazon.com/iam), pilih **Peran**, lalu pilih nama peran untuk perangkat inti. Anda menentukan nama peran ini saat menginstal perangkat lunak AWS IoT Greengrass Inti. Jika Anda tidak menentukan nama, defaultnya adalah`GreengrassV2TokenExchangeRole`.
1. Di bawah **Izin**, pilih **Tambahkan izin**, lalu pilih **Lampirkan** kebijakan.
1. Pada halaman **Tambahkan izin**, pilih kotak centang di samping `MyGreengrassV2ComponentArtifactPolicy` kebijakan yang Anda buat, lalu pilih **Tambahkan izin**.
1. Gunakan resep komponen untuk membuat komponen di [AWS IoT Greengrass konsol](https://console.aws.amazon.com/greengrass).
1. Di menu navigasi [AWS IoT Greengrass konsol](https://console.aws.amazon.com/greengrass), pilih **Komponen**, lalu pilih **Buat komponen**.
1. Di bawah **Informasi komponen**, pilih **Masukkan resep sebagai JSON**. Resep placeholder akan terlihat mirip dengan contoh berikut.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
1. Ganti URI placeholder di setiap `Artifacts` bagian dengan URI S3 objek Anda. `hello_world.py`
1. Pilih **Buat komponen**.
1. Di **com.example. HelloWorld**halaman komponen, verifikasi bahwa **Status** komponen adalah **Deployable**.
## Buat komponen Anda di AWS IoT Greengrass (AWS CLI)
**Untuk mengunggah komponen Hello World anda**
1. Gunakan bucket S3 di artefak AWS IoT Greengrass komponen Anda Akun AWS untuk meng-host. Saat Anda men-deploy komponen ke perangkat inti, perangkat akan mengunduh artefak komponen dari bucket.
Anda dapat menggunakan bucket S3 yang ada, atau menjalankan perintah berikut untuk membuat bucket. Perintah ini membuat bucket dengan Akun AWS ID Anda dan Wilayah AWS untuk membentuk nama bucket yang unik. Ganti *123456789012* dengan Akun AWS ID Anda dan *region* dengan Wilayah AWS yang Anda gunakan untuk tutorial ini.
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
Perintah ini mengeluarkan informasi berikut jika permintaan berhasil.
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
1. Izinkan perangkat inti mengakses artefak komponen dalam bucket S3.
Setiap perangkat [inti memiliki peran IAM perangkat inti](device-service-role.md) yang memungkinkannya berinteraksi dengan AWS IoT dan mengirim log ke file. AWS Cloud Peran perangkat ini tidak mengizinkan akses ke bucket S3 secara default, sehingga Anda harus membuat dan melampirkan kebijakan yang memungkinkan perangkat inti mengambil artefak komponen dari bucket S3.
Jika peran perangkat inti sudah memungkinkan akses ke bucket S3, Anda dapat melewati langkah ini. Jika tidak, buat kebijakan IAM yang memungkinkan akses dan melampirkannya pada peran, sebagai berikut:
1. Buat file bernama `component-artifact-policy.json` dan salin JSON berikut ke dalam file. Kebijakan ini memungkinkan akses ke semua file dalam bucket S3. Ganti amzn-s3-demo-bucket dengan nama bucket S3.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Jalankan perintah berikut untuk membuat kebijakan dari dokumen kebijakan di `component-artifact-policy.json`.
------
#### [ Linux or Unix ]
```
aws iam create-policy \\
--policy-name MyGreengrassV2ComponentArtifactPolicy \\
--policy-document file://component-artifact-policy.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam create-policy ^
--policy-name MyGreengrassV2ComponentArtifactPolicy ^
--policy-document file://component-artifact-policy.json
```
------
#### [ PowerShell ]
```
aws iam create-policy `
--policy-name MyGreengrassV2ComponentArtifactPolicy `
--policy-document file://component-artifact-policy.json
```
------
Salin Amazon Resource Name (ARN) kebijakan dari metadata kebijakan dalam output. Anda menggunakan ARN ini untuk melampirkan kebijakan ini ke peran perangkat inti di langkah berikutnya.
1. Jalankan perintah berikut untuk melampirkan kebijakan tersebut pada peran perangkat inti. Ganti *GreengrassV2TokenExchangeRole* dengan nama peran untuk perangkat inti. Anda menentukan nama peran ini saat menginstal perangkat lunak AWS IoT Greengrass Inti. Ganti ARN kebijakan dengan ARN dari langkah sebelumnya.
------
#### [ Linux or Unix ]
```
aws iam attach-role-policy \\
--role-name GreengrassV2TokenExchangeRole \\
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam attach-role-policy ^
--role-name GreengrassV2TokenExchangeRole ^
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ PowerShell ]
```
aws iam attach-role-policy `
--role-name GreengrassV2TokenExchangeRole `
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
Jika perintah tidak memiliki output, itu berhasil. Perangkat inti sekarang dapat mengakses artefak yang Anda unggah ke bucket S3 ini.
1. Unggah artefak skrip Python Hello World ke bucket S3.
Jalankan perintah berikut untuk mengunggah skrip ke jalur yang sama di bucket tempat skrip ada di AWS IoT Greengrass inti Anda. Ganti amzn-s3-demo-bucket dengan nama bucket S3.
------
#### [ Linux or Unix ]
```
aws s3 cp \
artifacts/com.example.HelloWorld/1.0.0/hello_world.py \
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws s3 cp ^
artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ PowerShell ]
```
aws s3 cp `
artifacts/com.example.HelloWorld/1.0.0/hello_world.py `
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
Perintah itu mengeluarkan baris yang dimulai dengan `upload:` jika permintaan berhasil.
1. Tambahkan URI Amazon S3 artefak ke resep komponen.
URI Amazon S3 terdiri atas nama bucket dan path ke objek artefak dalam bucket. URI Amazon S3 Anda adalah URI tujuan Anda mengunggah artefak pada langkah sebelumnya. URI ini akan terlihat serupa dengan contoh berikut. Ganti amzn-s3-demo-bucket dengan nama bucket S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Untuk menambahkan artefak ke resep, tambahkan daftar `Artifacts` yang berisi struktur dengan URI Amazon S3.
------
#### [ JSON ]
```
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
```
Buka file resep di editor teks.
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
Tambahkan artefak ke resep. File resep Anda akan terlihat seperti contoh berikut.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Buka file resep di editor teks.
Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
Tambahkan artefak ke resep. File resep Anda akan terlihat seperti contoh berikut.
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
1. Buat sumber daya komponen AWS IoT Greengrass dari resep. Jalankan perintah berikut untuk membuat komponen dari resep, yang Anda sediakan sebagai file biner.
------
#### [ JSON ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml
```
------
Responsnya terlihat seperti contoh berikut jika permintaan berhasil.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
Salin `arn` dari output untuk memeriksa keadaan komponen pada langkah berikutnya.
**catatan**
Anda juga dapat melihat komponen Hello World di [Konsol AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) pada halaman **Komponen**.
1. Verifikasi bahwa komponen tersebut terbuat dan siap untuk di-deploy. Ketika Anda membuat komponen, keadaannya adalah `REQUESTED`. Kemudian, AWS IoT Greengrass memvalidasi bahwa komponen tersebut dapat di-deploy. Anda dapat menjalankan perintah berikut untuk melakukan kueri atas status komponen dan memverifikasi bahwa komponen Anda dapat di-deploy. Ganti `arn` dengan ARN dari langkah sebelumnya.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0"
```
Jika komponen tervalidasi, respons akan menunjukkan bahwa keadaan komponen adalah `DEPLOYABLE`.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-11-30T18:04:05.823Z",
"publisher": "Amazon",
"description": "My first Greengrass component.",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"os": "linux",
"architecture": "all"
}
]
}
```
Komponen Hello World Anda sekarang tersedia di AWS IoT Greengrass. Anda dapat men-deploy-nya kembali ke perangkat inti Greengrass ini atau ke perangkat inti lainnya.
# Langkah 6: Terapkan komponen Anda
Dengan AWS IoT Greengrass, Anda dapat menyebarkan komponen ke perangkat individual atau grup perangkat. Saat Anda menerapkan komponen, AWS IoT Greengrass menginstal dan menjalankan perangkat lunak komponen tersebut di setiap perangkat target. Anda menentukan komponen mana yang akan di-deploy dan pembaruan konfigurasi yang akan di-deploy pada setiap komponen. Anda juga dapat mengontrol bagaimana deployment mulai tersedia pada perangkat yang menjadi target deployment. Untuk informasi selengkapnya, lihat [Menyebarkan AWS IoT Greengrass komponen ke perangkat](manage-deployments.md).
Di bagian ini, Anda menerapkan komponen Hello World Anda kembali ke perangkat inti Greengrass Anda.
## Terapkan komponen Anda (konsol)
1. Pada menu navigasi [konsol AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) tersebut, pilih **Komponen**.
1. Pada halaman **Components**, pada tab **My components**, pilih **com.example.HelloWorld**.
1. Pada **com.example.HelloWorld**halaman, pilih **Deploy**.
1. **Dari **Add to deployment**, pilih **Create new deployment**, lalu pilih Next.**
1. Di halaman **Tentukan target**, lakukan hal berikut:
1. Di kotak **Nama**, masukkan**Deployment for MyGreengrassCore**.
1. Untuk **target Deployment**, pilih **Perangkat inti**, dan nama AWS IoT benda untuk perangkat inti Anda. Nilai default dalam tutorial ini adalah*MyGreengrassCore*.
1. Pilih **Berikutnya**.
1. Pada halaman **Pilih komponen**, di bawah **Komponen saya**, verifikasi bahwa **com.example.HelloWorld**komponen dipilih, dan pilih **Berikutnya**.
1. Pada halaman **Konfigurasi komponen**, pilih **com.example.HelloWorld**, dan lakukan hal berikut:
1. Pilih **Konfigurasi komponen**.
1. Di bawah **Pembaruan konfigurasi**, di **Konfigurasi untuk menggabungkan**, masukkan konfigurasi berikut.
```
{
"Message": "universe"
}
```
Pembaruan konfigurasi ini menetapkan parameter `Message` Hello World ke `universe` untuk perangkat dalam deployment ini.
1. Pilih **Konfirmasi**.
1. Pilih **Berikutnya**.
1. Pada halaman **Konfigurasikan pengaturan lanjutan**, simpan pengaturan konfigurasi default tersebut, dan pilih **Selanjutnya**.
1. Di halaman **Tinjau**, pilih **Deploy**.
1. Verifikasi bahwa deployment berhasil diselesaikan. Deployment ini dapat memakan waktu beberapa menit hingga selesai. Periksa log Hello World untuk memverifikasi perubahan. Jalankan perintah berikut pada perangkat inti Greengrass Anda.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Anda akan melihat pesan yang mirip dengan contoh berikut ini.
```
Hello, universe! Greetings from your first Greengrass component.
```
**catatan**
Jika pesan log tidak berubah, deployment gagal atau tidak mencapai perangkat inti. Hal ini dapat terjadi jika perangkat inti Anda tidak tersambung ke internet atau tidak memiliki izin untuk mengambil artefak dari bucket S3 Anda. Jalankan perintah berikut pada perangkat inti Anda untuk melihat file log perangkat lunak AWS IoT Greengrass inti. File ini mencakup log dari layanan deployment perangkat inti Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Untuk informasi selengkapnya, lihat [Pemecahan masalah AWS IoT Greengrass V2](troubleshooting.md).
## Terapkan komponen Anda ()AWS CLI
**Untuk men-deploy komponen Hello World Anda**
1. Pada komputer pengembangan Anda, buat file bernama `hello-world-deployment.json` dan salin JSON berikut ke dalam file. File ini menentukan komponen dan konfigurasi yang akan di-deploy.
```
{
"components": {
"com.example.HelloWorld": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"Message\":\"universe\"}"
}
}
}
}
```
File konfigurasi ini menentukan untuk men-deploy versi `1.0.0` komponen Hello World yang telah Anda kembangkan dan deploy dalam prosedur sebelumnya. `configurationUpdate` menentukan untuk menggabungkan konfigurasi komponen dalam string yang dikodekan JSON. Pembaruan konfigurasi ini menetapkan parameter `Message` Hello World ke `universe` untuk perangkat dalam deployment ini.
1. Jalankan perintah berikut untuk men-deploy komponen ke perangkat inti Greengrass Anda. Anda dapat men-deploy ke objek, yang merupakan perangkat individual, atau grup objek, yang merupakan grup perangkat. Ganti *MyGreengrassCore* dengan nama AWS IoT benda untuk perangkat inti Anda.
------
#### [ Linux or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--cli-input-json file://hello-world-deployment.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--cli-input-json file://hello-world-deployment.json
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--cli-input-json file://hello-world-deployment.json
```
------
Perintah ini menghasilkan respons yang mirip dengan contoh berikut.
```
{
"deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9",
"iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75",
"iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75"
}
```
1. Verifikasi bahwa deployment berhasil diselesaikan. Deployment ini dapat memakan waktu beberapa menit hingga selesai. Periksa log Hello World untuk memverifikasi perubahan. Jalankan perintah berikut pada perangkat inti Greengrass Anda.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ Windows Command Prompt (CMD) ]
```
type C:\greengrass\v2\\logs\\com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Anda akan melihat pesan yang mirip dengan contoh berikut ini.
```
Hello, universe! Greetings from your first Greengrass component.
```
**catatan**
Jika pesan log tidak berubah, deployment gagal atau tidak mencapai perangkat inti. Hal ini dapat terjadi jika perangkat inti Anda tidak tersambung ke internet atau tidak memiliki izin untuk mengambil artefak dari bucket S3 Anda. Jalankan perintah berikut pada perangkat inti Anda untuk melihat file log perangkat lunak AWS IoT Greengrass inti. File ini mencakup log dari layanan deployment perangkat inti Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
`type`Perintah menulis konten file ke terminal. Jalankan perintah ini beberapa kali untuk mengamati perubahan dalam file.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Untuk informasi selengkapnya, lihat [Pemecahan masalah AWS IoT Greengrass V2](troubleshooting.md).
# Langkah selanjutnya
Anda telah menyelesaikan tutorial ini. Perangkat lunak AWS IoT Greengrass Core dan komponen Hello World Anda berjalan di perangkat Anda. Selain itu, komponen Hello World Anda tersedia di layanan AWS IoT Greengrass cloud untuk diterapkan ke perangkat lain. Untuk informasi selengkapnya tentang topik yang dieksplorasi pada tutorial ini, lihat berikut ini:
+ [Buat AWS IoT Greengrass komponen](create-components.md)
+ [Publikasikan komponen untuk diterapkan ke perangkat inti Anda](publish-components.md)
+ [Menyebarkan AWS IoT Greengrass komponen ke perangkat](manage-deployments.md)