Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mempertahankan status perangkat saat perangkat offline dengan Device Shadows
Tutorial ini menunjukkan cara menggunakan layanan AWS IoT Device Shadow untuk menyimpan dan memperbarui informasi status perangkat. Dokumen Shadow, yang merupakan dokumen JSON, menunjukkan perubahan status perangkat berdasarkan pesan yang diterbitkan oleh perangkat, aplikasi lokal, atau layanan. Dalam tutorial ini, dokumen Shadow menunjukkan perubahan warna bola lampu. Tutorial ini juga menunjukkan bagaimana bayangan menyimpan informasi ini bahkan ketika perangkat terputus dari internet, dan meneruskan informasi status terbaru kembali ke perangkat ketika kembali online dan meminta informasi ini.
Kami menyarankan Anda mencoba tutorial ini sesuai urutan yang ditampilkan di sini, dimulai dengan AWS IoT sumber daya yang perlu Anda buat dan pengaturan perangkat keras yang diperlukan, yang juga membantu Anda mempelajari konsep secara bertahap. Tutorial ini menunjukkan cara mengkonfigurasi dan menghubungkan perangkat Raspberry Pi untuk digunakan AWS IoT. Jika Anda tidak memiliki perangkat keras yang diperlukan, Anda dapat mengikuti tutorial ini dengan mengadaptasinya ke perangkat pilihan Anda atau dengan [membuat perangkat virtual dengan Amazon EC2](creating-a-virtual-thing.md).
**Ikhtisar skenario tutorial**
Skenario untuk tutorial ini adalah aplikasi atau layanan lokal yang mengubah warna bola lampu dan yang menerbitkan datanya ke topik bayangan yang dicadangkan. Tutorial ini mirip dengan fungsi Device Shadow yang dijelaskan dalam [tutorial memulai interaktif](interactive-demo.md) dan diimplementasikan pada perangkat Raspberry Pi. Tutorial di bagian ini berfokus pada satu bayangan klasik sambil menunjukkan bagaimana Anda dapat mengakomodasi bayangan bernama atau beberapa perangkat.
Tutorial berikut akan membantu Anda mempelajari cara menggunakan layanan AWS IoT Device Shadow.
+
**[Tutorial: Mempersiapkan Raspberry Pi Anda untuk menjalankan aplikasi bayangan](create-resources-shadow.md)**
Tutorial ini menunjukkan cara mengatur perangkat Raspberry Pi untuk terhubung dengan AWS IoT. Anda juga akan membuat dokumen AWS IoT kebijakan dan sumber daya benda, mengunduh sertifikat, dan kemudian melampirkan kebijakan ke sumber daya itu. Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya.
+
**[Tutorial: Menginstal Device SDK dan menjalankan aplikasi sampel untuk Device Shadows](lightbulb-shadow-application.md)**
Tutorial ini menunjukkan cara menginstal alat yang diperlukan, perangkat lunak, dan SDK AWS IoT Perangkat untuk Python, dan kemudian menjalankan aplikasi bayangan sampel. Tutorial ini dibangun di atas konsep yang disajikan [Connect Raspberry Pi atau perangkat lain](connecting-to-existing-device.md) dan membutuhkan waktu 20 menit untuk menyelesaikannya.
+
**[Tutorial: Berinteraksi dengan Device Shadow menggunakan aplikasi sampel dan klien pengujian MQTT](interact-lights-device-shadows.md)**
Tutorial ini menunjukkan bagaimana Anda menggunakan aplikasi `shadow.py` sampel dan **AWS IoT konsol** untuk mengamati interaksi antara AWS IoT Device Shadows dan perubahan status bola lampu. Tutorial ini juga menunjukkan cara mengirim pesan MQTT ke topik yang dicadangkan Device Shadow. Tutorial ini bisa memakan waktu 45 menit untuk menyelesaikannya.
**AWS IoT Ikhtisar Device Shadow**
Device Shadow adalah representasi virtual persisten dari perangkat yang dikelola oleh [sumber daya](iot-thing-management.md) yang Anda buat di AWS IoT registri. Dokumen Shadow adalah JSON atau dokumen JavaScript notasi yang digunakan untuk menyimpan dan mengambil informasi status saat ini untuk perangkat. Anda dapat menggunakan bayangan untuk mendapatkan dan mengatur status perangkat melalui topik MQTT atau HTTP REST APIs, terlepas dari apakah perangkat terhubung ke internet.
Dokumen Shadow berisi `state` properti yang menjelaskan aspek-aspek status perangkat ini.
+ `desired`: Aplikasi menentukan status properti perangkat yang diinginkan dengan memperbarui `desired` objek.
+ `reported`: Perangkat melaporkan statusnya saat ini di `reported` objek.
+ `delta`: AWS IoT melaporkan perbedaan antara keadaan yang diinginkan dan yang dilaporkan dalam `delta` objek.
Berikut adalah contoh dokumen status Shadow.
```
{
"state": {
"desired": {
"color": "green"
},
"reported": {
"color": "blue"
},
"delta": {
"color": "green"
}
}
}
```
[Untuk memperbarui dokumen Shadow perangkat, Anda dapat menggunakan [topik MQTT yang dicadangkan](reserved-topics.md#reserved-topics-shadow), [Device Shadow REST APIs](device-shadow-rest-api.md) yang mendukung `GET``UPDATE`, dan `DELETE` operasi dengan HTTP, dan CLI.AWS IoT](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot-data/index.html)
Pada contoh sebelumnya, katakanlah Anda ingin mengubah `desired` warna menjadi`yellow`. Untuk melakukan ini, kirim permintaan ke [UpdateThingShadow](device-shadow-rest-api.md#API_UpdateThingShadow) API atau publikasikan pesan ke topik [Update](device-shadow-mqtt.md#update-pub-sub-topic),`$aws/things/THING_NAME/shadow/update`.
```
{
"state": {
"desired": {
"color": yellow
}
}
}
```
Pembaruan hanya memengaruhi bidang yang ditentukan dalam permintaan. Setelah berhasil memperbarui Device Shadow, AWS IoT menerbitkan `desired` status baru ke `delta` topik,`$aws/things/THING_NAME/shadow/delta`. Dokumen Shadow dalam hal ini terlihat seperti ini:
```
{
"state": {
"desired": {
"color": yellow
},
"reported": {
"color": green
},
"delta": {
"color": yellow
}
}
}
```
Status baru kemudian dilaporkan ke AWS IoT Device Shadow menggunakan `Update` topik `$aws/things/THING_NAME/shadow/update` dengan pesan JSON berikut:
```
{
"state": {
"reported": {
"color": yellow
}
}
}
```
Jika Anda ingin mendapatkan informasi status saat ini, kirim permintaan ke [GetThingShadow](device-shadow-rest-api.md#API_GetThingShadow) API atau publikasikan pesan MQTT ke topik [Dapatkan](device-shadow-mqtt.md#get-pub-sub-topic),. `$aws/things/THING_NAME/shadow/get`
Untuk informasi selengkapnya tentang menggunakan layanan Device Shadow, lihat[AWS IoT Layanan Device Shadow](iot-device-shadows.md).
Untuk informasi selengkapnya tentang penggunaan Device Shadows di perangkat, aplikasi, dan layanan, lihat [Menggunakan bayangan di perangkat](device-shadow-comms-device.md) dan[Menggunakan bayangan di aplikasi dan layanan](device-shadow-comms-app.md).
Untuk informasi tentang berinteraksi dengan AWS IoT bayangan, lihat[Berinteraksi dengan bayangan](device-shadow-data-flow.md).
Untuk informasi tentang topik yang dicadangkan MQTT dan HTTP REST APIs, lihat dan. [Topik MQTT Bayangan Perangkat](device-shadow-mqtt.md) [Device Shadow REST API](device-shadow-rest-api.md)
# Tutorial: Mempersiapkan Raspberry Pi Anda untuk menjalankan aplikasi bayangan
Tutorial ini menunjukkan cara mengatur dan mengkonfigurasi perangkat Raspberry Pi dan membuat AWS IoT sumber daya yang dibutuhkan perangkat untuk menghubungkan dan bertukar pesan MQTT.
**catatan**
Jika Anda berencana[Buat perangkat virtual dengan Amazon EC2](creating-a-virtual-thing.md), Anda dapat melewati halaman ini dan melanjutkan ke[Konfigurasikan perangkat Anda](configure-device.md). Anda akan membuat sumber daya ini saat Anda membuat benda virtual Anda. Jika Anda ingin menggunakan perangkat yang berbeda daripada Raspberry Pi, Anda dapat mencoba mengikuti tutorial ini dengan mengadaptasinya ke perangkat pilihan Anda.
**Dalam tutorial ini, Anda akan belajar cara:**
+ Siapkan perangkat Raspberry Pi dan konfigurasikan untuk digunakan dengan AWS IoT.
+ Buat dokumen AWS IoT kebijakan, yang mengizinkan perangkat Anda untuk berinteraksi dengan AWS IoT layanan.
+ Buat sumber daya benda AWS IoT di sertifikat perangkat X.509, lalu lampirkan dokumen kebijakan.
Masalahnya adalah representasi virtual perangkat Anda di AWS IoT registri. Sertifikat mengautentikasi perangkat Anda ke AWS IoT Core, dan dokumen kebijakan mengizinkan perangkat Anda untuk berinteraksi. AWS IoT
**Cara menjalankan tutorial ini**
Untuk menjalankan aplikasi `shadow.py` sampel untuk Device Shadows, Anda memerlukan perangkat Raspberry Pi yang terhubung ke AWS IoT. Kami menyarankan Anda mengikuti tutorial ini dalam urutan yang disajikan di sini, dimulai dengan menyiapkan Raspberry Pi dan aksesorisnya, dan kemudian membuat kebijakan dan melampirkan kebijakan ke sumber daya yang Anda buat. Anda kemudian dapat mengikuti tutorial ini dengan menggunakan antarmuka pengguna grafis (GUI) yang didukung oleh Raspberry Pi untuk membuka AWS IoT konsol di browser web perangkat, yang juga membuatnya lebih mudah untuk mengunduh sertifikat langsung ke Raspberry Pi Anda untuk terhubung ke AWS IoT.
**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ Sebuah Akun AWS. Jika Anda tidak memilikinya, selesaikan langkah-langkah yang dijelaskan [Mengatur Akun AWS](setting-up.md) sebelum Anda melanjutkan. Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini.
+ Raspberry Pi dan aksesori yang diperlukan. Anda akan membutuhkan:
+ [Raspberry Pi 3 Model B](https://www.raspberrypi.com/products/) atau model yang lebih baru. Tutorial ini mungkin berfungsi pada versi Raspberry Pi sebelumnya, tetapi kami belum mengujinya.
+ [Raspberry Pi OS (32-bit)](https://www.raspberrypi.com/software/operating-systems/) atau yang lebih baru. Kami merekomendasikan menggunakan versi terbaru dari Raspberry Pi OS. Versi OS sebelumnya mungkin berfungsi, tetapi kami belum mengujinya.
+ Koneksi Ethernet atau Wi-Fi.
+ Keyboard, mouse, monitor, kabel, dan catu daya.
Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya.
## Langkah 1: Siapkan dan konfigurasikan perangkat Raspberry Pi
Di bagian ini, kita akan mengkonfigurasi perangkat Raspberry Pi untuk digunakan dengan AWS IoT.
**penting**
Menyesuaikan instruksi ini ke perangkat dan sistem operasi lain dapat menjadi tantangan. Anda harus memahami perangkat Anda dengan cukup baik untuk dapat menafsirkan instruksi ini dan menerapkannya ke perangkat Anda. Jika Anda mengalami kesulitan, Anda dapat mencoba salah satu opsi perangkat lain sebagai alternatif, seperti [Buat perangkat virtual dengan Amazon EC2](creating-a-virtual-thing.md) atau[Gunakan Windows atau Linux PC atau Mac Anda sebagai AWS IoT perangkat](using-laptop-as-device.md).
Anda harus mengkonfigurasi Raspberry Pi Anda sehingga dapat memulai sistem operasi (OS), terhubung ke internet, dan memungkinkan Anda untuk berinteraksi dengannya di antarmuka baris perintah. Anda juga dapat menggunakan antarmuka pengguna grafis (GUI) yang didukung dengan Raspberry Pi untuk membuka AWS IoT konsol dan menjalankan sisa tutorial ini.
**Untuk mengatur Raspberry Pi**
1. Masukkan kartu SD ke dalam slot kartu microSD pada Raspberry Pi. Beberapa kartu SD sudah dimuat sebelumnya dengan manajer instalasi yang meminta Anda dengan menu untuk menginstal OS setelah mem-boot papan. Anda juga dapat menggunakan imager Raspberry Pi untuk menginstal OS pada kartu Anda.
1. Hubungkan TV HDMI atau monitor ke kabel HDMI yang terhubung ke port HDMI Raspberry Pi.
1. Hubungkan keyboard dan mouse ke port USB Raspberry Pi dan kemudian colokkan adaptor daya untuk mem-boot papan.
Setelah Raspberry Pi boot, jika kartu SD sudah dimuat sebelumnya dengan manajer instalasi, sebuah menu muncul untuk menginstal sistem operasi. Jika Anda kesulitan menginstal OS, Anda dapat mencoba langkah-langkah berikut. Untuk informasi lebih lanjut tentang pengaturan Raspberry Pi, lihat [Menyiapkan Raspberry Pi Anda](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/).
**Jika Anda mengalami kesulitan mengatur Raspberry Pi:**
+ Periksa apakah Anda memasukkan kartu SD sebelum mem-boot papan. Jika Anda mencolokkan kartu SD setelah mem-boot papan, menu instalasi mungkin tidak muncul.
+ Pastikan TV atau monitor dihidupkan dan input yang benar dipilih.
+ Pastikan Anda menggunakan perangkat lunak yang kompatibel dengan Raspberry Pi.
Setelah Anda menginstal dan mengkonfigurasi OS Raspberry Pi, buka browser web Raspberry Pi dan arahkan ke AWS IoT Core konsol untuk melanjutkan langkah-langkah lainnya dalam tutorial ini.
Jika Anda dapat membuka AWS IoT Core konsol, Anda Raspberry Pi sudah siap dan Anda dapat melanjutkan[Tutorial: Menyediakan perangkat Anda di AWS IoT](shadow-provision-cloud.md).
Jika Anda mengalami masalah atau membutuhkan bantuan tambahan, lihat [Mendapatkan bantuan untuk Raspberry Pi Anda](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/5).
# Tutorial: Menyediakan perangkat Anda di AWS IoT
Bagian ini menciptakan AWS IoT Core sumber daya yang akan digunakan tutorial Anda.
**Topics**
+ [Langkah 1: Buat AWS IoT kebijakan untuk Device Shadow](#create-policy-shadow)
+ [Langkah 2: Buat sumber daya benda dan lampirkan kebijakan ke benda itu](#create-thing-shadow)
+ [Langkah 3: Tinjau hasil dan langkah selanjutnya](#resources-shadow-review)
## Langkah 1: Buat AWS IoT kebijakan untuk Device Shadow
Sertifikat X.509 mengautentikasi perangkat Anda dengan. AWS IoT Core AWS IoT kebijakan dilampirkan pada sertifikat yang mengizinkan perangkat untuk melakukan AWS IoT operasi, seperti berlangganan atau menerbitkan topik cadangan MQTT yang digunakan oleh layanan Device Shadow. Perangkat Anda menampilkan sertifikatnya saat terhubung dan mengirim pesan ke AWS IoT Core.
Dalam prosedur ini, Anda akan membuat kebijakan yang memungkinkan perangkat Anda melakukan AWS IoT operasi yang diperlukan untuk menjalankan program contoh. Kami menyarankan Anda membuat kebijakan yang hanya memberikan izin yang diperlukan untuk melakukan tugas. Anda membuat AWS IoT kebijakan terlebih dahulu, lalu melampirkannya ke sertifikat perangkat yang akan Anda buat nanti.
**Untuk membuat AWS IoT kebijakan**
1. Di menu sebelah kiri, pilih **Aman**, lalu pilih **Kebijakan**. Jika akun Anda memiliki kebijakan yang ada, pilih **Buat**, jika **tidak, pada halaman Anda belum memiliki kebijakan**, pilih **Buat kebijakan**.
1. Pada halaman **Buat kebijakan**:
1. Masukkan nama untuk kebijakan di bidang **Nama** (misalnya,**My\$1Device\$1Shadow\$1policy**). Jangan gunakan informasi identitas pribadi dalam nama kebijakan Anda.
1. Dalam dokumen kebijakan, Anda menjelaskan tindakan menghubungkan, berlangganan, menerima, dan memublikasikan yang memberikan izin perangkat untuk mempublikasikan dan berlangganan topik yang dicadangkan MQTT.
Salin contoh kebijakan berikut dan tempel di dokumen kebijakan Anda. Ganti `thingname` dengan nama benda yang akan Anda buat (misalnya,`My_light_bulb`), `region` dengan AWS IoT Wilayah tempat Anda menggunakan layanan, dan `account` dengan Akun AWS nomor Anda. Untuk informasi selengkapnya tentang AWS IoT kebijakan, lihat[AWS IoT Core kebijakan](iot-policies.md).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/test-*"
}
]
}
```
## Langkah 2: Buat sumber daya benda dan lampirkan kebijakan ke benda itu
Perangkat yang terhubung AWS IoT dapat diwakili oleh *sumber daya benda* dalam AWS IoT registri. *Sumber daya sesuatu* mewakili perangkat tertentu atau entitas logis, seperti bola lampu dalam tutorial ini.
Untuk mempelajari cara membuat sesuatu AWS IoT, ikuti langkah-langkah yang dijelaskan di[Buat objek benda](create-iot-resources.md#create-aws-thing). Berikut adalah beberapa hal penting yang perlu diperhatikan saat Anda mengikuti langkah-langkah dalam tutorial itu:
1. Pilih **Buat satu hal**, dan di bidang **Nama**, masukkan nama untuk hal yang sama dengan `thingname` (misalnya,`My_light_bulb`) yang Anda tentukan saat membuat kebijakan sebelumnya.
Anda tidak dapat mengubah nama setelah dibuat. Jika Anda memberinya nama yang berbeda selain`thingname`, buat hal baru dengan nama sebagai `thingname` dan hapus yang lama.
**catatan**
Jangan gunakan informasi yang dapat diidentifikasi secara pribadi dalam nama barang Anda. Nama benda dapat muncul dalam komunikasi dan laporan yang tidak terenkripsi.
1. Kami menyarankan Anda mengunduh setiap file sertifikat pada **Sertifikat yang dibuat\$1** halaman ke lokasi di mana Anda dapat dengan mudah menemukannya. Anda harus menginstal file-file ini untuk menjalankan aplikasi sampel.
Kami menyarankan Anda mengunduh file ke `certs` subdirektori di `home` direktori Anda di Raspberry Pi dan beri nama masing-masing dengan nama yang lebih sederhana seperti yang disarankan dalam tabel berikut.
**Nama berkas sertifikat**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/shadow-provision-cloud.html)
1. Setelah Anda mengaktifkan sertifikat untuk mengaktifkan koneksi AWS IoT, pilih **Lampirkan kebijakan** dan pastikan Anda melampirkan kebijakan yang Anda buat sebelumnya (misalnya,**My\$1Device\$1Shadow\$1policy**) ke benda tersebut.
Setelah Anda membuat sesuatu, Anda dapat melihat sumber daya benda Anda ditampilkan dalam daftar hal-hal di AWS IoT konsol.
## Langkah 3: Tinjau hasil dan langkah selanjutnya
**Dalam tutorial ini, Anda belajar cara:**
+ Siapkan dan konfigurasikan perangkat Raspberry Pi.
+ Buat dokumen AWS IoT kebijakan yang mengizinkan perangkat Anda untuk berinteraksi dengan AWS IoT layanan.
+ Buat sumber daya benda dan sertifikat perangkat X.509 terkait, dan lampirkan dokumen kebijakan ke dalamnya.
**Langkah selanjutnya**
Anda sekarang dapat menginstal SDK AWS IoT perangkat untuk Python, menjalankan `shadow.py` aplikasi sampel, dan menggunakan Device Shadows untuk mengontrol status. Untuk informasi lebih lanjut tentang cara menjalankan tutorial ini, lihat[Tutorial: Menginstal Device SDK dan menjalankan aplikasi sampel untuk Device Shadows](lightbulb-shadow-application.md).
# Tutorial: Menginstal Device SDK dan menjalankan aplikasi sampel untuk Device Shadows
Bagian ini menunjukkan bagaimana Anda dapat menginstal perangkat lunak yang diperlukan dan AWS IoT Device SDK untuk Python dan menjalankan `shadow.py` aplikasi sampel untuk mengedit dokumen Shadow dan mengontrol status bayangan.
**Dalam tutorial ini, Anda akan belajar cara:**
+ Gunakan perangkat lunak yang diinstal dan AWS IoT Device SDK untuk Python untuk menjalankan aplikasi sampel.
+ Pelajari cara memasukkan nilai menggunakan aplikasi sampel akan menerbitkan nilai yang diinginkan di AWS IoT konsol.
+ Tinjau aplikasi `shadow.py` sampel dan cara menggunakan protokol MQTT untuk memperbarui status bayangan.
**Sebelum Anda menjalankan tutorial ini:**
Anda harus menyiapkan Akun AWS, mengonfigurasi perangkat Raspberry Pi Anda, dan membuat AWS IoT hal dan kebijakan yang memberikan izin perangkat untuk mempublikasikan dan berlangganan topik yang dicadangkan MQTT dari layanan Device Shadow. Untuk informasi selengkapnya, lihat [Tutorial: Mempersiapkan Raspberry Pi Anda untuk menjalankan aplikasi bayangan](create-resources-shadow.md).
Anda juga harus menginstal Git, Python, dan AWS IoT Device SDK untuk Python. Tutorial ini dibangun di atas konsep yang disajikan dalam tutorial[Connect Raspberry Pi atau perangkat lain](connecting-to-existing-device.md). Jika Anda belum mencoba tutorial itu, kami sarankan Anda mengikuti langkah-langkah yang dijelaskan dalam tutorial itu untuk menginstal file sertifikat dan Device SDK dan kemudian kembali ke tutorial ini untuk menjalankan aplikasi `shadow.py` sampel.
**Topics**
+ [Langkah 1: Jalankan aplikasi sampel shadow.py](#run-sample-application-shadows)
+ [Langkah 2: Tinjau aplikasi contoh SDK Perangkat shadow.py](#review-shadow-sample-code)
+ [Langkah 3: Memecahkan masalah dengan aplikasi sampel `shadow.py`](#shadow-sample-app-troubleshoot)
+ [Langkah 4: Tinjau hasil dan langkah selanjutnya](#sample-app-shadow-review)
Tutorial ini membutuhkan waktu sekitar 20 menit untuk menyelesaikannya.
## Langkah 1: Jalankan aplikasi sampel shadow.py
Sebelum menjalankan aplikasi `shadow.py` sampel, Anda memerlukan informasi berikut selain nama dan lokasi file sertifikat yang Anda instal.
**Nilai parameter aplikasi**
| Parameter | Di mana menemukan nilainya |
| --- | --- |
| your-iot-thing-name | Nama AWS IoT benda yang Anda buat sebelumnya[Langkah 2: Buat sumber daya benda dan lampirkan kebijakan ke benda itu](shadow-provision-cloud.md#create-thing-shadow). Untuk menemukan nilai ini, di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), pilih **Kelola**, lalu pilih **Things**. |
| your-iot-endpoint | *your-iot-endpoint*Nilai memiliki format:`endpoint_id-ats.iot.region.amazonaws.com`, misalnya,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`. Untuk menemukan nilai ini: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/lightbulb-shadow-application.html) |
**Instal dan jalankan aplikasi sampel**
1. Arahkan ke direktori aplikasi contoh.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
```
1. Di jendela baris perintah, ganti *your-iot-endpoint* dan *your-iot-thing-name* seperti yang ditunjukkan dan jalankan perintah ini.
```
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
1. Perhatikan bahwa aplikasi sampel:
1. Terhubung ke layanan AWS IoT untuk akun Anda.
1. Berlangganan `Delta` acara dan `Update` dan `Get` tanggapan.
1. Meminta Anda untuk memasukkan nilai yang diinginkan di terminal.
1. Menampilkan output yang mirip dengan berikut ini:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow contains reported value 'off'.
Enter desired value:
```
**catatan**
Jika Anda mengalami masalah dalam menjalankan aplikasi `shadow.py` sampel, tinjau[Langkah 3: Memecahkan masalah dengan aplikasi sampel `shadow.py`](#shadow-sample-app-troubleshoot). Untuk mendapatkan informasi tambahan yang mungkin membantu Anda memperbaiki masalah, tambahkan `--verbosity debug` parameter ke baris perintah sehingga aplikasi sampel menampilkan pesan terperinci tentang apa yang dilakukannya.
**Masukkan nilai dan amati pembaruan dalam dokumen Shadow**
Anda dapat memasukkan nilai di terminal untuk menentukan `desired` nilai, yang juga memperbarui `reported` nilai. Katakanlah Anda memasukkan warna `yellow` di terminal. `reported`Nilai juga diperbarui ke warna`yellow`. Berikut ini menunjukkan pesan yang ditampilkan di terminal:
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Saat Anda mempublikasikan permintaan pembaruan ini, AWS IoT buat bayangan klasik default untuk sumber daya benda. Anda dapat mengamati permintaan pembaruan yang Anda terbitkan ke `reported` dan `desired` nilai di AWS IoT konsol dengan melihat dokumen Shadow untuk sumber daya benda yang Anda buat (misalnya,`My_light_bulb`). Untuk melihat pembaruan dalam dokumen Shadow:
1. Di AWS IoT konsol, pilih **Kelola** dan kemudian pilih **Things**.
1. Dalam daftar hal-hal yang ditampilkan, pilih hal yang Anda buat, pilih **Shadows**, dan kemudian pilih **Classic Shadow**.
Dokumen Shadow akan terlihat mirip dengan berikut ini, menunjukkan `reported` dan `desired` nilai yang disetel ke warna`yellow`. Anda melihat nilai-nilai ini di bagian **Shadow state** dari dokumen.
```
{
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
}
```
Anda juga melihat bagian **Metadata** yang berisi informasi stempel waktu dan nomor versi permintaan.
Anda dapat menggunakan versi dokumen negara untuk memastikan Anda memperbarui versi terbaru dari dokumen Shadow perangkat. Jika Anda mengirim permintaan pembaruan lain, nomor versi bertambah sebesar 1. Saat Anda menyediakan versi dengan permintaan pembaruan, layanan menolak permintaan dengan kode respons konflik HTTP 409 jika versi dokumen status saat ini tidak cocok dengan versi yang disediakan.
```
{
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
}
},
"version": 10
}
```
Untuk mempelajari lebih lanjut tentang dokumen Shadow dan mengamati perubahan pada informasi negara, lanjutkan ke tutorial berikutnya [Tutorial: Berinteraksi dengan Device Shadow menggunakan aplikasi sampel dan klien pengujian MQTT](interact-lights-device-shadows.md) seperti yang dijelaskan di [Langkah 4: Tinjau hasil dan langkah selanjutnya](#sample-app-shadow-review) bagian tutorial ini. Secara opsional, Anda juga dapat mempelajari tentang kode `shadow.py` sampel dan cara menggunakan protokol MQTT di bagian berikut.
## Langkah 2: Tinjau aplikasi contoh SDK Perangkat shadow.py
Bagian ini mengulas `shadow.py` contoh aplikasi dari **AWS IoT Device SDK v2 untuk Python** yang digunakan dalam tutorial ini. Di sini, kita akan meninjau bagaimana terhubung AWS IoT Core dengan menggunakan MQTT dan MQTT melalui protokol WSS. Pustaka [runtime AWS umum (AWS-CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) menyediakan dukungan protokol komunikasi tingkat rendah dan disertakan dengan AWS IoT Device SDK v2 untuk Python.
Sementara tutorial ini menggunakan MQTT dan MQTT melalui WSS, AWS IoT mendukung perangkat yang menerbitkan permintaan HTTPS. Untuk contoh program Python yang mengirim pesan HTTP dari perangkat, lihat [contoh kode HTTPS menggunakan pustaka](http.md#codeexample) Python. `requests`
Untuk informasi tentang bagaimana Anda dapat membuat keputusan berdasarkan informasi tentang protokol mana yang akan digunakan untuk komunikasi perangkat Anda, tinjau[Memilih protokol aplikasi untuk komunikasi perangkat Anda](protocols.md#protocol-selection).
**MQTT**
`shadow.py`Contoh panggilan `mtls_from_path` (ditampilkan di sini) di [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)untuk membuat koneksi dengan AWS IoT Core dengan menggunakan protokol MQTT. `mtls_from_path`menggunakan sertifikat X.509 dan TLS v1.2 untuk mengautentikasi perangkat. Pustaka AWS-CRT menangani detail tingkat yang lebih rendah dari koneksi itu.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
+ `endpoint`adalah AWS IoT titik akhir Anda yang Anda lewatkan dari baris perintah dan `client_id` merupakan ID yang secara unik mengidentifikasi perangkat ini di. Wilayah AWS
+ `cert_filepath`,`pri_key_filepath`, dan `ca_filepath` merupakan jalur ke sertifikat perangkat dan file kunci pribadi, dan file CA root.
+ `client_bootstrap`adalah objek runtime umum yang menangani aktivitas komunikasi soket, dan dipakai sebelum panggilan ke. `mqtt_connection_builder.mtls_from_path`
+ `on_connection_interrupted`dan `on_connection_resumed` merupakan fungsi panggilan balik untuk memanggil ketika koneksi perangkat terputus dan dilanjutkan.
+ `clean_session`adalah apakah akan memulai sesi baru yang persisten, atau jika ada, sambungkan kembali ke yang sudah ada. `keep_alive_secs`adalah nilai keep alive, dalam hitungan detik, untuk mengirim `CONNECT` permintaan. Ping akan secara otomatis dikirim pada interval ini. Server mengasumsikan bahwa koneksi terputus jika tidak menerima ping setelah 1,5 kali nilai ini.
`shadow.py`Sampel juga memanggil `websockets_with_default_aws_signing` [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)untuk membuat koneksi dengan AWS IoT Core menggunakan protokol MQTT melalui WSS. MQTT melalui WSS juga menggunakan parameter yang sama seperti MQTT dan mengambil parameter tambahan ini:
+ `region`adalah Wilayah AWS penandatanganan yang digunakan oleh otentikasi Signature V4, dan `credentials_provider` merupakan AWS kredensyal yang disediakan untuk digunakan untuk otentikasi. Region dilewatkan dari baris perintah, dan `credentials_provider` objek dipakai sesaat sebelum panggilan ke. `mqtt_connection_builder.websockets_with_default_aws_signing`
+ `websocket_proxy_options`adalah opsi proxy HTTP, jika menggunakan host proxy. Dalam aplikasi `shadow.py` sampel, nilai ini dipakai sesaat sebelum panggilan ke. `mqtt_connection_builder.websockets_with_default_aws_signing`
**Berlangganan topik dan acara Shadow**
`shadow.py`Sampel mencoba untuk membuat koneksi dan menunggu untuk terhubung sepenuhnya. Jika tidak terhubung, perintah akan diantrian. Setelah terhubung, sampel berlangganan acara delta dan memperbarui dan mendapatkan pesan, dan menerbitkan pesan dengan tingkat Quality of Service (QoS) 1 (). `mqtt.QoS.AT_LEAST_ONCE`
Saat perangkat berlangganan pesan dengan QoS level 1, broker pesan menyimpan pesan yang dilanggani perangkat hingga dapat dikirim ke perangkat. Broker pesan mengirim ulang pesan hingga menerima `PUBACK` respons dari perangkat.
Untuk informasi lebih lanjut tentang protokol MQTT, lihat dan. [Tinjau protokol MQTT](sdk-tutorials.md#sdk-tutorials-mqtt-review) [MQTT](mqtt.md)
Untuk informasi lebih lanjut tentang bagaimana MQTT, MQTT melalui WSS, sesi persisten, dan level QoS yang digunakan dalam tutorial ini, lihat. [Tinjau aplikasi contoh SDK Perangkat pubsub.py](sdk-tutorials.md#sdk-tutorials-explore-sample)
## Langkah 3: Memecahkan masalah dengan aplikasi sampel `shadow.py`
Saat menjalankan aplikasi `shadow.py` sampel, Anda akan melihat beberapa pesan ditampilkan di terminal dan prompt untuk memasukkan `desired` nilai. Jika program melempar kesalahan, maka untuk men-debug kesalahan, Anda dapat mulai dengan memeriksa apakah Anda menjalankan perintah yang benar untuk sistem Anda.
Dalam beberapa kasus, pesan kesalahan mungkin menunjukkan masalah koneksi dan terlihat mirip dengan: `Host name was invalid for dns resolution` atau`Connection was closed unexpectedly`. Dalam kasus seperti itu, berikut adalah beberapa hal yang dapat Anda periksa:
+
**Periksa alamat titik akhir dalam perintah**
Tinjau `endpoint` argumen dalam perintah yang Anda masukkan untuk menjalankan aplikasi sampel, (misalnya,`a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com`) dan periksa nilai ini di **AWS IoT konsol**.
Untuk memeriksa apakah Anda menggunakan nilai yang benar:
1. Di **AWS IoT konsol**, pilih **Kelola** dan kemudian pilih **Things**.
1. **Pilih hal yang Anda buat untuk aplikasi sampel Anda (misalnya, **my\$1light\$1bulb**) dan kemudian pilih Interact.**
Pada halaman detail hal, titik akhir Anda ditampilkan di bagian **HTTPS**. Anda juga harus melihat pesan yang mengatakan: `This thing already appears to be connected.`
+
**Periksa aktivasi sertifikat**
Sertifikat mengautentikasi perangkat Anda dengan AWS IoT Core.
Untuk memeriksa apakah sertifikat Anda aktif:
1. Di **AWS IoT konsol**, pilih **Kelola** dan kemudian pilih **Things**.
1. **Pilih hal yang Anda buat untuk aplikasi sampel Anda (misalnya, **my\$1light\$1bulb**) dan kemudian pilih Keamanan.**
1. Pilih sertifikat dan kemudian, dari halaman detail sertifikat, pilih Pilih sertifikat dan kemudian, dari halaman detail sertifikat, pilih **Tindakan**.
Jika dalam daftar tarik-turun **Aktifkan** tidak tersedia dan Anda hanya dapat memilih **Nonaktifkan**, sertifikat Anda aktif. Jika tidak, pilih **Aktifkan** dan jalankan kembali program sampel.
Jika program masih tidak berjalan, periksa nama file sertifikat di `certs` folder.
+
**Periksa kebijakan yang dilampirkan pada sumber daya benda**
Sementara sertifikat mengautentikasi perangkat Anda, AWS IoT kebijakan mengizinkan perangkat untuk melakukan AWS IoT operasi, seperti berlangganan atau memublikasikan topik yang dicadangkan MQTT.
Untuk memeriksa apakah kebijakan yang benar terlampir:
1. Temukan sertifikat seperti yang dijelaskan sebelumnya, lalu pilih **Kebijakan**.
1. Pilih kebijakan yang ditampilkan dan periksa apakah kebijakan tersebut menjelaskan`connect`,, `subscribe``receive`, dan `publish` tindakan yang memberikan izin perangkat untuk mempublikasikan dan berlangganan topik yang dicadangkan MQTT.
Untuk kebijakan sampel, lihat[Langkah 1: Buat AWS IoT kebijakan untuk Device Shadow](shadow-provision-cloud.md#create-policy-shadow).
Jika Anda melihat pesan galat yang menunjukkan masalah saat terhubung AWS IoT, itu mungkin karena izin yang Anda gunakan untuk kebijakan tersebut. Jika demikian, kami sarankan Anda memulai dengan kebijakan yang menyediakan akses penuh ke AWS IoT sumber daya dan kemudian menjalankan kembali program sampel. Anda dapat mengedit kebijakan saat ini, atau memilih kebijakan saat ini, pilih **Lepaskan**, lalu buat kebijakan lain yang menyediakan akses penuh dan melampirkannya ke sumber daya Anda. Anda nantinya dapat membatasi kebijakan hanya pada tindakan dan kebijakan yang Anda perlukan untuk menjalankan program.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
```
+
**Periksa penginstalan SDK Perangkat**
Jika program masih tidak berjalan, Anda dapat menginstal ulang Device SDK untuk memastikan bahwa instalasi SDK Anda selesai dan benar.
## Langkah 4: Tinjau hasil dan langkah selanjutnya
**Dalam tutorial ini, Anda belajar cara:**
+ Instal perangkat lunak, alat, dan AWS IoT Device SDK yang diperlukan untuk Python.
+ Pahami bagaimana aplikasi sampel,`shadow.py`, menggunakan protokol MQTT untuk mengambil dan memperbarui status bayangan saat ini.
+ Jalankan aplikasi sampel untuk Device Shadows dan amati pembaruan ke dokumen Shadow di AWS IoT konsol. Anda juga belajar memecahkan masalah apa pun dan memperbaiki kesalahan saat menjalankan program.
**Langkah selanjutnya**
Anda sekarang dapat menjalankan aplikasi `shadow.py` sampel dan menggunakan Device Shadows untuk mengontrol status. Anda dapat mengamati pembaruan pada dokumen Shadow di AWS IoT Konsol dan mengamati peristiwa delta yang merespons aplikasi sampel. Dengan menggunakan klien pengujian MQTT, Anda dapat berlangganan topik bayangan yang dipesan dan mengamati pesan yang diterima oleh topik saat menjalankan program sampel. Untuk informasi lebih lanjut tentang cara menjalankan tutorial ini, lihat[Tutorial: Berinteraksi dengan Device Shadow menggunakan aplikasi sampel dan klien pengujian MQTT](interact-lights-device-shadows.md).
# Tutorial: Berinteraksi dengan Device Shadow menggunakan aplikasi sampel dan klien pengujian MQTT
Untuk berinteraksi dengan aplikasi `shadow.py` sampel, masukkan nilai di terminal untuk `desired` nilai tersebut. Misalnya, Anda dapat menentukan warna yang menyerupai lampu lalu lintas dan AWS IoT merespons permintaan dan memperbarui nilai yang dilaporkan.
**Dalam tutorial ini, Anda akan belajar cara:**
+ Gunakan aplikasi `shadow.py` sampel untuk menentukan status yang diinginkan dan memperbarui status bayangan saat ini.
+ Edit dokumen Shadow untuk mengamati peristiwa delta dan bagaimana aplikasi `shadow.py` sampel meresponsnya.
+ Gunakan klien pengujian MQTT untuk berlangganan topik bayangan dan mengamati pembaruan saat Anda menjalankan program sampel.
**Sebelum Anda menjalankan tutorial ini, Anda harus memiliki:**
Siapkan Akun AWS, konfigurasikan perangkat Raspberry Pi Anda, dan buat AWS IoT sesuatu dan kebijakan. Anda juga harus menginstal perangkat lunak yang diperlukan, SDK Perangkat, file sertifikat, dan menjalankan program sampel di terminal. Untuk informasi lebih lanjut, lihat tutorial sebelumnya [Tutorial: Mempersiapkan Raspberry Pi Anda untuk menjalankan aplikasi bayangan](create-resources-shadow.md) dan[Langkah 1: Jalankan aplikasi sampel shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows). Anda harus menyelesaikan tutorial ini jika Anda belum melakukannya.
**Topics**
+ [Langkah 1: Perbarui nilai yang diinginkan dan dilaporkan menggunakan aplikasi `shadow.py` sampel](#update-desired-shadow-sample)
+ [Langkah 2: Lihat pesan dari aplikasi `shadow.py` sampel di klien pengujian MQTT](#shadow-sample-view-msg)
+ [Langkah 3: Memecahkan masalah kesalahan dengan interaksi Device Shadow](#shadow-observe-messages-troubleshoot)
+ [Langkah 4: Tinjau hasil dan langkah selanjutnya](#sample-shadow-review)
Tutorial ini membutuhkan waktu sekitar 45 menit untuk menyelesaikannya.
## Langkah 1: Perbarui nilai yang diinginkan dan dilaporkan menggunakan aplikasi `shadow.py` sampel
Dalam tutorial sebelumnya[Langkah 1: Jalankan aplikasi sampel shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows), Anda belajar cara mengamati pesan yang dipublikasikan ke dokumen Shadow di AWS IoT konsol saat Anda memasukkan nilai yang diinginkan seperti yang dijelaskan di bagian[Tutorial: Menginstal Device SDK dan menjalankan aplikasi sampel untuk Device Shadows](lightbulb-shadow-application.md).
Pada contoh sebelumnya, kami mengatur warna yang diinginkan ke`yellow`. Setelah Anda memasukkan setiap nilai, terminal meminta Anda untuk memasukkan `desired` nilai lain. Jika Anda memasukkan nilai (`yellow`) yang sama lagi, aplikasi akan mengenali ini dan meminta Anda untuk memasukkan nilai baru`desired`.
```
Enter desired value:
yellow
Local value is already 'yellow'.
Enter desired value:
```
Sekarang, katakan bahwa Anda memasukkan warna`green`. AWS IoT menanggapi permintaan dan memperbarui `reported` nilainya. `green` Ini adalah bagaimana pembaruan terjadi ketika `desired` status berbeda dari `reported` status, menyebabkan delta.
**Cara aplikasi `shadow.py` sampel mensimulasikan interaksi Device Shadow:**
1. Masukkan `desired` nilai (katakanlah`yellow`) di terminal untuk mempublikasikan status yang diinginkan.
1. Karena `desired` statusnya berbeda dari `reported` status (katakanlah warnanya`green`), delta terjadi, dan aplikasi yang berlangganan delta menerima pesan ini.
1. Aplikasi merespons pesan dan memperbarui statusnya ke `desired` nilainya,`yellow`.
1. Aplikasi kemudian menerbitkan pesan pembaruan dengan nilai status perangkat yang dilaporkan baru,`yellow`.
Berikut ini menunjukkan pesan yang ditampilkan di terminal yang menunjukkan bagaimana permintaan pembaruan diterbitkan.
```
Enter desired value:
green
Changed local shadow value to 'green'.
Updating reported shadow value to 'green'...
Update request published.
Finished updating reported shadow value to 'green'.
```
Di AWS IoT konsol, dokumen Shadow mencerminkan nilai yang diperbarui `green` untuk kedua `desired` bidang `reported` dan, dan nomor versi bertambah 1. Misalnya, jika nomor versi sebelumnya ditampilkan sebagai 10, nomor versi saat ini akan ditampilkan sebagai 11.
**catatan**
Menghapus bayangan tidak mengatur ulang nomor versi ke 0. Anda akan melihat bahwa versi bayangan bertambah 1 saat Anda mempublikasikan permintaan pembaruan atau membuat bayangan lain dengan nama yang sama.
**Edit dokumen Shadow untuk mengamati peristiwa delta**
Aplikasi `shadow.py` sampel juga berlangganan `delta` acara, dan merespons ketika ada perubahan pada `desired` nilai. Misalnya, Anda dapat mengubah `desired` nilai menjadi warna`red`. Untuk melakukan ini, di AWS IoT konsol, edit dokumen Shadow dengan mengklik **Edit** dan kemudian atur `desired` nilainya `red` di JSON, sambil mempertahankan `reported` nilainya. `green` Sebelum Anda menyimpan perubahan, biarkan terminal pada Raspberry Pi terbuka karena Anda akan melihat pesan ditampilkan di terminal ketika perubahan terjadi.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Setelah Anda menyimpan nilai baru, aplikasi `shadow.py` sampel merespons perubahan ini dan menampilkan pesan di terminal yang menunjukkan delta. Anda kemudian akan melihat pesan berikut muncul di bawah prompt untuk memasukkan `desired` nilai.
```
Enter desired value:
Received shadow delta event.
Delta reports that desired value is 'red'. Changing local value...
Changed local shadow value to 'red'.
Updating reported shadow value to 'red'...
Finished updating reported shadow value to 'red'.
Enter desired value:
Update request published.
Finished updating reported shadow value to 'red'.
```
## Langkah 2: Lihat pesan dari aplikasi `shadow.py` sampel di klien pengujian MQTT
Anda dapat menggunakan **klien pengujian MQTT** di **AWS IoT konsol** untuk memantau pesan MQTT yang diteruskan di konsol Anda. Akun AWS Dengan berlangganan topik MQTT cadangan yang digunakan oleh layanan Device Shadow, Anda dapat mengamati pesan yang diterima oleh topik saat menjalankan aplikasi sampel.
Jika Anda belum menggunakan klien pengujian MQTT, Anda dapat meninjau. [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md) Ini membantu Anda mempelajari cara menggunakan **klien pengujian MQTT** di **AWS IoT konsol** untuk melihat pesan MQTT saat mereka melewati broker pesan.
1.
**Buka klien uji MQTT**
Buka [klien pengujian MQTT di AWS IoT konsol di](https://console.aws.amazon.com//iot/home#/test) jendela baru sehingga Anda dapat mengamati pesan yang diterima oleh topik MQTT tanpa kehilangan konfigurasi klien pengujian MQTT Anda. Klien pengujian MQTT tidak menyimpan langganan atau log pesan apa pun jika Anda membiarkannya masuk ke halaman lain di konsol. Untuk bagian tutorial ini, Anda dapat memiliki dokumen Shadow dari AWS IoT barang Anda dan klien pengujian MQTT terbuka di jendela terpisah untuk lebih mudah mengamati interaksi dengan Device Shadows.
1.
**Berlangganan topik Shadow yang dipesan MQTT**
Anda dapat menggunakan klien pengujian MQTT untuk memasukkan nama topik yang dicadangkan MQTT Device Shadow dan berlangganan untuk menerima pembaruan saat menjalankan aplikasi sampel. `shadow.py` Untuk berlangganan topik:
1. Di **klien pengujian MQTT** di **AWS IoT konsol**, pilih **Berlangganan topik**.
1. Di bagian **filter Topik**, masukkan: **\$1aws/things/ /shadow/update/ \$1 *thingname***. Di sini, `thingname` adalah nama sumber daya benda yang Anda buat sebelumnya (misalnya,`My_light_bulb`).
1. Simpan nilai default untuk pengaturan konfigurasi tambahan, lalu pilih **Berlangganan**.
Dengan menggunakan wildcard **\$1** dalam langganan topik, Anda dapat berlangganan beberapa topik MQTT secara bersamaan dan mengamati semua pesan yang dipertukarkan antara perangkat dan Bayangannya dalam satu jendela. Untuk informasi selengkapnya tentang karakter wildcard dan penggunaannya, lihat[Topik MQTT](topics.md).
1.
**Jalankan program `shadow.py` sampel dan amati pesan**
**Di jendela baris perintah Raspberry Pi Anda, jika Anda telah memutus program, jalankan aplikasi sampel lagi dan tonton pesan di **klien pengujian MQTT** di konsol.AWS IoT **
1. Jalankan perintah berikut untuk memulai ulang program sampel. Ganti *your-iot-thing-name* dan *your-iot-endpoint* dengan nama AWS IoT benda yang Anda buat sebelumnya (misalnya,`My_light_bulb`), dan titik akhir untuk berinteraksi dengan perangkat.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
Aplikasi `shadow.py` sampel kemudian berjalan dan mengambil status bayangan saat ini. Jika Anda telah menghapus bayangan atau menghapus status saat ini, program menetapkan nilai saat ini `off` dan kemudian meminta Anda untuk memasukkan nilai. `desired`
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow document lacks 'color' property. Setting defaults...
Changed local shadow value to 'off'.
Updating reported shadow value to 'off'...
Update request published.
Finished updating reported shadow value to 'off'...
Enter desired value:
```
Di sisi lain, jika program berjalan dan Anda memulai ulang, Anda akan melihat nilai warna terbaru yang dilaporkan di terminal. **Di klien pengujian MQTT, Anda akan melihat pembaruan ke topik **\$1aws/things/ /shadow/get dan *thingname* \$1aws/things/**/. *thingname* shadow/get/accepted**
Misalkan warna terbaru yang dilaporkan adalah`green`. Berikut ini menunjukkan isi dari ***thingname*\$1aws/things/** JSON file. shadow/get/accepted
```
{
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
}
},
"version": 10,
"timestamp": 1620173908
}
```
1. Masukkan `desired` nilai di terminal, seperti`yellow`. Aplikasi `shadow.py` sampel merespons dan menampilkan pesan berikut di terminal yang menunjukkan perubahan `reported` nilai ke`yellow`.
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Di **klien pengujian MQTT** di **AWS IoT konsol**, di bawah **Langganan**, Anda melihat bahwa topik berikut menerima pesan:
+ **\$1aws/things/ *thingname* /shadow/update**: menunjukkan bahwa keduanya dan nilai berubah menjadi warna. `desired` `updated` `yellow`
+ **\$1aws/things/*thingname*/shadow/update/accepted**: menunjukkan nilai saat ini dari `reported` status `desired` dan metadata dan informasi versinya.
+ **\$1aws/things/*thingname*/shadow/update/documents**: menunjukkan nilai sebelumnya dan saat ini dari `reported` status dan metadata `desired` dan informasi versinya.
Karena dokumen **\$1aws/things/*thingname*/shadow/update/documents**juga berisi informasi yang terkandung dalam dua topik lainnya, kita dapat memeriksanya untuk melihat informasi negara. Status sebelumnya menunjukkan nilai yang dilaporkan disetel ke`green`, metadata dan informasi versinya, dan status saat ini yang menunjukkan nilai yang dilaporkan diperbarui ke. `yellow`
```
{
"previous": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
}
},
"version": 10
},
"current": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
}
},
"version": 11
},
"timestamp": 1617297904
}
```
1. Sekarang, jika Anda memasukkan `desired` nilai lain, Anda melihat perubahan lebih lanjut pada `reported` nilai dan pembaruan pesan yang diterima oleh topik ini. Nomor versi juga bertambah 1. Misalnya, jika Anda memasukkan nilai`green`, status sebelumnya melaporkan nilai `yellow` dan status saat ini melaporkan nilainya`green`.
1.
**Edit dokumen Shadow untuk mengamati peristiwa delta**
Untuk mengamati perubahan pada topik delta, edit dokumen Shadow di AWS IoT konsol. Misalnya, Anda dapat mengubah `desired` nilai menjadi warna`red`. Untuk melakukan ini, di AWS IoT konsol, pilih **Edit** dan kemudian atur `desired` nilainya menjadi merah di JSON, sambil menjaga `reported` nilai disetel ke`green`. Sebelum Anda menyimpan perubahan, biarkan terminal tetap terbuka karena Anda akan melihat pesan delta yang dilaporkan di terminal.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Aplikasi `shadow.py` sampel merespons perubahan ini dan menampilkan pesan di terminal yang menunjukkan delta. Di klien pengujian MQTT, `update` topik akan menerima pesan yang menunjukkan perubahan pada dan nilai. `desired` `reported`
Anda juga melihat bahwa topik ***thingname*\$1aws/things/**/menerima pesan. shadow/update/delta Untuk melihat pesan, pilih topik ini, yang tercantum di bawah **Langganan**.
```
{
"version": 13,
"timestamp": 1617318480,
"state": {
"color": "red"
},
"metadata": {
"color": {
"timestamp": 1617318480
}
}
}
```
## Langkah 3: Memecahkan masalah kesalahan dengan interaksi Device Shadow
Saat menjalankan aplikasi sampel Shadow, Anda mungkin mengalami masalah saat mengamati interaksi dengan layanan Device Shadow.
Jika program berjalan dengan sukses dan meminta Anda untuk memasukkan `desired` nilai, Anda harus dapat mengamati interaksi Device Shadow dengan menggunakan dokumen Shadow dan klien pengujian MQTT seperti yang dijelaskan sebelumnya. Namun, jika Anda tidak dapat melihat interaksinya, berikut adalah beberapa hal yang dapat Anda periksa:
+
**Periksa nama benda dan bayangannya di AWS IoT konsol**
Jika Anda tidak melihat pesan di dokumen Shadow, tinjau perintahnya dan pastikan itu cocok dengan nama benda di **AWS IoT konsol**. Anda juga dapat memeriksa apakah Anda memiliki bayangan klasik dengan memilih sumber daya barang Anda dan kemudian memilih **Shadows**. Tutorial ini berfokus terutama pada interaksi dengan bayangan klasik.
Anda juga dapat mengonfirmasi bahwa perangkat yang Anda gunakan terhubung ke internet. Di **AWS IoT konsol**, pilih hal yang Anda buat sebelumnya, lalu pilih **Interact**. Pada halaman detail hal, Anda akan melihat pesan di sini yang mengatakan: `This thing already appears to be connected.`
+
**Periksa topik cadangan MQTT yang Anda langgani**
Jika Anda tidak melihat pesan muncul di klien pengujian MQTT, periksa apakah topik yang Anda berlangganan diformat dengan benar. Topik Device Shadow MQTT memiliki format **\$1aws/things/ *thingname* /shadow/** dan mungkin memiliki `update``get`, atau `delete` mengikutinya tergantung pada tindakan yang ingin Anda lakukan pada bayangan. **Tutorial ini menggunakan topik **\$1aws/things/ *thingname* /shadow/ \$1** jadi pastikan Anda memasukkannya dengan benar saat berlangganan topik di bagian filter Topik klien pengujian.**
Saat Anda memasukkan nama topik, pastikan bahwa *thingname* itu sama dengan nama AWS IoT benda yang Anda buat sebelumnya. Anda juga dapat berlangganan topik MQTT tambahan untuk melihat apakah pembaruan telah berhasil dilakukan. Misalnya, Anda dapat berlangganan topik **\$1aws/things/*thingname*/shadow/update/rejected**untuk menerima pesan setiap kali permintaan pembaruan gagal sehingga Anda dapat men-debug masalah koneksi. Untuk informasi lebih lanjut tentang topik yang dipesan, lihat [Topik bayangan](reserved-topics.md#reserved-topics-shadow) dan[Topik MQTT Bayangan Perangkat](device-shadow-mqtt.md).
## Langkah 4: Tinjau hasil dan langkah selanjutnya
**Dalam tutorial ini, Anda belajar cara:**
+ Gunakan aplikasi `shadow.py` sampel untuk menentukan status yang diinginkan dan memperbarui status bayangan saat ini.
+ Edit dokumen Shadow untuk mengamati peristiwa delta dan bagaimana aplikasi `shadow.py` sampel meresponsnya.
+ Gunakan klien pengujian MQTT untuk berlangganan topik bayangan dan mengamati pembaruan saat Anda menjalankan program sampel.
**Langkah selanjutnya**
Anda dapat berlangganan topik cadangan MQTT tambahan untuk mengamati pembaruan aplikasi bayangan. Misalnya, jika Anda hanya berlangganan topik **\$1aws/things/*thingname*/shadow/update/accepted**, Anda hanya akan melihat informasi status saat ini ketika pembaruan berhasil dilakukan.
Anda juga dapat berlangganan topik bayangan tambahan untuk men-debug masalah atau mempelajari lebih lanjut tentang interaksi Device Shadow dan juga men-debug masalah apa pun dengan interaksi Device Shadow. Untuk informasi selengkapnya, lihat [Topik bayangan](reserved-topics.md#reserved-topics-shadow) dan [Topik MQTT Bayangan Perangkat](device-shadow-mqtt.md).
Anda juga dapat memilih untuk memperluas aplikasi Anda dengan menggunakan bayangan bernama atau dengan menggunakan perangkat keras tambahan yang terhubung dengan Raspberry Pi untuk LEDs dan mengamati perubahan status mereka menggunakan pesan yang dikirim dari terminal.
Untuk informasi selengkapnya tentang layanan Device Shadow dan menggunakan layanan di perangkat, aplikasi, dan layanan[AWS IoT Layanan Device Shadow](iot-device-shadows.md), lihat[Menggunakan bayangan di perangkat](device-shadow-comms-device.md), dan[Menggunakan bayangan di aplikasi dan layanan](device-shadow-comms-app.md).