Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Membangun solusi dengan AWS IoT Perangkat SDKs
<a name="iot-tutorials-sdk-intro"></a>

Tutorial di bagian ini membantu memandu Anda melalui langkah-langkah untuk mengembangkan solusi IoT yang dapat diterapkan ke lingkungan produksi menggunakan. AWS IoT

Tutorial ini membutuhkan lebih banyak waktu untuk diselesaikan daripada yang ada di bagian [Membangun demo dengan AWS IoT Device Client](iot-tutorials-dc-intro.md) karena mereka menggunakan AWS IoT Perangkat SDKs dan menjelaskan konsep yang diterapkan secara lebih rinci untuk membantu Anda membuat solusi yang aman dan andal.

## Mulai membangun solusi dengan AWS IoT Perangkat SDKs
<a name="iot-sdk-tutorial-overview"></a>

Tutorial ini memandu Anda melalui AWS IoT skenario yang berbeda. Jika sesuai, tutorial menggunakan AWS IoT Perangkat SDKs.

**Topics**
+ [Mulai membangun solusi dengan AWS IoT Perangkat SDKs](#iot-sdk-tutorial-overview)
+ [Tutorial: Menghubungkan perangkat AWS IoT Core dengan menggunakan AWS IoT Device SDK](sdk-tutorials.md)
+ [Membuat AWS IoT aturan untuk merutekan data perangkat ke layanan lain](iot-rules-tutorial.md)
+ [Mempertahankan status perangkat saat perangkat offline dengan Device Shadows](iot-shadows-tutorial.md)
+ [Tutorial: Membuat otorisasi khusus untuk AWS IoT Core](custom-auth-tutorial.md)
+ [Tutorial: Memantau kelembaban tanah dengan AWS IoT dan Raspberry Pi](iot-moisture-tutorial.md)

# Tutorial: Menghubungkan perangkat AWS IoT Core dengan menggunakan AWS IoT Device SDK
<a name="sdk-tutorials"></a>

Tutorial ini menunjukkan cara menghubungkan perangkat AWS IoT Core sehingga dapat mengirim dan menerima data ke dan dari AWS IoT. Setelah Anda menyelesaikan tutorial ini, perangkat Anda akan dikonfigurasi untuk terhubung AWS IoT Core dan Anda akan memahami bagaimana perangkat berkomunikasi dengan AWS IoT.

**Topics**
+ [Prasyarat](#sdk-tutorials-prereq)
+ [Siapkan perangkat Anda untuk AWS IoT](#sdk-tutorials-prepare)
+ [Tinjau protokol MQTT](#sdk-tutorials-mqtt-review)
+ [Tinjau aplikasi contoh SDK Perangkat pubsub.py](#sdk-tutorials-explore-sample)
+ [Connect perangkat Anda dan berkomunikasi dengan AWS IoT Core](#sdk-tutorials-experiment)
+ [Tinjau hasilnya](#sdk-tutorials-conclusion)
+ [Tutorial: Menggunakan AWS IoT Device SDK for Embedded C](iot-embedded-c-sdk.md)

## Prasyarat
<a name="sdk-tutorials-prereq"></a>

Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:
+ 

**Selesai [Memulai dengan AWS IoT Core tutorial](iot-gs.md)**  
Di bagian tutorial di mana Anda harus[Konfigurasikan perangkat Anda](configure-device.md), pilih [Connect Raspberry Pi atau perangkat lain](connecting-to-existing-device.md) opsi untuk perangkat Anda dan gunakan opsi bahasa Python untuk mengonfigurasi perangkat Anda.
**catatan**  
Tetap buka jendela terminal yang Anda gunakan dalam tutorial itu karena Anda juga akan menggunakannya dalam tutorial ini.
+ 

**Perangkat yang dapat menjalankan AWS IoT Device SDK v2 untuk Python.**  
Tutorial ini menunjukkan cara menghubungkan perangkat AWS IoT Core dengan menggunakan contoh kode Python, yang membutuhkan perangkat yang relatif kuat. Jika Anda bekerja dengan perangkat terbatas sumber daya, contoh kode ini mungkin tidak berfungsi pada mereka. Dalam hal ini, Anda mungkin lebih sukses dengan [Tutorial: Menggunakan AWS IoT Device SDK for Embedded C](iot-embedded-c-sdk.md) tutorial.
+ 

**Memperoleh informasi yang diperlukan untuk terhubung ke perangkat**  
Untuk menghubungkan perangkat Anda AWS IoT, Anda harus memiliki informasi tentang nama benda, nama host, dan nomor port.
**catatan**  
Anda juga dapat menggunakan otentikasi khusus untuk menghubungkan perangkat ke AWS IoT Core. Data koneksi yang Anda berikan ke fungsi Lambda otorisasi Anda tergantung pada protokol yang Anda gunakan.
  + **Nama benda**: Nama AWS IoT benda yang ingin Anda hubungkan. Anda harus telah terdaftar sebagai perangkat Anda sebagai AWS IoT sesuatu. Untuk informasi selengkapnya, lihat [Mengelola perangkat dengan AWS IoT](iot-thing-management.md).
  + **Nama host: Nama** host untuk titik akhir IoT khusus akun.
  + **Nomor port**: Nomor port yang akan dihubungkan.

  Anda dapat menggunakan `configureEndpoint` metode di AWS IoT Python SDK untuk mengkonfigurasi nama host dan nomor port.

  ```
  myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)
  ```

## Siapkan perangkat Anda untuk AWS IoT
<a name="sdk-tutorials-prepare"></a>

Di[Memulai dengan AWS IoT Core tutorial](iot-gs.md), Anda menyiapkan perangkat dan AWS akun Anda sehingga mereka dapat berkomunikasi. Bagian ini mengulas aspek-aspek persiapan yang berlaku untuk koneksi perangkat apa pun dengan AWS IoT Core.

Untuk perangkat untuk terhubung ke AWS IoT Core:

1. Anda harus memiliki **Akun AWS**.

   Prosedur dalam [Mengatur Akun AWS](setting-up.md) menjelaskan cara membuat Akun AWS jika Anda belum memilikinya. 

1. Di akun itu, Anda harus memiliki **AWS IoT sumber daya** berikut yang ditentukan untuk perangkat di Akun AWS dan Wilayah Anda.

   Prosedur dalam [Buat AWS IoT sumber daya](create-iot-resources.md) menjelaskan cara membuat sumber daya ini untuk perangkat di wilayah Anda Akun AWS dan wilayah.
   + **Sertifikat perangkat** yang terdaftar AWS IoT dan diaktifkan untuk mengautentikasi perangkat.

     Sertifikat sering dibuat dengan, dan dilampirkan pada, **objek AWS IoT benda**. Meskipun objek benda tidak diperlukan untuk perangkat untuk terhubung AWS IoT, itu membuat AWS IoT fitur tambahan tersedia untuk perangkat.
   + **Kebijakan** yang dilampirkan pada sertifikat perangkat yang mengizinkannya untuk terhubung AWS IoT Core dan melakukan semua tindakan yang Anda inginkan.

1. **Koneksi internet** yang dapat mengakses titik akhir perangkat Anda Akun AWS.

   Titik akhir perangkat dijelaskan [AWS IoT data perangkat dan titik akhir layanan](iot-connect-devices.md#iot-connect-device-endpoints) dan dapat dilihat di [halaman pengaturan AWS IoT konsol](https://console.aws.amazon.com/iot/home#/settings). 

1. **Perangkat lunak komunikasi** seperti yang SDKs disediakan AWS IoT Perangkat. Tutorial ini menggunakan [AWS IoT Device SDK v2 untuk Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python).

## Tinjau protokol MQTT
<a name="sdk-tutorials-mqtt-review"></a>

Sebelum kita berbicara tentang aplikasi sampel, ada baiknya untuk memahami protokol MQTT. Protokol MQTT menawarkan beberapa keunggulan dibandingkan protokol komunikasi jaringan lainnya, seperti HTTP, yang menjadikannya pilihan populer untuk perangkat IoT. Bagian ini mengulas aspek-aspek kunci dari MQTT yang berlaku untuk tutorial ini. Untuk informasi tentang bagaimana MQTT dibandingkan dengan HTTP, lihat. [Memilih protokol aplikasi untuk komunikasi perangkat Anda](protocols.md#protocol-selection)

**MQTT menggunakan model komunikasi publish/subscribe**  
Protokol MQTT menggunakan model publish/subscribe komunikasi dengan hostnya. Model ini berbeda dari request/response model yang digunakan HTTP. Dengan MQTT, perangkat membuat sesi dengan host yang diidentifikasi oleh ID klien unik. Untuk mengirim data, perangkat mempublikasikan pesan yang diidentifikasi berdasarkan topik ke broker pesan di host. Untuk menerima pesan dari broker pesan, perangkat berlangganan topik dengan mengirimkan filter topik dalam permintaan berlangganan ke broker pesan.

**MQTT mendukung sesi persisten**  
Broker pesan menerima pesan dari perangkat dan menerbitkan pesan ke perangkat yang telah berlangganan. Dengan [sesi persisten](mqtt.md#mqtt-persistent-sessions) —sesi yang tetap aktif bahkan saat perangkat yang memulai terputus—perangkat dapat mengambil pesan yang diterbitkan saat terputus. Di sisi perangkat, MQTT mendukung Quality of Service Level ([QoS](mqtt.md#mqtt-qos)) yang memastikan host menerima pesan yang dikirim oleh perangkat.

## Tinjau aplikasi contoh SDK Perangkat pubsub.py
<a name="sdk-tutorials-explore-sample"></a>

Bagian ini mengulas `pubsub.py` contoh aplikasi dari **AWS IoT Device SDK v2 untuk Python** yang digunakan dalam tutorial ini. Di sini, kami akan meninjau bagaimana terhubung AWS IoT Core untuk mempublikasikan dan berlangganan pesan MQTT. Bagian selanjutnya menyajikan beberapa latihan untuk membantu Anda menjelajahi bagaimana perangkat terhubung dan berkomunikasi dengannya AWS IoT Core.

**Aplikasi `pubsub.py` sampel menunjukkan aspek-aspek koneksi MQTT ini dengan: AWS IoT Core**
+ [Protokol komunikasi](#sdk-tutorials-explore-protocols)
+ [Sesi persisten](#sdk-tutorials-explore-persistent)
+ [Kualitas Layanan](#sdk-tutorials-explore-qos)
+ [Pesan terbitkan](#sdk-tutorials-explore-publish)
+ [Langganan pesan](#sdk-tutorials-explore-subscribe)
+ [Pemutusan dan koneksi ulang perangkat](#sdk-tutorials-explore-connect)

### Protokol komunikasi
<a name="sdk-tutorials-explore-protocols"></a>

`pubsub.py`Sampel menunjukkan koneksi MQTT 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.

#### MQTT
<a name="sdk-tutorials-explore-mqtt"></a>

`pubsub.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`  
Titik Akun AWS akhir perangkat IoT Anda  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`cert_filepath`  
Jalur ke file sertifikat perangkat  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`pri_key_filepath`  
Jalur ke file kunci pribadi perangkat yang dibuat dengan file sertifikatnya  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`ca_filepath`  
Jalur ke file Root CA. Diperlukan hanya jika server MQTT menggunakan sertifikat yang belum ada di toko kepercayaan Anda.  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`client_bootstrap`  
Objek runtime umum yang menangani aktivitas komunikasi soket  
Dalam aplikasi sampel, objek ini dipakai sebelum panggilan ke. `mqtt_connection_builder.mtls_from_path`

`on_connection_interrupted``on_connection_resumed`  
Fungsi panggilan balik untuk memanggil saat koneksi perangkat terputus dan dilanjutkan

`client_id`  
ID yang secara unik mengidentifikasi perangkat ini di Wilayah AWS  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`clean_session`  
Apakah akan memulai sesi persisten baru, atau, jika ada, sambungkan kembali ke yang sudah ada

`keep_alive_secs`  
Nilai keep alive, dalam hitungan detik, untuk mengirim `CONNECT` permintaan. Ping akan secara otomatis dikirim pada interval ini. Jika server tidak menerima ping setelah 1,5 kali nilai ini, itu mengasumsikan bahwa koneksi terputus.

#### MQTT melalui WSS
<a name="sdk-tutorials-explore-mqtt-wss"></a>

`pubsub.py`Contoh panggilan `websockets_with_default_aws_signing` (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 menggunakan protokol MQTT melalui WSS. `websockets_with_default_aws_signing`membuat koneksi MQTT melalui WSS menggunakan [Signature V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) untuk mengautentikasi perangkat.

```
mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
    endpoint=args.endpoint,
    client_bootstrap=client_bootstrap,
    region=args.signing_region,
    credentials_provider=credentials_provider,
    websocket_proxy_options=proxy_options,
    ca_filepath=args.ca_file,
    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`  
Titik Akun AWS akhir perangkat IoT Anda  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`client_bootstrap`  
Objek runtime umum yang menangani aktivitas komunikasi soket  
Dalam aplikasi sampel, objek ini dipakai sebelum panggilan ke. `mqtt_connection_builder.websockets_with_default_aws_signing`

`region`  
Wilayah AWS penandatanganan yang digunakan oleh otentikasi Signature V4. Di`pubsub.py`, ia melewati parameter yang dimasukkan di baris perintah.  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`credentials_provider`  
 AWS Kredensi yang disediakan untuk digunakan untuk otentikasi  
Dalam aplikasi sampel, objek ini dipakai sebelum panggilan ke. `mqtt_connection_builder.websockets_with_default_aws_signing`

`websocket_proxy_options`  
Opsi proxy HTTP, jika menggunakan host proxy  
Di aplikasi sampel, nilai ini diinisialisasi sebelum panggilan ke`mqtt_connection_builder.websockets_with_default_aws_signing`.

`ca_filepath`  
Jalur ke file Root CA. Diperlukan hanya jika server MQTT menggunakan sertifikat yang belum ada di toko kepercayaan Anda.  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`on_connection_interrupted``on_connection_resumed`  
Fungsi panggilan balik untuk memanggil saat koneksi perangkat terputus dan dilanjutkan

`client_id`  
ID yang secara unik mengidentifikasi perangkat ini di. Wilayah AWS  
Di aplikasi sampel, nilai ini diteruskan dari baris perintah.

`clean_session`  
Apakah akan memulai sesi persisten baru, atau, jika ada, sambungkan kembali ke yang sudah ada

`keep_alive_secs`  
Nilai keep alive, dalam hitungan detik, untuk mengirim `CONNECT` permintaan. Ping akan secara otomatis dikirim pada interval ini. Jika server tidak menerima ping setelah 1,5 kali nilai ini, itu mengasumsikan koneksi terputus.

#### HTTPS
<a name="sdk-tutorials-explore-https"></a>

Bagaimana dengan HTTPS? AWS IoT Core mendukung perangkat yang mempublikasikan permintaan HTTPS. Dari perspektif pemrograman, perangkat mengirim permintaan HTTPS ke AWS IoT Core seperti halnya aplikasi lainnya. Untuk contoh program Python yang mengirim pesan HTTP dari perangkat, lihat [contoh kode HTTPS menggunakan pustaka](http.md#codeexample) Python. `requests` Contoh ini mengirimkan pesan untuk AWS IoT Core menggunakan HTTPS sehingga AWS IoT Core menafsirkannya sebagai pesan MQTT.

Meskipun AWS IoT Core mendukung permintaan HTTPS dari perangkat, pastikan untuk meninjau informasi tentang [Memilih protokol aplikasi untuk komunikasi perangkat Anda](protocols.md#protocol-selection) sehingga Anda dapat membuat keputusan berdasarkan informasi tentang protokol mana yang akan digunakan untuk komunikasi perangkat Anda.

### Sesi persisten
<a name="sdk-tutorials-explore-persistent"></a>

Di aplikasi sampel, menyetel `clean_session` parameter untuk `False` menunjukkan bahwa koneksi harus persisten. Dalam praktiknya, ini berarti bahwa koneksi yang dibuka oleh panggilan ini terhubung kembali ke sesi persisten yang ada, jika ada. Jika tidak, itu menciptakan dan terhubung ke sesi persisten baru.

Dengan sesi persisten, pesan yang dikirim ke perangkat disimpan oleh broker pesan saat perangkat tidak terhubung. Ketika perangkat terhubung kembali ke sesi persisten, broker pesan mengirim ke perangkat pesan apa pun yang tersimpan yang telah dilanggankannya.

Tanpa sesi persisten, perangkat tidak akan menerima pesan yang dikirim saat perangkat tidak terhubung. Opsi mana yang akan digunakan tergantung pada aplikasi Anda dan apakah pesan yang terjadi saat perangkat tidak terhubung harus dikomunikasikan. Untuk informasi selengkapnya, lihat [Sesi persisten MQTT](mqtt.md#mqtt-persistent-sessions).

### Kualitas Layanan
<a name="sdk-tutorials-explore-qos"></a>

Saat perangkat menerbitkan dan berlangganan pesan, Quality of Service (QoS) pilihan dapat diatur. AWS IoT mendukung QoS level 0 dan 1 untuk mempublikasikan dan berlangganan operasi. Untuk informasi selengkapnya tentang level QoS AWS IoT, lihat. [Opsi Kualitas Layanan (QoS) MQTT](mqtt.md#mqtt-qos)

Runtime AWS CRT untuk Python mendefinisikan konstanta ini untuk level QoS yang didukungnya:


**Tingkat Kualitas Layanan Python**  

| Tingkat QoS MQTT | Nilai simbolis Python yang digunakan oleh SDK | Deskripsi | 
| --- | --- | --- | 
| QoS tingkat 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Hanya satu upaya untuk mengirim pesan yang akan dilakukan, apakah itu diterima atau tidak. Pesan mungkin tidak dikirim sama sekali, misalnya, jika perangkat tidak terhubung atau ada kesalahan jaringan. | 
| QoS tingkat 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | Pesan dikirim berulang kali sampai PUBACK pengakuan diterima. | 

Dalam aplikasi contoh, permintaan publikasi dan berlangganan dibuat dengan tingkat QoS 1 ()`mqtt.QoS.AT_LEAST_ONCE`. 
+ 

**QoS di publikasikan**  
Ketika perangkat menerbitkan pesan dengan QoS level 1, ia mengirim pesan berulang kali hingga menerima `PUBACK` respons dari broker pesan. Jika perangkat tidak terhubung, pesan akan diantrian untuk dikirim setelah tersambung kembali.
+ 

**QoS saat berlangganan**  
Saat perangkat berlangganan pesan dengan QoS level 1, broker pesan menyimpan pesan yang menjadi langganan perangkat hingga dapat dikirim ke perangkat. Broker pesan mengirim ulang pesan hingga menerima `PUBACK` respons dari perangkat.

### Pesan terbitkan
<a name="sdk-tutorials-explore-publish"></a>

Setelah berhasil membuat koneksi ke AWS IoT Core, perangkat dapat mempublikasikan pesan. `pubsub.py`Sampel melakukan ini dengan memanggil `publish` operasi `mqtt_connection` objek.

```
mqtt_connection.publish(
    topic=args.topic,
    payload=message,
    qos=mqtt.QoS.AT_LEAST_ONCE
)
```

`topic`  
Nama topik pesan yang mengidentifikasi pesan  
Dalam aplikasi sampel, ini diteruskan dari baris perintah.

`payload`  
Payload pesan diformat sebagai string (misalnya, dokumen JSON)  
Dalam aplikasi sampel, ini diteruskan dari baris perintah.  
Dokumen JSON adalah format payload umum, dan yang diakui oleh AWS IoT layanan lain; Namun, format data payload pesan dapat berupa apa saja yang disetujui oleh penerbit dan pelanggan. AWS IoT Layanan lain, bagaimanapun, hanya mengenali JSON, dan CBOR, dalam beberapa kasus, untuk sebagian besar operasi.

`qos`  
Level QoS untuk pesan ini

### Langganan pesan
<a name="sdk-tutorials-explore-subscribe"></a>

Untuk menerima pesan dari AWS IoT dan layanan dan perangkat lainnya, perangkat berlangganan pesan tersebut berdasarkan nama topiknya. Perangkat dapat berlangganan pesan individual dengan menentukan [nama topik](topics.md#topicnames), dan ke sekelompok pesan dengan menentukan [filter topik](topics.md#topicfilters), yang dapat mencakup karakter wild card. `pubsub.py`Sampel menggunakan kode yang ditampilkan di sini untuk berlangganan pesan dan mendaftarkan fungsi panggilan balik untuk memproses pesan setelah diterima.

```
subscribe_future, packet_id = mqtt_connection.subscribe(
    topic=args.topic,
    qos=mqtt.QoS.AT_LEAST_ONCE,
    callback=on_message_received
)
subscribe_result = subscribe_future.result()
```

`topic`  
Topik untuk berlangganan. Ini bisa berupa nama topik atau filter topik.  
Dalam aplikasi sampel, ini diteruskan dari baris perintah.

`qos`  
Apakah broker pesan harus menyimpan pesan-pesan ini saat perangkat terputus.  
Nilai `mqtt.QoS.AT_LEAST_ONCE` (QoS level 1), membutuhkan sesi persisten untuk ditentukan (`clean_session=False`) saat koneksi dibuat.

`callback`  
Fungsi untuk memanggil untuk memproses pesan berlangganan.

`mqtt_connection.subscribe`Fungsi mengembalikan future dan ID paket. Jika permintaan berlangganan berhasil dimulai, ID paket yang dikembalikan lebih besar dari 0. Untuk memastikan bahwa langganan diterima dan didaftarkan oleh broker pesan, Anda harus menunggu hasil operasi asinkron kembali, seperti yang ditunjukkan pada contoh kode.

**Fungsi callback**  
Callback dalam `pubsub.py` sampel memproses pesan berlangganan saat perangkat menerimanya.

```
def on_message_received(topic, payload, **kwargs):
    print("Received message from topic '{}': {}".format(topic, payload))
    global received_count
    received_count += 1
    if received_count == args.count:
        received_all_event.set()
```

`topic`  
Topik pesan  
Ini adalah nama topik spesifik dari pesan yang diterima, bahkan jika Anda berlangganan filter topik.

`payload`  
Payload pesan  
Format untuk ini adalah aplikasi khusus.

`kwargs`  
Kemungkinan argumen tambahan seperti yang dijelaskan dalam [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe).

Dalam `pubsub.py` sampel, `on_message_received` hanya menampilkan topik dan muatannya. Ini juga menghitung pesan yang diterima untuk mengakhiri program setelah batas tercapai.

Aplikasi Anda akan mengevaluasi topik dan payload untuk menentukan tindakan apa yang harus dilakukan.

### Pemutusan dan koneksi ulang perangkat
<a name="sdk-tutorials-explore-connect"></a>

`pubsub.py`Sampel mencakup fungsi panggilan balik yang dipanggil saat perangkat terputus dan saat koneksi dibuat kembali. Tindakan apa yang dilakukan perangkat Anda pada acara ini adalah spesifik aplikasi.

Saat perangkat terhubung untuk pertama kalinya, perangkat harus berlangganan topik untuk diterima. Jika sesi perangkat hadir saat terhubung kembali, langganannya dipulihkan, dan pesan apa pun yang disimpan dari langganan tersebut dikirim ke perangkat setelah terhubung kembali.

Jika sesi perangkat tidak ada lagi saat terhubung kembali, ia harus berlangganan kembali ke langganannya. Sesi persisten memiliki masa pakai yang terbatas dan dapat kedaluwarsa ketika perangkat terputus terlalu lama.

## Connect perangkat Anda dan berkomunikasi dengan AWS IoT Core
<a name="sdk-tutorials-experiment"></a>

Bagian ini menyajikan beberapa latihan untuk membantu Anda menjelajahi berbagai aspek menghubungkan perangkat Anda AWS IoT Core. Untuk latihan ini, Anda akan menggunakan [klien pengujian MQTT](https://console.aws.amazon.com/iot/home#/test) di AWS IoT konsol untuk melihat apa yang dipublikasikan perangkat Anda dan memublikasikan pesan ke perangkat Anda. Latihan ini menggunakan [https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py)sampel dari [AWS IoT Device SDK v2 untuk Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) dan membangun pengalaman [Memulai dengan AWS IoT Core tutorial](iot-gs.md) Anda dengan tutorial. 

**Topics**
+ [Berlangganan filter topik wild card](#sdk-tutorials-experiment-wild)
+ [Langganan filter topik proses](#sdk-tutorials-experiment-process)
+ [Publikasikan pesan dari perangkat Anda](#sdk-tutorials-experiment-publish)

Untuk latihan ini, Anda akan mulai dari program `pubsub.py` sampel.

**catatan**  
Latihan-latihan ini mengasumsikan bahwa Anda menyelesaikan [Memulai dengan AWS IoT Core tutorial](iot-gs.md) tutorial dan menggunakan jendela terminal untuk perangkat Anda dari tutorial itu.

### Berlangganan filter topik wild card
<a name="sdk-tutorials-experiment-wild"></a>

Dalam latihan ini, Anda akan memodifikasi baris perintah yang digunakan `pubsub.py` untuk menelepon untuk berlangganan filter topik wild card dan memproses pesan yang diterima berdasarkan topik pesan.

#### Prosedur latihan
<a name="sdk-tutorials-experiment-wild-steps"></a>

Untuk latihan ini, bayangkan perangkat Anda berisi kontrol suhu dan kontrol cahaya. Ini menggunakan nama-nama topik ini untuk mengidentifikasi pesan tentang mereka.

1. Sebelum memulai latihan, coba jalankan perintah ini dari [Memulai dengan AWS IoT Core tutorial](iot-gs.md) tutorial di perangkat Anda untuk memastikan semuanya siap untuk latihan.

   ```
   cd ~/aws-iot-device-sdk-python-v2/samples
   python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
   ```

   Anda akan melihat output yang sama seperti yang Anda lihat di [tutorial Memulai](connecting-to-existing-device.md#gs-device-node-app-run).

1. Untuk latihan ini, ubah parameter baris perintah ini.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/sdk-tutorials.html)

   Membuat perubahan ini pada baris perintah awal menghasilkan baris perintah ini. Masukkan perintah ini di jendela terminal untuk perangkat Anda.

   ```
   python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
   ```

   Program harus menampilkan sesuatu seperti ini:

   ```
   Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
   Connected!
   Subscribing to topic 'device/+/details'...
   Subscribed with QoS.AT_LEAST_ONCE
   Waiting for all messages to be received...
   ```

   Jika Anda melihat sesuatu seperti ini di terminal Anda, perangkat Anda siap dan mendengarkan pesan di mana nama topik dimulai `device` dan diakhiri dengan`/detail`. Jadi, mari kita uji itu.

1. Berikut adalah beberapa pesan yang mungkin diterima perangkat Anda.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/sdk-tutorials.html)

1. Menggunakan klien pengujian MQTT di AWS IoT konsol, kirim pesan yang dijelaskan pada langkah sebelumnya ke perangkat Anda.

   1. Buka [klien pengujian MQTT di konsol](https://console.aws.amazon.com/iot/home#/test). AWS IoT 

   1. Di **Berlangganan topik**, di **bidang Topik berlangganan**, masukkan filter topik:**device/\$1/details**, lalu pilih **Berlangganan topik**.

   1. **Di kolom **Langganan** klien pengujian MQTT, pilih perangkat/\$1/detail.**

   1. Untuk setiap topik di tabel sebelumnya, lakukan hal berikut di klien pengujian MQTT:

      1. Di **Publikasikan**, masukkan nilai dari kolom **Nama topik** dalam tabel.

      1. Di bidang payload pesan di bawah nama topik, masukkan nilai dari kolom **Payload pesan** dalam tabel.

      1. Tonton jendela terminal tempat `pubsub.py` berjalan dan, di klien pengujian MQTT, pilih **Publikasikan** ke topik.

      Anda akan melihat bahwa pesan diterima oleh `pubsub.py` di jendela terminal.

#### Hasil latihan
<a name="sdk-tutorials-experiment-wild-result"></a>

Dengan ini,`pubsub.py`, berlangganan pesan menggunakan filter topik kartu liar, menerimanya, dan menampilkannya di jendela terminal. Perhatikan bagaimana Anda berlangganan filter topik tunggal, dan fungsi callback dipanggil untuk memproses pesan yang memiliki dua topik berbeda.

### Langganan filter topik proses
<a name="sdk-tutorials-experiment-process"></a>

Berdasarkan latihan sebelumnya, modifikasi aplikasi `pubsub.py` sampel untuk mengevaluasi topik pesan dan memproses pesan berlangganan berdasarkan topik.

#### Prosedur latihan
<a name="sdk-tutorials-experiment-process-steps"></a>

**Untuk mengevaluasi topik pesan**

1. Salin `pubsub.py` ke `pubsub2.py`.

1. Buka `pubsub2.py` di editor teks atau IDE favorit Anda.

1. Di`pubsub2.py`, temukan `on_message_received` fungsinya.

1. Dalam`on_message_received`, masukkan kode berikut setelah baris yang dimulai dengan `print("Received message` dan sebelum baris yang dimulai dengan`global received_count`.

   ```
       topic_parsed = False
       if "/" in topic:
           parsed_topic = topic.split("/")
           if len(parsed_topic) == 3:
               # this topic has the correct format
               if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
                   # this is a topic we care about, so check the 2nd element
                   if (parsed_topic[1] == 'temp'):
                       print("Received temperature request: {}".format(payload))
                       topic_parsed = True
                   if (parsed_topic[1] == 'light'):
                       print("Received light request: {}".format(payload))
                       topic_parsed = True
       if not topic_parsed:
           print("Unrecognized message topic.")
   ```

1. Simpan perubahan Anda dan jalankan program yang dimodifikasi dengan menggunakan baris perintah ini.

   ```
   python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
   ```

1. Di AWS IoT konsol, buka klien uji [MQTT](https://console.aws.amazon.com/iot/home#/test).

1. Di **Berlangganan topik**, di **bidang Topik berlangganan**, masukkan filter topik:**device/\$1/details**, lalu pilih **Berlangganan topik**.

1. **Di kolom **Langganan** klien pengujian MQTT, pilih perangkat/\$1/detail.**

1. Untuk setiap topik dalam tabel ini, lakukan hal berikut di klien pengujian MQTT:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/sdk-tutorials.html)

   1. Di **Publikasikan**, masukkan nilai dari kolom **Nama topik** dalam tabel.

   1. Di bidang payload pesan di bawah nama topik, masukkan nilai dari kolom **Payload pesan** dalam tabel.

   1. Tonton jendela terminal tempat `pubsub.py` berjalan dan, di klien pengujian MQTT, pilih **Publikasikan** ke topik.

   Anda akan melihat bahwa pesan diterima oleh `pubsub.py` di jendela terminal.

Anda akan melihat sesuatu yang mirip dengan ini di jendela terminal Anda.

```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!
```

#### Hasil latihan
<a name="sdk-tutorials-experiment-process-result"></a>

Dalam latihan ini, Anda menambahkan kode sehingga aplikasi sampel akan mengenali dan memproses beberapa pesan dalam fungsi callback. Dengan ini, perangkat Anda dapat menerima pesan dan menindaklanjutinya.

Cara lain bagi perangkat Anda untuk menerima dan memproses beberapa pesan adalah dengan berlangganan pesan yang berbeda secara terpisah dan menetapkan setiap langganan ke fungsi panggilan baliknya sendiri.

### Publikasikan pesan dari perangkat Anda
<a name="sdk-tutorials-experiment-publish"></a>

Anda dapat menggunakan aplikasi sampel pubsub.py untuk memublikasikan pesan dari perangkat Anda. Meskipun akan mempublikasikan pesan apa adanya, pesan tidak dapat dibaca sebagai dokumen JSON. Latihan ini memodifikasi aplikasi sampel agar dapat mempublikasikan dokumen JSON di payload pesan yang dapat dibaca oleh. AWS IoT Core

#### Prosedur latihan
<a name="sdk-tutorials-experiment-publish-steps"></a>

Dalam latihan ini, pesan berikut akan dikirim dengan `device/data` topik.

```
{
    "timestamp": 1601048303,
    "sensorId": 28,
    "sensorData": [
        {
        "sensorName": "Wind speed",
        "sensorValue": 34.2211224
        }
    ]
}
```

**Untuk mempersiapkan klien tes MQTT Anda untuk memantau pesan dari latihan ini**

1. Di **Berlangganan topik**, di **bidang Topik berlangganan**, masukkan filter topik:**device/data**, lalu pilih **Berlangganan topik**.

1. **Di kolom **Langganan** klien pengujian MQTT, pilih perangkat/data.**

1. Biarkan jendela klien pengujian MQTT tetap terbuka untuk menunggu pesan dari perangkat Anda.

**Untuk mengirim dokumen JSON dengan aplikasi sampel pubsub.py**

1. Di perangkat Anda, salin `pubsub.py` ke`pubsub3.py`.

1. Edit `pubsub3.py` untuk mengubah cara memformat pesan yang diterbitkannya.

   1. Buka `pubsub3.py` di editor teks.

   1. Temukan baris kode ini:

      `message = "{} [{}]".format(message_string, publish_count)`

   1. Ubah ke:

      `message = "{}".format(message_string)`

   1. Temukan baris kode ini:

      `message_json = json.dumps(message)`

   1. Ubah ke:

      `message = "{}".json.dumps(json.loads(message))`

   1. Simpan perubahan Anda.

1. Di perangkat Anda, jalankan perintah ini untuk mengirim pesan dua kali.

   ```
   python3 pubsub3.py  --ca_file ~/certs/Amazon-root-CA-1.pem  --cert ~/certs/device.pem.crt  --key ~/certs/private.pem.key  --topic device/data  --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'  --endpoint your-iot-endpoint
   ```

1. Di klien pengujian MQTT, periksa untuk melihat bahwa ia telah menafsirkan dan memformat dokumen JSON dalam muatan pesan, seperti ini:  
![\[Gambar yang menunjukkan bagaimana payload pesan JSON ditampilkan di klien MQTT konsol. AWS IoT\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/images/mqtt-test-client-output.png)

Secara default, `pubsub3.py` juga berlangganan pesan yang dikirimnya. Anda akan melihat bahwa itu menerima pesan dalam output aplikasi. Jendela terminal akan terlihat seperti ini.

```
Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!
```

#### Hasil latihan
<a name="sdk-tutorials-experiment-publish-result"></a>

Dengan ini, perangkat Anda dapat menghasilkan pesan untuk dikirim AWS IoT Core untuk menguji konektivitas dasar dan menyediakan pesan perangkat AWS IoT Core untuk diproses. Misalnya, Anda dapat menggunakan aplikasi ini untuk mengirim data pengujian dari perangkat Anda untuk menguji tindakan AWS IoT aturan.

## Tinjau hasilnya
<a name="sdk-tutorials-conclusion"></a>

Contoh dalam tutorial ini memberi Anda pengalaman langsung dengan dasar-dasar bagaimana perangkat dapat berkomunikasi dengan AWS IoT Core— bagian mendasar dari solusi Anda. AWS IoT Ketika perangkat Anda dapat berkomunikasi AWS IoT Core, mereka dapat meneruskan pesan ke AWS layanan dan perangkat lain tempat mereka dapat bertindak. Demikian juga, AWS layanan dan perangkat lain dapat memproses informasi yang menghasilkan pesan yang dikirim kembali ke perangkat Anda.

Ketika Anda siap untuk mengeksplorasi AWS IoT Core lebih lanjut, cobalah tutorial ini:
+ [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)
+ [Tutorial: Menyimpan data perangkat dalam tabel DynamoDB](iot-ddb-rule.md)
+ [Tutorial: Memformat notifikasi dengan menggunakan fungsi AWS Lambda](iot-lambda-rule.md)

# Tutorial: Menggunakan AWS IoT Device SDK for Embedded C
<a name="iot-embedded-c-sdk"></a>

Bagian ini menjelaskan cara menjalankan AWS IoT Device SDK for Embedded C.

**Topics**
+ [Langkah 1: Instal AWS IoT Device SDK for Embedded C](#install-embedded-c-sdk)
+ [Langkah 2: Konfigurasikan aplikasi sampel](#iot-c-sdk-app-config)
+ [Langkah 3: Bangun dan jalankan aplikasi sampel](#iot-c-sdk-app-run)

## Langkah 1: Instal AWS IoT Device SDK for Embedded C
<a name="install-embedded-c-sdk"></a>

Umumnya AWS IoT Device SDK for Embedded C ditargetkan pada perangkat terbatas sumber daya yang memerlukan runtime bahasa C yang dioptimalkan. Anda dapat menggunakan SDK pada sistem operasi apa pun dan menghostingnya pada semua jenis prosesor (misalnya, MCUs dan MPUs). Jika Anda memiliki lebih banyak memori dan sumber daya pemrosesan yang tersedia, kami sarankan Anda menggunakan salah satu AWS IoT Perangkat dan Seluler tingkat tinggi SDKs (misalnya, C \$1\$1, Java JavaScript, dan Python).

Secara umum, AWS IoT Device SDK for Embedded C ini ditujukan untuk sistem yang menggunakan MCUs atau low-end MPUs yang menjalankan sistem operasi tertanam. Untuk contoh pemrograman di bagian ini, kami menganggap perangkat Anda menggunakan Linux.

**Example**  

1. Unduh AWS IoT Device SDK for Embedded C ke perangkat Anda dari [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C).

   ```
   git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules
   ```

   Ini membuat direktori bernama `aws-iot-device-sdk-embedded-c` dalam direktori saat ini.

1. Arahkan ke direktori itu dan periksa rilis terbaru. Silakan lihat [github. com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags)untuk tag rilis terbaru.

   ```
   cd aws-iot-device-sdk-embedded-c
   git checkout latest-release-tag
   ```

1. Instal OpenSSL versi 1.1.0 atau yang lebih baru. Library pengembangan OpenSSL biasanya disebut “libssl-dev” atau “openssl-devel” ketika diinstal melalui manajer paket.

   ```
   sudo apt-get install libssl-dev
   ```

## Langkah 2: Konfigurasikan aplikasi sampel
<a name="iot-c-sdk-app-config"></a>

 AWS IoT Device SDK for Embedded C Termasuk contoh aplikasi untuk Anda coba. Untuk kesederhanaan, tutorial ini menggunakan `mqtt_demo_mutual_auth` aplikasi, yang menggambarkan cara terhubung ke broker AWS IoT Core pesan dan berlangganan dan mempublikasikan ke topik MQTT.

1. Salin sertifikat dan kunci pribadi yang Anda buat [Memulai dengan AWS IoT Core tutorial](iot-gs.md) ke dalam `build/bin/certificates` direktori.
**catatan**  
Sertifikat CA perangkat dan root dapat kedaluwarsa atau dicabut. Jika sertifikat ini kedaluwarsa atau dicabut, Anda harus menyalin sertifikat CA baru atau kunci pribadi dan sertifikat perangkat ke perangkat Anda.

1. Anda harus mengonfigurasi sampel dengan AWS IoT Core titik akhir pribadi, kunci pribadi, sertifikat, dan sertifikat root CA Anda. Buka direktori `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth` tersebut.

   Jika Anda telah AWS CLI menginstal, Anda dapat menggunakan perintah ini untuk menemukan URL titik akhir akun Anda.

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

   Jika Anda belum AWS CLI menginstal, buka [AWS IoT konsol](https://console.aws.amazon.com/iot/home) Anda. Dari panel navigasi, pilih **Kelola**, lalu pilih **Things**. **Pilih IoT untuk perangkat Anda, lalu pilih Interact.** Titik akhir Anda ditampilkan di bagian **HTTPS** dari halaman detail hal.

1. Buka `demo_config.h` file dan perbarui nilai untuk yang berikut:  
AWS\$1IOT\$1TITIK AKHIR  
Titik akhir pribadi Anda.  
CLIENT\$1CERT\$1PATH  
Jalur file sertifikat Anda, misalnya`certificates/device.pem.crt"`.  
CLIENT\$1PRIVATE\$1KEY\$1PATH  
Nama file kunci pribadi Anda, misalnya`certificates/private.pem.key`.

   Misalnya:

   ```
   // Get from demo_config.h
   // =================================================
   #define AWS_IOT_ENDPOINT               "my-endpoint-ats.iot.us-east-1.amazonaws.com"
   #define AWS_MQTT_PORT                  8883
   #define CLIENT_IDENTIFIER              "testclient"
   #define ROOT_CA_CERT_PATH              "certificates/AmazonRootCA1.crt"
   #define CLIENT_CERT_PATH               "certificates/my-device-cert.pem.crt"
   #define CLIENT_PRIVATE_KEY_PATH        "certificates/my-device-private-key.pem.key"
   // =================================================
   ```

1. Periksa untuk melihat apakah Anda telah CMake menginstal pada perangkat Anda dengan menggunakan perintah ini.

   ```
   cmake --version
   ```

   Jika Anda melihat informasi versi untuk kompiler, Anda dapat melanjutkan ke bagian berikutnya.

   Jika Anda mendapatkan kesalahan atau tidak melihat informasi apa pun, maka Anda harus menginstal paket cmake menggunakan perintah ini.

   ```
   sudo apt-get install cmake
   ```

   Jalankan **cmake --version** perintah lagi dan konfirmasikan bahwa CMake telah diinstal dan Anda siap untuk melanjutkan.

1. Periksa untuk melihat apakah Anda memiliki alat pengembangan yang diinstal pada perangkat Anda dengan menggunakan perintah ini.

   ```
   gcc --version
   ```

   Jika Anda melihat informasi versi untuk kompiler, Anda dapat melanjutkan ke bagian berikutnya.

   Jika Anda mendapatkan kesalahan atau tidak melihat informasi kompiler, Anda harus menginstal `build-essential` paket menggunakan perintah ini.

   ```
   sudo apt-get install build-essential
   ```

   Jalankan **gcc --version** perintah lagi dan konfirmasikan bahwa alat build telah diinstal dan Anda siap untuk melanjutkan.

## Langkah 3: Bangun dan jalankan aplikasi sampel
<a name="iot-c-sdk-app-run"></a>

Prosedur ini menjelaskan cara membuat `mqtt_demo_mutual_auth` aplikasi di perangkat Anda dan menghubungkannya ke [AWS IoT konsol](https://console.aws.amazon.com/iot/home) menggunakan. AWS IoT Device SDK for Embedded C

**Untuk menjalankan aplikasi AWS IoT Device SDK for Embedded C sampel**

1. Arahkan ke `aws-iot-device-sdk-embedded-c` dan buat direktori build.

   ```
   mkdir build && cd build
   ```

1. Masukkan CMake perintah berikut untuk menghasilkan Makefiles yang diperlukan untuk membangun.

   ```
   cmake ..  
   ```

1. Masukkan perintah berikut untuk membangun file aplikasi yang dapat dieksekusi.

   ```
   make
   ```

1. Jalankan `mqtt_demo_mutual_auth` aplikasi dengan perintah ini.

   ```
   cd bin
   ./mqtt_demo_mutual_auth
   ```

   Anda akan melihat output yang serupa dengan yang berikut:   
![\[Output baris perintah untuk menjalankan aplikasi AWS IoT Device SDK for Embedded C sampel.\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/images/successful-run2.png)

Perangkat Anda sekarang terhubung untuk AWS IoT menggunakan file AWS IoT Device SDK for Embedded C.

Anda juga dapat menggunakan AWS IoT konsol untuk melihat pesan MQTT yang diterbitkan oleh aplikasi sampel. Untuk informasi tentang cara menggunakan klien MQTT di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), lihat. [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md)

# Membuat AWS IoT aturan untuk merutekan data perangkat ke layanan lain
<a name="iot-rules-tutorial"></a>

Tutorial ini menunjukkan cara membuat dan menguji AWS IoT aturan menggunakan beberapa tindakan aturan yang lebih umum.

AWS IoT aturan mengirim data dari perangkat Anda ke AWS layanan lain. Mereka mendengarkan pesan MQTT tertentu, memformat data dalam muatan pesan, dan mengirim hasilnya ke layanan lain. AWS 

Kami menyarankan Anda mencoba ini dalam urutan yang ditampilkan di sini, bahkan jika tujuan Anda adalah membuat aturan yang menggunakan fungsi Lambda atau sesuatu yang lebih kompleks. Tutorial disajikan secara berurutan dari dasar hingga yang kompleks. Mereka menyajikan konsep baru secara bertahap untuk membantu Anda mempelajari konsep yang dapat Anda gunakan untuk membuat tindakan aturan yang tidak memiliki tutorial khusus.

**catatan**  
AWS IoT aturan membantu Anda mengirim data dari perangkat IoT Anda ke layanan lain AWS . Namun, untuk melakukannya dengan sukses, Anda memerlukan pengetahuan tentang layanan lain tempat Anda ingin mengirim data. Meskipun tutorial ini memberikan informasi yang diperlukan untuk menyelesaikan tugas, Anda mungkin merasa terbantu untuk mempelajari lebih lanjut tentang layanan yang ingin Anda kirimi data sebelum Anda menggunakannya dalam solusi Anda. Penjelasan rinci tentang AWS layanan lain berada di luar cakupan tutorial ini.

**Ikhtisar skenario tutorial**  
Skenario untuk tutorial ini adalah perangkat sensor cuaca yang secara berkala menerbitkan datanya. Ada banyak perangkat sensor seperti itu dalam sistem imajiner ini. Tutorial di bagian ini, bagaimanapun, fokus pada satu perangkat sambil menunjukkan bagaimana Anda dapat mengakomodasi beberapa sensor.

Tutorial di bagian ini menunjukkan cara menggunakan AWS IoT aturan untuk melakukan tugas-tugas berikut dengan sistem imajiner perangkat sensor cuaca ini.
+ 

**[Tutorial: Menerbitkan ulang pesan MQTT](iot-repub-rule.md)**  
Tutorial ini menunjukkan cara mempublikasikan ulang pesan MQTT yang diterima dari sensor cuaca sebagai pesan yang hanya berisi ID sensor dan nilai suhu. Ini hanya menggunakan AWS IoT Core layanan dan menunjukkan kueri SQL sederhana dan cara menggunakan klien MQTT untuk menguji aturan Anda.
+ 

**[Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)**  
Tutorial ini menunjukkan cara mengirim pesan SNS ketika nilai dari perangkat sensor cuaca melebihi nilai tertentu. Ini dibangun di atas konsep yang disajikan dalam tutorial sebelumnya dan menambahkan cara bekerja dengan AWS layanan lain, [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) (Amazon SNS).

  Jika Anda baru mengenal Amazon SNS, tinjau latihan [Memulai](https://docs.aws.amazon.com//sns/latest/dg/sns-getting-started.html) sebelum memulai tutorial ini. 
+ 

**[Tutorial: Menyimpan data perangkat dalam tabel DynamoDB](iot-ddb-rule.md)**  
Tutorial ini menunjukkan cara menyimpan data dari perangkat sensor cuaca dalam tabel database. Ini menggunakan pernyataan kueri aturan dan template substitusi untuk memformat data pesan untuk layanan tujuan, [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html).

  Jika Anda baru mengenal DynamoDB, tinjau latihan [Memulai](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) sebelum memulai tutorial ini.
+ 

**[Tutorial: Memformat notifikasi dengan menggunakan fungsi AWS Lambda](iot-lambda-rule.md)**  
Tutorial ini menunjukkan cara memanggil fungsi Lambda untuk memformat ulang data perangkat dan kemudian mengirimkannya sebagai pesan teks. Ia menambahkan skrip Python dan fungsi AWS SDK dalam [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)fungsi untuk memformat dengan data payload pesan dari perangkat sensor cuaca dan mengirim pesan teks.

  Jika Anda baru mengenal Lambda, tinjau latihan [Memulai](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) sebelum Anda memulai tutorial ini.

**AWS IoT ikhtisar aturan**  
Semua tutorial ini membuat AWS IoT aturan. 

Untuk AWS IoT aturan untuk mengirim data dari perangkat ke AWS layanan lain, ia menggunakan: 


+ Pernyataan kueri aturan yang terdiri dari:
  + Klausa SQL SELECT yang memilih dan memformat data dari payload pesan
  + Filter topik (objek FROM dalam pernyataan kueri aturan) yang mengidentifikasi pesan yang akan digunakan
  + Pernyataan kondisional opsional (klausa SQL WHERE) yang menentukan kondisi tertentu untuk bertindak
+ Setidaknya satu tindakan aturan

Perangkat mempublikasikan pesan ke topik MQTT. Filter topik dalam pernyataan SQL SELECT mengidentifikasi topik MQTT untuk menerapkan aturan. Bidang yang ditentukan dalam pernyataan SQL SELECT memformat data dari muatan pesan MQTT yang masuk untuk digunakan oleh tindakan aturan. Untuk daftar lengkap tindakan aturan, lihat [Tindakan AWS IoT aturan](iot-rule-actions.md).

**Topics**
+ [Tutorial: Menerbitkan ulang pesan MQTT](iot-repub-rule.md)
+ [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)
+ [Tutorial: Menyimpan data perangkat dalam tabel DynamoDB](iot-ddb-rule.md)
+ [Tutorial: Memformat notifikasi dengan menggunakan fungsi AWS Lambda](iot-lambda-rule.md)

# Tutorial: Menerbitkan ulang pesan MQTT
<a name="iot-repub-rule"></a>

Tutorial ini menunjukkan cara membuat AWS IoT aturan yang menerbitkan pesan MQTT ketika pesan MQTT tertentu diterima. Payload pesan yang masuk dapat dimodifikasi oleh aturan sebelum dipublikasikan. Ini memungkinkan untuk membuat pesan yang disesuaikan dengan aplikasi tertentu tanpa perlu mengubah perangkat Anda atau firmware-nya. Anda juga dapat menggunakan aspek pemfilteran aturan untuk mempublikasikan pesan hanya ketika kondisi tertentu terpenuhi.

Pesan yang diterbitkan ulang oleh aturan bertindak seperti pesan yang dikirim oleh AWS IoT perangkat atau klien lain. Perangkat dapat berlangganan pesan yang diterbitkan ulang dengan cara yang sama seperti mereka dapat berlangganan topik pesan MQTT lainnya.

**Apa yang akan Anda pelajari dalam tutorial ini:**
+ Cara menggunakan query SQL sederhana dan fungsi dalam pernyataan query aturan
+ Cara menggunakan klien MQTT untuk menguji aturan AWS IoT 

Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya.

**Topics**
+ [Tinjau topik dan aturan MQTT AWS IoT](#iot-repub-rule-mqtt)
+ [Langkah 1: Buat AWS IoT aturan untuk menerbitkan ulang pesan MQTT](#iot-repub-rule-define)
+ [Langkah 2: Uji aturan baru Anda](#iot-repub-rule-test)
+ [Langkah 3: Tinjau hasil dan langkah selanjutnya](#iot-repub-rule-review)

**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ 

**[Mengatur Akun AWS](setting-up.md)**  
Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini.
+ 

**Diulas [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md)**  
Pastikan Anda dapat menggunakan klien MQTT untuk berlangganan dan mempublikasikan ke suatu topik. Anda akan menggunakan klien MQTT untuk menguji aturan baru Anda dalam prosedur ini.

## Tinjau topik dan aturan MQTT AWS IoT
<a name="iot-repub-rule-mqtt"></a>

Sebelum berbicara tentang AWS IoT aturan, ada baiknya untuk memahami protokol MQTT. Dalam solusi IoT, protokol MQTT menawarkan beberapa keunggulan dibandingkan protokol komunikasi jaringan lainnya, seperti HTTP, yang menjadikannya pilihan populer untuk digunakan oleh perangkat IoT. Bagian ini mengulas aspek-aspek kunci dari MQTT karena mereka berlaku untuk tutorial ini. Untuk informasi tentang bagaimana MQTT dibandingkan dengan HTTP, lihat. [Memilih protokol aplikasi untuk komunikasi perangkat Anda](protocols.md#protocol-selection)

**Protokol MQTT**  
Protokol MQTT menggunakan model publish/subscribe komunikasi dengan hostnya. Untuk mengirim data, perangkat mempublikasikan pesan yang diidentifikasi berdasarkan topik ke broker AWS IoT pesan. Untuk menerima pesan dari broker pesan, perangkat berlangganan topik yang akan mereka terima dengan mengirimkan filter topik dalam permintaan berlangganan ke broker pesan. Mesin AWS IoT aturan menerima pesan MQTT dari broker pesan.

**AWS IoT aturan**  
AWS IoT aturan terdiri dari pernyataan kueri aturan dan satu atau lebih tindakan aturan. Ketika mesin AWS IoT aturan menerima pesan MQTT, elemen-elemen ini bertindak pada pesan sebagai berikut.
+ 

**Pernyataan kueri aturan**  
Pernyataan kueri aturan menjelaskan topik MQTT yang akan digunakan, menafsirkan data dari muatan pesan, dan memformat data seperti yang dijelaskan oleh pernyataan SQL yang mirip dengan pernyataan yang digunakan oleh database SQL populer. Hasil dari pernyataan query adalah data yang dikirim ke tindakan aturan.
+ 

**Tindakan aturan**  
Setiap tindakan aturan dalam aturan bertindak pada data yang dihasilkan dari pernyataan kueri aturan. AWS IoT mendukung [banyak tindakan aturan](iot-rule-actions.md). Namun, dalam tutorial ini, Anda akan berkonsentrasi pada tindakan [Publikasikan ulang](republish-rule-action.md) aturan, yang menerbitkan hasil pernyataan kueri sebagai pesan MQTT dengan topik tertentu.

## Langkah 1: Buat AWS IoT aturan untuk menerbitkan ulang pesan MQTT
<a name="iot-repub-rule-define"></a>

 AWS IoT Aturan yang akan Anda buat dalam tutorial ini berlangganan topik `device/device_id/data` MQTT di *device\$1id* mana ID perangkat yang mengirim pesan. Topik-topik ini dijelaskan oleh [filter topik](topics.md#topicfilters) sebagai`device/+/data`, di mana `+` adalah karakter wildcard yang cocok dengan string apa pun di antara dua karakter garis miring ke depan.

Ketika aturan menerima pesan dari topik yang cocok, aturan akan menerbitkan kembali `device_id` dan `temperature` nilai sebagai pesan MQTT baru dengan topik tersebut. `device/data/temp` 

Misalnya, muatan pesan MQTT dengan `device/22/data` topik terlihat seperti ini:

```
{
  "temperature": 28,
  "humidity": 80,
  "barometer": 1013,
  "wind": {
    "velocity": 22,
    "bearing": 255
  }
}
```

Aturan mengambil `temperature` nilai dari payload pesan, dan `device_id` dari topik, dan menerbitkannya kembali sebagai pesan MQTT dengan `device/data/temp` topik dan muatan pesan yang terlihat seperti ini:

```
{
  "device_id": "22",
  "temperature": 28
}
```

Dengan aturan ini, perangkat yang hanya memerlukan ID perangkat dan data suhu berlangganan `device/data/temp` topik untuk hanya menerima informasi itu.

**Untuk membuat aturan yang menerbitkan kembali pesan MQTT**

1. Buka [hub **Aturan**AWS IoT konsol](https://console.aws.amazon.com//iot/home#/rulehub).

1. Di **Aturan**, pilih **Buat** dan mulai membuat aturan baru Anda.

1. Di bagian atas **Buat aturan**:

   1. Di **Nama**, masukkan nama aturan. Untuk tutorial ini, beri nama**republish\$1temp**.

      Ingat bahwa nama aturan harus unik dalam Akun dan Wilayah Anda, dan tidak dapat memiliki spasi apa pun. Kami telah menggunakan karakter garis bawah dalam nama ini untuk memisahkan dua kata dalam nama aturan.

   1.  Dalam **Deskripsi**, jelaskan aturannya. 

      Deskripsi yang bermakna membantu Anda mengingat apa yang dilakukan aturan ini dan mengapa Anda membuatnya. Deskripsi bisa selama dibutuhkan, jadi sedetail mungkin. 

1. Dalam **pernyataan kueri Aturan** **Buat aturan**:

   1.  Dalam **Menggunakan versi SQL**, pilih**2016-03-23**. 

   1. Dalam kotak edit **pernyataan kueri aturan**, masukkan pernyataan: 

      ```
      SELECT topic(2) as device_id, temperature FROM 'device/+/data'
      ```

      Pernyataan ini:
      + Mendengarkan pesan MQTT dengan topik yang cocok dengan filter topik. `device/+/data`
      + Memilih elemen kedua dari string topik dan menugaskannya ke bidang. `device_id`
      + Memilih `temperature` bidang nilai dari payload pesan dan menetapkannya ke bidang. `temperature`

1. Di **Tetapkan satu atau lebih tindakan**:

   1. Untuk membuka daftar tindakan aturan untuk aturan ini, pilih **Tambah tindakan**.

   1. Di **Pilih tindakan**, pilih **Menerbitkan ulang pesan ke AWS IoT topik**.

   1. Di bagian bawah daftar tindakan, pilih **Konfigurasi tindakan** untuk membuka halaman konfigurasi tindakan yang dipilih.

1. Dalam **tindakan Konfigurasi**:

   1.  Di **Topik**, masukkan**device/data/temp**. Ini adalah topik MQTT dari pesan yang akan dipublikasikan oleh aturan ini. 

   1.  Di **Quality of Service**, pilih **0 - Pesan dikirim nol kali atau lebih**. 

   1.  Di **Pilih atau buat peran untuk memberikan AWS IoT akses untuk melakukan tindakan ini**:

      1.  Pilih **Buat Peran**. Kotak dialog **Buat peran baru** terbuka. 

      1. Masukkan nama yang menggambarkan peran baru. Dalam tutorial ini, gunakan**republish\$1role**. 

         Saat Anda membuat peran baru, kebijakan yang benar untuk melakukan tindakan aturan dibuat dan dilampirkan ke peran baru. Jika Anda mengubah topik tindakan aturan ini atau menggunakan peran ini dalam tindakan aturan lain, Anda harus memperbarui kebijakan untuk peran tersebut guna mengotorisasi topik atau tindakan baru. Untuk memperbarui peran yang ada, pilih **Perbarui peran** di bagian ini.

      1. Pilih **Buat Peran** untuk membuat peran dan menutup kotak dialog. 

   1. Pilih **Tambahkan tindakan** untuk menambahkan tindakan ke aturan dan kembali ke halaman **Buat aturan**. 

1. **Menerbitkan ulang pesan ke tindakan AWS IoT topik** sekarang tercantum dalam **Tetapkan satu atau beberapa tindakan**.

   Di ubin tindakan baru, di bawah **Publikasikan ulang pesan ke suatu AWS IoT topik**, Anda dapat melihat topik yang akan dipublikasikan oleh tindakan penerbitan ulang Anda.

   Ini adalah satu-satunya tindakan aturan yang akan Anda tambahkan ke aturan ini.

1. Di **Buat aturan**, gulir ke bawah ke bawah dan pilih **Buat aturan** untuk membuat aturan dan selesaikan langkah ini.

## Langkah 2: Uji aturan baru Anda
<a name="iot-repub-rule-test"></a>

Untuk menguji aturan baru Anda, Anda akan menggunakan klien MQTT untuk mempublikasikan dan berlangganan pesan MQTT yang digunakan oleh aturan ini.

Buka [klien MQTT di AWS IoT konsol di jendela](https://console.aws.amazon.com//iot/home#/test) baru. Ini akan memungkinkan Anda mengedit aturan tanpa kehilangan konfigurasi klien MQTT Anda. Klien MQTT tidak menyimpan langganan atau log pesan apa pun jika Anda membiarkannya pergi ke halaman lain di konsol.

**Untuk menggunakan klien MQTT untuk menguji aturan Anda**

1. Di [klien MQTT di AWS IoT konsol](https://console.aws.amazon.com//iot/home#/test), berlangganan topik input, dalam hal ini,. `device/+/data`

   1. Di klien MQTT, di bawah **Langganan, pilih **Berlangganan**** topik.

   1. Dalam **topik Langganan**, masukkan topik filter topik masukan,**device/\$1/data**.

   1. Simpan sisa bidang di pengaturan defaultnya.

   1. Pilih **Berlangganan topik**.

      Di kolom **Langganan**, di bawah **Publikasikan ke topik**, **device/\$1/data** muncul. 

1. Berlangganan topik yang akan diterbitkan oleh aturan Anda:`device/data/temp`.

   1. Di bawah **Langganan****, pilih Berlangganan topik** lagi, dan dalam **topik Langganan**, masukkan topik pesan yang diterbitkan ulang,. **device/data/temp**

   1. Simpan sisa bidang di pengaturan defaultnya.

   1. Pilih **Berlangganan topik**.

      Di kolom **Langganan**, di bawah **perangkat/\$1/data, muncul**. **device/data/temp** 

1. Publikasikan pesan ke topik input dengan ID perangkat tertentu,**device/22/data**. Anda tidak dapat mempublikasikan ke topik MQTT yang berisi karakter wildcard.

   1. **Di klien MQTT, di bawah **Langganan**, pilih Publikasikan ke topik.**

   1. Di bidang **Publikasikan**, masukkan nama topik masukan,**device/22/data**.

   1. Salin data sampel yang ditampilkan di sini dan, di kotak edit di bawah nama topik, tempel data sampel.

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Untuk mengirim pesan MQTT Anda, pilih **Publikasikan** ke topik.

1. Tinjau pesan yang dikirim.

   1. Di klien MQTT, di bawah **Langganan**, ada titik hijau di sebelah dua topik yang Anda berlangganan sebelumnya.

      Titik-titik hijau menunjukkan bahwa satu atau lebih pesan baru telah diterima sejak terakhir kali Anda melihatnya.

   1. Di bawah **Langganan**, pilih **perangkat/\$1/data** untuk memeriksa apakah muatan pesan cocok dengan apa yang baru saja Anda terbitkan dan terlihat seperti ini:

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Di bawah **Langganan**, pilih **device/data/temp**untuk memeriksa apakah payload pesan yang dipublikasikan ulang terlihat seperti ini:

      ```
      {
        "device_id": "22",  
        "temperature": 28
      }
      ```

      Perhatikan bahwa `device_id` nilainya adalah string yang dikutip dan `temperature` nilainya numerik. Hal ini karena [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic)fungsi mengekstrak string dari nama topik pesan masukan sementara `temperature` nilai menggunakan nilai numerik dari payload pesan masukan.

      Jika Anda ingin membuat nilai `device_id` nilai numerik, ganti `topic(2)` dalam pernyataan kueri aturan dengan:

      ```
      cast(topic(2) AS DECIMAL)
      ```

      Perhatikan bahwa `topic(2)` mentransmisikan nilai ke nilai numerik hanya akan berfungsi jika bagian topik tersebut hanya berisi karakter numerik.

1. Jika Anda melihat bahwa pesan yang benar dipublikasikan ke **device/data/temp**topik, maka aturan Anda berfungsi. Lihat apa lagi yang dapat Anda pelajari tentang tindakan aturan Publikasikan ulang di bagian berikutnya.

   Jika Anda tidak melihat bahwa pesan yang benar telah dipublikasikan ke **perangkat/\$1/data** atau **device/data/temp**topik, periksa tips pemecahan masalah.

### Memecahkan masalah aturan pesan Republish
<a name="iot-repub-rule-trouble"></a>

Berikut adalah beberapa hal untuk diperiksa jika Anda tidak melihat hasil yang Anda harapkan.
+ 

**Anda mendapat spanduk kesalahan**  
Jika kesalahan muncul saat Anda mempublikasikan pesan input, perbaiki kesalahan itu terlebih dahulu. Langkah-langkah berikut dapat membantu Anda memperbaiki kesalahan itu.
+ 

**Anda tidak melihat pesan masukan di klien MQTT**  
Setiap kali Anda mempublikasikan pesan masukan ke `device/22/data` topik, pesan itu akan muncul di klien MQTT jika Anda berlangganan filter `device/+/data` topik seperti yang dijelaskan dalam prosedur.

**Hal-hal yang harus diperiksa**
  + 

**Periksa filter topik yang Anda langgani**  
Jika Anda berlangganan topik pesan input seperti yang dijelaskan dalam prosedur, Anda akan melihat salinan pesan input setiap kali Anda mempublikasikannya.

    Jika Anda tidak melihat pesan, periksa nama topik yang Anda langgani dan bandingkan dengan topik yang Anda terbitkan. Nama topik peka huruf besar/kecil dan topik yang Anda langgani harus identik dengan topik yang Anda publikasikan payload pesan.
  + 

**Periksa fungsi publikasi pesan**  
**Di klien MQTT, di bawah **Langganan**, pilih **perangkat/\$1/data**, periksa topik pesan terbitkan, lalu pilih Publikasikan ke topik.** Anda akan melihat payload pesan dari kotak edit di bawah topik yang muncul di daftar pesan. 
+ 

**Anda tidak melihat pesan yang diterbitkan ulang di klien MQTT**  
Agar aturan Anda berfungsi, ia harus memiliki kebijakan yang benar yang mengizinkannya untuk menerima dan menerbitkan ulang pesan dan harus menerima pesan.

**Hal-hal yang harus diperiksa**
  + 

**Periksa klien MQTT Anda dan aturan yang Anda buat Wilayah AWS**  
Konsol tempat Anda menjalankan klien MQTT harus berada di AWS Wilayah yang sama dengan aturan yang Anda buat. 
  + 

**Periksa topik pesan masukan dalam pernyataan kueri aturan**  
Agar aturan berfungsi, aturan harus menerima pesan dengan nama topik yang cocok dengan filter topik dalam klausa FROM dari pernyataan kueri aturan.

    Periksa ejaan filter topik dalam pernyataan kueri aturan dengan topik di klien MQTT. Nama topik peka huruf besar/kecil dan topik pesan harus cocok dengan filter topik dalam pernyataan kueri aturan.
  + 

**Periksa isi payload pesan masukan**  
Agar aturan berfungsi, ia harus menemukan bidang data di payload pesan yang dideklarasikan dalam pernyataan SELECT.

    Periksa ejaan `temperature` bidang dalam pernyataan kueri aturan dengan payload pesan di klien MQTT. Nama bidang peka huruf besar/kecil dan `temperature` bidang dalam pernyataan kueri aturan harus identik dengan `temperature` bidang di payload pesan.

    Pastikan dokumen JSON di payload pesan diformat dengan benar. Jika JSON memiliki kesalahan, seperti koma yang hilang, aturan tidak akan dapat membacanya. 
  + 

**Periksa topik pesan yang diterbitkan ulang dalam tindakan aturan**  
Topik di mana tindakan aturan Republish menerbitkan pesan baru harus sesuai dengan topik yang Anda berlangganan di klien MQTT.

    Buka aturan yang Anda buat di konsol dan periksa topik di mana tindakan aturan akan menerbitkan ulang pesan.
  + 

**Periksa peran yang digunakan oleh aturan**  
Tindakan aturan harus memiliki izin untuk menerima topik asli dan mempublikasikan topik baru. 

    Kebijakan yang mengizinkan aturan untuk menerima data pesan dan mempublikasikannya khusus untuk topik yang digunakan. Jika mengubah topik yang digunakan untuk memublikasikan ulang data pesan, Anda harus memperbarui peran tindakan aturan untuk memperbarui kebijakannya agar sesuai dengan topik saat ini.

    Jika Anda mencurigai ini masalahnya, edit tindakan aturan Republish dan buat peran baru. Peran baru yang dibuat oleh tindakan aturan menerima otorisasi yang diperlukan untuk melakukan tindakan ini.

## Langkah 3: Tinjau hasil dan langkah selanjutnya
<a name="iot-repub-rule-review"></a>

**Dalam tutorial ini**
+ Anda menggunakan query SQL sederhana dan beberapa fungsi dalam pernyataan query aturan untuk menghasilkan pesan MQTT baru.
+ Anda membuat aturan yang menerbitkan ulang pesan baru itu.
+ Anda menggunakan klien MQTT untuk menguji aturan Anda. AWS IoT 

**Langkah selanjutnya**  
Setelah Anda menerbitkan ulang beberapa pesan dengan aturan ini, cobalah bereksperimen dengannya untuk melihat bagaimana mengubah beberapa aspek tutorial memengaruhi pesan yang diterbitkan ulang. Berikut adalah beberapa ide untuk Anda mulai.
+ Ubah topik pesan masukan dan amati efeknya dalam payload pesan yang diterbitkan ulang. *device\$1id*
+ Ubah bidang yang dipilih dalam pernyataan kueri aturan dan amati efeknya dalam payload pesan yang diterbitkan ulang.
+ Coba tutorial berikutnya dalam seri ini dan pelajari caranya[Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md).

Tindakan aturan Republish yang digunakan dalam tutorial ini juga dapat membantu Anda men-debug pernyataan kueri aturan. Misalnya, Anda dapat menambahkan tindakan ini ke aturan untuk melihat bagaimana pernyataan kueri aturannya memformat data yang digunakan oleh tindakan aturannya.

# Tutorial: Mengirim notifikasi Amazon SNS
<a name="iot-sns-rule"></a>

Tutorial ini menunjukkan cara membuat AWS IoT aturan yang mengirimkan data pesan MQTT ke topik Amazon SNS sehingga dapat dikirim sebagai pesan teks SMS. 

Dalam tutorial ini, Anda membuat aturan yang mengirimkan data pesan dari sensor cuaca ke semua pelanggan topik Amazon SNS, setiap kali suhu melebihi nilai yang ditetapkan dalam aturan. Aturan mendeteksi ketika suhu yang dilaporkan melebihi nilai yang ditetapkan oleh aturan, dan kemudian membuat muatan pesan baru yang hanya mencakup ID perangkat, suhu yang dilaporkan, dan batas suhu yang terlampaui. Aturan mengirimkan payload pesan baru sebagai dokumen JSON ke topik SNS, yang memberi tahu semua pelanggan ke topik SNS.

**Apa yang akan Anda pelajari dalam tutorial ini:**
+ Cara membuat dan menguji notifikasi Amazon SNS
+ Cara memanggil notifikasi Amazon SNS dari suatu aturan AWS IoT 
+ Cara menggunakan query SQL sederhana dan fungsi dalam pernyataan query aturan
+ Cara menggunakan klien MQTT untuk menguji aturan AWS IoT 

Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya.

**Topics**
+ [Langkah 1: Buat topik Amazon SNS yang mengirim pesan teks SMS](#iot-sns-rule-create-sns-topic)
+ [Langkah 2: Buat AWS IoT aturan untuk mengirim pesan teks](#iot-sns-rule-create-rule)
+ [Langkah 3: Uji AWS IoT aturan dan pemberitahuan Amazon SNS](#iot-sns-rule-test-rule)
+ [Langkah 4: Tinjau hasil dan langkah selanjutnya](#iot-sns-rule-review-results)

**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ 

**[Mengatur Akun AWS](setting-up.md)**  
Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini.
+ 

**Diulas [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md)**  
Pastikan Anda dapat menggunakan klien MQTT untuk berlangganan dan mempublikasikan ke suatu topik. Anda akan menggunakan klien MQTT untuk menguji aturan baru Anda dalam prosedur ini.
+ 

**Meninjau [Layanan Pemberitahuan Sederhana Amazon](https://docs.aws.amazon.com//sns/latest/dg/welcome.html)**  
Jika Anda belum pernah menggunakan Amazon SNS sebelumnya, tinjau [Menyiapkan akses untuk Amazon SNS](https://docs.aws.amazon.com//sns/latest/dg/sns-setting-up.html). Jika Anda sudah menyelesaikan AWS IoT tutorial lain, Anda Akun AWS harus sudah dikonfigurasi dengan benar.

## Langkah 1: Buat topik Amazon SNS yang mengirim pesan teks SMS
<a name="iot-sns-rule-create-sns-topic"></a>

Prosedur ini menjelaskan cara membuat topik Amazon SNS yang dapat dikirimkan oleh sensor cuaca Anda. Topik Amazon SNS kemudian akan memberi tahu semua pelanggannya melalui pesan teks SMS tentang batas suhu yang terlampaui.

**Untuk membuat topik Amazon SNS yang mengirim pesan teks SMS**

1. **Buat topik Amazon SNS.**

   1. Masuk ke [konsol Amazon SNS](https://console.aws.amazon.com//sns/home).

   1. Di panel navigasi kiri, pilih **Topics (Topik)**.

   1. Di halaman **Topics (Topik)**, pilih **Create topic (Buat topik)**.

   1. Di **Detail**, pilih tipe **Standar**. Secara default, konsol membuat topik FIFO.

   1. Di **Nama**, masukkan nama topik SNS. Untuk tutorial ini, masukkan **high\$1temp\$1notice**.

   1. Gulir ke akhir halaman dan pilih **Buat topik**.

      Konsol membuka halaman **Detail** topik baru.

1. **Buat langganan Amazon SNS.**
**catatan**  
Nomor telepon yang Anda gunakan dalam langganan ini mungkin dikenakan biaya pesan teks dari pesan yang akan Anda kirim dalam tutorial ini.

   1. **Di halaman detail topik **high\$1temp\$1notice**, pilih Buat langganan.**

   1. Di **Buat langganan**, di bagian **Detail**, dalam daftar **Protokol**, pilih **SMS**.

   1. Di **Endpoint**, masukkan nomor telepon yang dapat menerima pesan teks. Pastikan untuk memasukkannya sedemikian rupa sehingga dimulai dengan`+`, termasuk kode negara dan area, dan tidak menyertakan karakter tanda baca lainnya.

   1. Pilih **Buat langganan**.

1. **Uji notifikasi Amazon SNS.**

   1. **Di [konsol Amazon SNS](https://console.aws.amazon.com//sns/home), di panel navigasi kiri, pilih Topik.**

   1. Untuk membuka halaman detail topik, di **Topik, dalam daftar topik**, pilih **high\$1temp\$1notice**.

   1. **Untuk membuka halaman **Publikasikan pesan ke topik**, di halaman detail **high\$1temp\$1notice**, pilih Publikasikan pesan.**

   1. **Di **Publikasikan pesan ke topik**, di bagian Isi **pesan, di Badan pesan untuk dikirim ke titik akhir**, masukkan pesan singkat.**

   1. Gulir ke bawah ke bagian bawah halaman dan pilih **Publikasikan pesan**.

   1. Di telepon dengan nomor yang Anda gunakan sebelumnya saat membuat langganan, konfirmasikan bahwa pesan telah diterima.

   Jika Anda tidak menerima pesan tes, periksa kembali nomor telepon dan pengaturan telepon Anda.

   Pastikan Anda dapat mempublikasikan pesan pengujian dari [konsol Amazon SNS](https://console.aws.amazon.com//sns/home) sebelum melanjutkan tutorial.

## Langkah 2: Buat AWS IoT aturan untuk mengirim pesan teks
<a name="iot-sns-rule-create-rule"></a>

 AWS IoT Aturan yang akan Anda buat dalam tutorial ini berlangganan topik `device/device_id/data` MQTT di `device_id` mana ID perangkat yang mengirim pesan. Topik-topik ini dijelaskan dalam filter topik sebagai`device/+/data`, di mana `+` adalah karakter wildcard yang cocok dengan string apa pun di antara dua karakter garis miring ke depan. Aturan ini juga menguji nilai `temperature` bidang dalam payload pesan.

Saat aturan menerima pesan dari topik yang cocok, aturan akan mengambil `device_id` dari nama topik, `temperature` nilai dari payload pesan, dan menambahkan nilai konstan untuk batas pengujian, dan mengirimkan nilai ini sebagai dokumen JSON ke topik notifikasi Amazon SNS. 

 Misalnya, pesan MQTT dari perangkat sensor cuaca nomor 32 menggunakan `device/32/data` topik dan memiliki muatan pesan yang terlihat seperti ini: 

```
{
  "temperature": 38,
  "humidity": 80,
  "barometer": 1013,
  "wind": {
    "velocity": 22,
    "bearing": 255
  }
}
```

Pernyataan kueri aturan mengambil `temperature` nilai dari payload pesan, `device_id` dari nama topik, dan menambahkan `max_temperature` nilai konstan untuk mengirim payload pesan yang terlihat seperti ini ke topik Amazon SNS: 

```
{
  "device_id": "32",
  "reported_temperature": 38,
  "max_temperature": 30
}
```

**Untuk membuat AWS IoT aturan untuk mendeteksi nilai suhu over-limit dan membuat data untuk dikirim ke topik Amazon SNS**

1. Buka [hub **Aturan**AWS IoT konsol](https://console.aws.amazon.com//iot/home#/rulehub).

1. Jika ini adalah aturan pertama Anda, pilih **Buat**, atau **Buat aturan**.

1. Di **Buat aturan**:

   1. Di **Nama**, masukkan **temp\$1limit\$1notify**.

      Ingat bahwa nama aturan harus unik di dalam Anda Akun AWS dan Wilayah, dan tidak dapat memiliki spasi apa pun. Kami telah menggunakan karakter garis bawah dalam nama ini untuk memisahkan kata-kata dalam nama aturan. 

   1. Dalam **Deskripsi**, jelaskan aturannya.

      Deskripsi yang bermakna membuatnya lebih mudah untuk mengingat apa yang dilakukan aturan ini dan mengapa Anda membuatnya. Deskripsi bisa selama dibutuhkan, jadi sedetail mungkin. 

1. Dalam **pernyataan kueri Aturan** **Buat aturan**:

   1.  Dalam **Menggunakan versi SQL**, pilih **2016-03-23**. 

   1. Dalam kotak edit **pernyataan kueri aturan**, masukkan pernyataan: 

      ```
      SELECT topic(2) as device_id, 
          temperature as reported_temperature, 
          30 as max_temperature 
        FROM 'device/+/data' 
        WHERE temperature > 30
      ```

      Pernyataan ini:
      + Mendengarkan pesan MQTT dengan topik yang cocok dengan filter `device/+/data` topik dan yang memiliki `temperature` nilai lebih besar dari 30. 
      + Memilih elemen kedua dari string topik dan menetapkannya ke bidang. `device_id`
      + Memilih `temperature` bidang nilai dari payload pesan dan menetapkannya ke bidang. `reported_temperature` 
      + Menciptakan nilai konstan `30` untuk mewakili nilai batas dan menetapkannya ke `max_temperature` bidang. 

1. Untuk membuka daftar tindakan aturan untuk aturan ini, di **Tetapkan satu atau beberapa tindakan**, pilih **Tambah tindakan**.

1. Di **Pilih tindakan**, pilih **Kirim pesan sebagai pemberitahuan push SNS**.

1. Untuk membuka halaman konfigurasi tindakan yang dipilih, di bagian bawah daftar tindakan, pilih **Konfigurasi tindakan**. 

1. Dalam **tindakan Konfigurasi**:

   1. **Di **target SNS**, **pilih Pilih**, temukan topik SNS Anda bernama **high\$1temp\$1notice**, dan pilih Select.**

   1. Dalam **format Pesan**, pilih **RAW**.

   1. Di **Pilih atau buat peran untuk memberikan AWS IoT akses untuk melakukan tindakan ini**, pilih **Buat Peran**.

   1. Di **Buat peran baru**, di **Nama**, masukkan nama unik untuk peran baru. Untuk tutorial ini, gunakan **sns\$1rule\$1role**.

   1. Pilih **Buat peran**.

   Jika Anda mengulangi tutorial ini atau menggunakan kembali peran yang ada, pilih **Perbarui peran sebelum melanjutkan**. Ini memperbarui dokumen kebijakan peran agar berfungsi dengan target SNS.

1. Pilih **Tambah tindakan** dan kembali ke halaman **Buat aturan**.

   Di ubin tindakan baru, di bawah **Kirim pesan sebagai pemberitahuan push SNS**, Anda dapat melihat topik SNS yang akan dipanggil aturan Anda. 

   Ini adalah satu-satunya tindakan aturan yang akan Anda tambahkan ke aturan ini.

1. Untuk membuat aturan dan menyelesaikan langkah ini, di **Buat aturan**, gulir ke bawah ke bawah dan pilih **Buat aturan**.

## Langkah 3: Uji AWS IoT aturan dan pemberitahuan Amazon SNS
<a name="iot-sns-rule-test-rule"></a>

Untuk menguji aturan baru Anda, Anda akan menggunakan klien MQTT untuk mempublikasikan dan berlangganan pesan MQTT yang digunakan oleh aturan ini.

Buka [klien MQTT di AWS IoT konsol di jendela](https://console.aws.amazon.com//iot/home#/test) baru. Ini akan memungkinkan Anda mengedit aturan tanpa kehilangan konfigurasi klien MQTT Anda. Jika Anda meninggalkan klien MQTT untuk membuka halaman lain di konsol, itu tidak akan menyimpan langganan atau log pesan apa pun.

**Untuk menggunakan klien MQTT untuk menguji aturan Anda**

1. Di [klien MQTT di AWS IoT konsol](https://console.aws.amazon.com//iot/home#/test), berlangganan topik input, dalam hal ini,. `device/+/data`

   1. Di klien MQTT, di bawah **Langganan, pilih **Berlangganan**** topik.

   1. Dalam **topik Langganan**, masukkan topik filter topik masukan,**device/\$1/data**.

   1. Simpan sisa bidang di pengaturan defaultnya.

   1. Pilih **Berlangganan topik**.

      Di kolom **Langganan**, di bawah **Publikasikan ke topik**, **device/\$1/data** muncul. 

1. Publikasikan pesan ke topik input dengan ID perangkat tertentu,**device/32/data**. Anda tidak dapat mempublikasikan ke topik MQTT yang berisi karakter wildcard.

   1. **Di klien MQTT, di bawah **Langganan**, pilih Publikasikan ke topik.**

   1. Di bidang **Publikasikan**, masukkan nama topik masukan,**device/32/data**.

   1. Salin data sampel yang ditampilkan di sini dan, di kotak edit di bawah nama topik, tempel data sampel.

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Pilih **Publikasikan ke topik** untuk mempublikasikan pesan MQTT Anda.

1. Konfirmasikan bahwa pesan teks telah dikirim.

   1. Di klien MQTT, di bawah **Langganan**, ada titik hijau di sebelah topik yang Anda berlangganan sebelumnya.

      Titik hijau menunjukkan bahwa satu atau lebih pesan baru telah diterima sejak terakhir kali Anda melihatnya.

   1. Di bawah **Langganan**, pilih **perangkat/\$1/data** untuk memeriksa apakah muatan pesan cocok dengan apa yang baru saja Anda terbitkan dan terlihat seperti ini:

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Periksa ponsel yang Anda gunakan untuk berlangganan topik SNS dan konfirmasikan isi payload pesan terlihat seperti ini:

      ```
      {"device_id":"32","reported_temperature":38,"max_temperature":30}
      ```

      Perhatikan bahwa `device_id` nilainya adalah string yang dikutip dan `temperature` nilainya numerik. Hal ini karena [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic)fungsi mengekstrak string dari nama topik pesan masukan sementara `temperature` nilai menggunakan nilai numerik dari payload pesan masukan.

      Jika Anda ingin membuat nilai `device_id` nilai numerik, ganti `topic(2)` dalam pernyataan kueri aturan dengan:

      ```
      cast(topic(2) AS DECIMAL)
      ```

      Perhatikan bahwa `topic(2)` mentransmisikan nilai ke numerik, `DECIMAL` nilai hanya akan berfungsi jika bagian topik tersebut hanya berisi karakter numerik.

1. Coba kirim pesan MQTT di mana suhunya tidak melebihi batas.

   1. **Di klien MQTT, di bawah **Langganan**, pilih Publikasikan ke topik.**

   1. Di bidang **Publikasikan**, masukkan nama topik masukan,**device/33/data**.

   1. Salin data sampel yang ditampilkan di sini dan, di kotak edit di bawah nama topik, tempel data sampel.

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Untuk mengirim pesan MQTT Anda, pilih **Publikasikan** ke topik.

   Anda akan melihat pesan yang Anda kirim dalam **device/\$1/data** langganan. Namun, karena nilai suhu di bawah suhu maks dalam pernyataan kueri aturan, Anda seharusnya tidak menerima pesan teks.

   Jika Anda tidak melihat perilaku yang benar, periksa tips pemecahan masalah.

### Memecahkan masalah aturan pesan SNS Anda
<a name="iot-sns-rule-trouble"></a>

Berikut adalah beberapa hal untuk diperiksa, jika Anda tidak melihat hasil yang Anda harapkan.
+ 

**Anda mendapat spanduk kesalahan**  
Jika kesalahan muncul saat Anda mempublikasikan pesan input, perbaiki kesalahan itu terlebih dahulu. Langkah-langkah berikut dapat membantu Anda memperbaiki kesalahan itu.
+ 

**Anda tidak melihat pesan masukan di klien MQTT**  
Setiap kali Anda mempublikasikan pesan masukan Anda ke `device/22/data` topik, pesan itu akan muncul di klien MQTT, jika Anda berlangganan filter `device/+/data` topik seperti yang dijelaskan dalam prosedur.

**Hal-hal yang harus diperiksa**
  + 

**Periksa filter topik yang Anda langgani**  
Jika Anda berlangganan topik pesan input seperti yang dijelaskan dalam prosedur, Anda akan melihat salinan pesan input setiap kali Anda mempublikasikannya.

    Jika Anda tidak melihat pesan, periksa nama topik yang Anda langgani dan bandingkan dengan topik yang Anda terbitkan. Nama topik peka huruf besar/kecil dan topik yang Anda langgani harus identik dengan topik yang Anda publikasikan payload pesan.
  + 

**Periksa fungsi publikasi pesan**  
**Di klien MQTT, di bawah **Langganan**, pilih **perangkat/\$1/data**, periksa topik pesan terbitkan, lalu pilih Publikasikan ke topik.** Anda akan melihat payload pesan dari kotak edit di bawah topik yang muncul di daftar pesan. 
+ 

**Anda tidak menerima pesan SMS**  
Agar aturan Anda berfungsi, itu harus memiliki kebijakan yang benar yang mengizinkannya untuk menerima pesan dan mengirim pemberitahuan SNS, dan itu harus menerima pesan.

**Hal-hal yang harus diperiksa**
  + 

**Periksa klien MQTT Anda dan aturan yang Anda buat Wilayah AWS**  
Konsol tempat Anda menjalankan klien MQTT harus berada di AWS Wilayah yang sama dengan aturan yang Anda buat.
  + 

**Periksa apakah nilai suhu dalam muatan pesan melebihi ambang uji**  
Jika nilai suhu kurang dari atau sama dengan 30, seperti yang didefinisikan dalam pernyataan kueri aturan, aturan tidak akan melakukan tindakannya.
  + 

**Periksa topik pesan masukan dalam pernyataan kueri aturan**  
Agar aturan berfungsi, aturan harus menerima pesan dengan nama topik yang cocok dengan filter topik dalam klausa FROM dari pernyataan kueri aturan.

    Periksa ejaan filter topik dalam pernyataan kueri aturan dengan topik di klien MQTT. Nama topik peka huruf besar/kecil dan topik pesan harus cocok dengan filter topik dalam pernyataan kueri aturan.
  + 

**Periksa isi payload pesan masukan**  
Agar aturan berfungsi, ia harus menemukan bidang data di payload pesan yang dideklarasikan dalam pernyataan SELECT.

    Periksa ejaan `temperature` bidang dalam pernyataan kueri aturan dengan payload pesan di klien MQTT. Nama bidang peka huruf besar/kecil dan `temperature` bidang dalam pernyataan kueri aturan harus identik dengan `temperature` bidang di payload pesan.

    Pastikan dokumen JSON di payload pesan diformat dengan benar. Jika JSON memiliki kesalahan, seperti koma yang hilang, aturan tidak akan dapat membacanya.
  + 

**Periksa topik pesan yang diterbitkan ulang dalam tindakan aturan**  
Topik di mana tindakan aturan Republish menerbitkan pesan baru harus sesuai dengan topik yang Anda berlangganan di klien MQTT.

    Buka aturan yang Anda buat di konsol dan periksa topik di mana tindakan aturan akan menerbitkan ulang pesan.
  + 

**Periksa peran yang digunakan oleh aturan**  
Tindakan aturan harus memiliki izin untuk menerima topik asli dan mempublikasikan topik baru. 

    Kebijakan yang mengizinkan aturan untuk menerima data pesan dan mempublikasikannya khusus untuk topik yang digunakan. Jika mengubah topik yang digunakan untuk memublikasikan ulang data pesan, Anda harus memperbarui peran tindakan aturan untuk memperbarui kebijakannya agar sesuai dengan topik saat ini.

    Jika Anda mencurigai ini masalahnya, edit tindakan aturan Republish dan buat peran baru. Peran baru yang dibuat oleh tindakan aturan menerima otorisasi yang diperlukan untuk melakukan tindakan ini.

## Langkah 4: Tinjau hasil dan langkah selanjutnya
<a name="iot-sns-rule-review-results"></a>

**Dalam tutorial ini:**
+ Anda membuat dan menguji topik dan langganan notifikasi Amazon SNS.
+ Anda menggunakan kueri dan fungsi SQL sederhana dalam pernyataan kueri aturan untuk membuat pesan baru untuk pemberitahuan Anda.
+ Anda membuat AWS IoT aturan untuk mengirim notifikasi Amazon SNS yang menggunakan payload pesan yang disesuaikan.
+ Anda menggunakan klien MQTT untuk menguji aturan Anda. AWS IoT 

**Langkah selanjutnya**  
Setelah Anda mengirim beberapa pesan teks dengan aturan ini, coba bereksperimen dengannya untuk melihat bagaimana mengubah beberapa aspek tutorial memengaruhi pesan dan kapan dikirim. Berikut adalah beberapa ide untuk Anda mulai.
+ *device\$1id*Ubah topik pesan masukan dan amati efeknya dalam isi pesan teks.
+ Ubah bidang yang dipilih dalam pernyataan kueri aturan dan amati efeknya dalam isi pesan teks.
+ Ubah pengujian dalam pernyataan kueri aturan untuk menguji suhu minimum, bukan suhu maksimum. Ingatlah untuk mengubah nama`max_temperature`\$1
+ Tambahkan tindakan aturan penerbitan ulang untuk mengirim pesan MQTT saat pemberitahuan SNS dikirim.
+ Coba tutorial berikutnya dalam seri ini dan pelajari caranya[Tutorial: Menyimpan data perangkat dalam tabel DynamoDB](iot-ddb-rule.md).

# Tutorial: Menyimpan data perangkat dalam tabel DynamoDB
<a name="iot-ddb-rule"></a>

Tutorial ini menunjukkan cara membuat AWS IoT aturan yang mengirimkan data pesan ke tabel DynamoDB.

Dalam tutorial ini, Anda membuat aturan yang mengirimkan data pesan dari perangkat sensor cuaca imajiner ke tabel DynamoDB. Aturan memformat data dari banyak sensor cuaca sehingga dapat ditambahkan ke tabel database tunggal.

**Apa yang akan Anda pelajari dalam tutorial ini**
+ Cara membuat tabel DynamoDB
+ Cara mengirim data pesan ke tabel DynamoDB dari aturan AWS IoT 
+ Cara menggunakan templat substitusi dalam aturan AWS IoT 
+ Cara menggunakan query SQL sederhana dan fungsi dalam pernyataan query aturan
+ Cara menggunakan klien MQTT untuk menguji aturan AWS IoT 

Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya.

**Topics**
+ [Langkah 1: Buat tabel DynamoDB untuk tutorial ini](#iot-ddb-rule-ddb-table)
+ [Langkah 2: Buat AWS IoT aturan untuk mengirim data ke tabel DynamoDB](#iot-ddb-rule-topic-rule)
+ [Langkah 3: Uji AWS IoT aturan dan tabel DynamoDB](#iot-ddb-rule-test)
+ [Langkah 4: Tinjau hasil dan langkah selanjutnya](#iot-ddb-rule-review)

**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ 

**[Mengatur Akun AWS](setting-up.md)**  
Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini.
+ 

**Diulas [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md)**  
Pastikan Anda dapat menggunakan klien MQTT untuk berlangganan dan mempublikasikan ke suatu topik. Anda akan menggunakan klien MQTT untuk menguji aturan baru Anda dalam prosedur ini.
+ 

**Meninjau ikhtisar [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html)**  
Jika Anda belum pernah menggunakan DynamoDB sebelumnya, [tinjau Memulai dengan DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) agar terbiasa dengan konsep dasar dan operasi DynamoDB.

## Langkah 1: Buat tabel DynamoDB untuk tutorial ini
<a name="iot-ddb-rule-ddb-table"></a>

Dalam tutorial ini, Anda akan membuat tabel DynamoDB dengan atribut ini untuk merekam data dari perangkat sensor cuaca imajiner: 
+ `sample_time`adalah kunci utama dan menjelaskan waktu sampel direkam.
+ `device_id`adalah kunci sortir dan menjelaskan perangkat yang menyediakan sampel 
+ `device_data`adalah data yang diterima dari perangkat dan diformat oleh pernyataan kueri aturan

**Untuk membuat tabel DynamoDB untuk tutorial ini**

1. **Buka konsol [DynamoDB](https://console.aws.amazon.com//dynamodb/home), lalu pilih Buat tabel.**

1. Di **Buat tabel**:

   1.  Dalam **nama Tabel**, masukkan nama tabel:**wx\$1data**.

   1. Di **kunci Partisi****sample\$1time**, masukkan, dan dalam daftar opsi di sebelah bidang, pilih**Number**.

   1. Di **Sortir kunci****device\$1id**, masukkan, dan dalam daftar opsi di sebelah bidang, pilih**Number**.

   1. Di bagian bawah halaman, pilih **Buat**.

Anda akan menentukan `device_data` nanti, ketika Anda mengkonfigurasi tindakan aturan DynamoDB.

## Langkah 2: Buat AWS IoT aturan untuk mengirim data ke tabel DynamoDB
<a name="iot-ddb-rule-topic-rule"></a>

Pada langkah ini, Anda akan menggunakan pernyataan kueri aturan untuk memformat data dari perangkat sensor cuaca imajiner untuk menulis ke tabel database.

Contoh payload pesan yang diterima dari perangkat sensor cuaca terlihat seperti ini:

```
{
  "temperature": 28,
  "humidity": 80,
  "barometer": 1013,
  "wind": {
    "velocity": 22,
    "bearing": 255
  }
}
```

Untuk entri database, Anda akan menggunakan pernyataan kueri aturan untuk meratakan struktur payload pesan agar terlihat seperti ini:

```
{
  "temperature": 28,
  "humidity": 80,
  "barometer": 1013,
  "wind_velocity": 22,
  "wind_bearing": 255
}
```

Dalam aturan ini, Anda juga akan menggunakan beberapa[Templat substitusi](iot-substitution-templates.md). Templat substitusi adalah ekspresi yang memungkinkan Anda menyisipkan nilai dinamis dari fungsi dan data pesan.

**Untuk membuat AWS IoT aturan untuk mengirim data ke tabel DynamoDB**

1. Buka [hub Aturan AWS IoT konsol](https://console.aws.amazon.com//iot/home#/rulehub). Atau, Anda dapat membuka AWS IoT beranda di dalam Konsol Manajemen AWS dan menavigasi ke **Perutean Pesan> Aturan**.

1. Untuk mulai membuat aturan baru Anda di **Aturan**, pilih **Buat aturan**.

1. Dalam **properti Aturan**:

   1. Dalam **nama Aturan**, masukkan**wx\$1data\$1ddb**.

      Ingat bahwa nama aturan harus unik di dalam Anda Akun AWS dan Wilayah, dan tidak dapat memiliki spasi apa pun. Kami telah menggunakan karakter garis bawah dalam nama ini untuk memisahkan dua kata dalam nama aturan.

   1. Dalam **Deskripsi aturan**, jelaskan aturannya.

      Deskripsi yang bermakna membuatnya lebih mudah untuk mengingat apa yang dilakukan aturan ini dan mengapa Anda membuatnya. Deskripsi bisa selama dibutuhkan, jadi sedetail mungkin. 

1. Pilih **Next** untuk melanjutkan.

1. Dalam **pernyataan SQL**:

   1. Dalam **versi SQL**, pilih**2016-03-23**.

   1. Dalam kotak edit **pernyataan SQL**, masukkan pernyataan: 

      ```
      SELECT temperature, humidity, barometer,
        wind.velocity as wind_velocity,
        wind.bearing as wind_bearing,
      FROM 'device/+/data'
      ```

      Pernyataan ini:
      + Mendengarkan pesan MQTT dengan topik yang cocok dengan filter topik. `device/+/data`
      + Memformat elemen `wind` atribut sebagai atribut individual.
      + Melewati`temperature`,`humidity`, dan `barometer` atribut tidak berubah.

1. Pilih **Next** untuk melanjutkan.

1. Dalam **tindakan Aturan**:

   1. Untuk membuka daftar tindakan aturan untuk aturan ini, di **Tindakan 1**, pilih**DynamoDB**.
**catatan**  
Pastikan Anda memilih DynamoDB dan bukan DBv2 Dynamo sebagai tindakan aturan.

   1. Dalam **nama Tabel**, pilih nama tabel DynamoDB yang Anda buat pada langkah sebelumnya:. **wx\$1data**

      **Tipe kunci Partition** dan kolom **tipe kunci Sort** diisi dengan nilai-nilai dari tabel DynamoDB Anda.

   1. Di **kunci Partisi**, masukkan**sample\$1time**.

   1. Dalam **nilai kunci partisi**, masukkan**\$1\$1timestamp()\$1**.

      Ini adalah yang pertama dari yang akan [Templat substitusi](iot-substitution-templates.md) Anda gunakan dalam aturan ini. Alih-alih menggunakan nilai dari payload pesan, itu akan menggunakan nilai yang dikembalikan dari fungsi stempel waktu. Untuk mempelajari selengkapnya, lihat [stempel waktu](iot-sql-functions.md#iot-function-timestamp) di Panduan *AWS IoT Core Pengembang*.

   1. Di **tombol Sortir**, masukkan**device\$1id**.

   1. Di **Sortir nilai kunci**, masukkan**\$1\$1cast(topic(2) AS DECIMAL)\$1**.

      Ini adalah yang kedua dari yang akan [Templat substitusi](iot-substitution-templates.md) Anda gunakan dalam aturan ini. Ini menyisipkan nilai elemen kedua dalam nama topik, yang merupakan ID perangkat, setelah itu melemparkan ke nilai DECIMAL untuk mencocokkan format numerik kunci. Untuk mempelajari lebih lanjut tentang topik, lihat [topik](iot-sql-functions.md#iot-function-topic) di *Panduan AWS IoT Core Pengembang*. Atau untuk mempelajari lebih lanjut tentang casting, lihat [pemeran](iot-sql-functions.md#iot-sql-function-cast) di *Panduan AWS IoT Core Pengembang*.

   1. Di **Tulis data pesan ke kolom ini**, masukkan**device\$1data**.

      Ini akan membuat `device_data` kolom dalam tabel DynamoDB.

   1. Biarkan **Operasi** kosong.

   1. Dalam **peran IAM**, pilih **Buat peran baru**.

   1. Dalam kotak dialog **Buat peran**, untuk **nama Peran, masukkan **wx\$1ddb\$1role****. Peran baru ini secara otomatis akan berisi kebijakan dengan awalan "aws-iot-rule" yang akan memungkinkan **wx\$1data\$1ddb** aturan untuk mengirim data ke tabel **wx\$1data** DynamoDB yang Anda buat.

   1. Dalam **peran IAM**, pilih**wx\$1ddb\$1role**.

   1. Di bagian bawah halaman, pilih **Selanjutnya**.

1. Di bagian bawah halaman **Tinjau dan buat**, pilih **Buat** untuk membuat aturan.

## Langkah 3: Uji AWS IoT aturan dan tabel DynamoDB
<a name="iot-ddb-rule-test"></a>

Untuk menguji aturan baru, Anda akan menggunakan klien MQTT untuk mempublikasikan dan berlangganan pesan MQTT yang digunakan dalam pengujian ini.

Buka [klien MQTT di AWS IoT konsol di jendela](https://console.aws.amazon.com//iot/home#/test) baru. Ini akan memungkinkan Anda mengedit aturan tanpa kehilangan konfigurasi klien MQTT Anda. Klien MQTT tidak menyimpan langganan atau log pesan apa pun jika Anda membiarkannya pergi ke halaman lain di konsol. Anda juga ingin jendela konsol terpisah terbuka ke [hub DynamoDB Tables di AWS IoT](https://console.aws.amazon.com//dynamodb/home#tables:) konsol untuk melihat entri baru yang dikirim aturan Anda.

**Untuk menggunakan klien MQTT untuk menguji aturan Anda**

1. Di [klien MQTT di AWS IoT konsol](https://console.aws.amazon.com//iot/home#/test), berlangganan topik input,. `device/+/data`

   1. Di klien MQTT, pilih **Berlangganan topik**.

   1. Untuk **filter Topik**, masukkan topik filter topik masukan,**device/\$1/data**.

   1. Pilih **Langganan**.

1. Sekarang, publikasikan pesan ke topik input dengan ID perangkat tertentu,**device/22/data**. Anda tidak dapat mempublikasikan ke topik MQTT yang berisi karakter wildcard.

   1. Di klien MQTT, pilih **Publikasikan ke topik**.

   1. Untuk **nama Topik**, masukkan nama topik masukan,**device/22/data**.

   1. Untuk **payload Pesan**, masukkan contoh data berikut.

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. **Untuk mempublikasikan pesan MQTT, pilih Publish.**

   1. Sekarang, di klien MQTT, pilih **Berlangganan topik**. Di kolom **Berlangganan**, pilih **device/\$1/data** langganan. Konfirmasikan bahwa data sampel dari langkah sebelumnya muncul di sana.

1. Periksa untuk melihat baris dalam tabel DynamoDB yang aturan Anda buat.

   1. **Di [hub DynamoDB Tables di AWS IoT](https://console.aws.amazon.com//dynamodb/home#tables:) konsol, **pilih wx\$1data, lalu pilih** tab Items.**

      Jika Anda sudah berada di tab **Item**, Anda mungkin perlu menyegarkan tampilan dengan memilih ikon penyegaran di sudut kanan atas header tabel.

   1. Perhatikan bahwa nilai **sample\$1time** dalam tabel adalah link dan buka satu. Jika Anda baru saja mengirim pesan pertama Anda, itu akan menjadi satu-satunya dalam daftar.

      Tautan ini menampilkan semua data di baris tabel tersebut.

   1. Perluas entri **device\$1data** untuk melihat data yang dihasilkan dari pernyataan kueri aturan.

   1. Jelajahi berbagai representasi data yang tersedia di tampilan ini. Anda juga dapat mengedit data di tampilan ini.

   1. Setelah Anda selesai meninjau baris data ini, untuk menyimpan perubahan apa pun yang Anda buat, pilih **Simpan**, atau keluar tanpa menyimpan perubahan apa pun, pilih **Batal**.

Jika Anda tidak melihat perilaku yang benar, periksa tips pemecahan masalah.

### Memecahkan masalah aturan DynamoDB
<a name="iot-ddb-rule-trouble"></a>

Berikut adalah beberapa hal untuk diperiksa jika Anda tidak melihat hasil yang Anda harapkan.
+ 

**Anda mendapat spanduk kesalahan**  
Jika kesalahan muncul saat Anda mempublikasikan pesan input, perbaiki kesalahan itu terlebih dahulu. Langkah-langkah berikut dapat membantu Anda memperbaiki kesalahan itu.
+ 

**Anda tidak melihat pesan masukan di klien MQTT**  
Setiap kali Anda mempublikasikan pesan masukan ke `device/22/data` topik, pesan itu akan muncul di klien MQTT jika Anda berlangganan filter `device/+/data` topik seperti yang dijelaskan dalam prosedur.

**Hal-hal yang harus diperiksa**
  + 

**Periksa filter topik yang Anda langgani**  
Jika Anda berlangganan topik pesan input seperti yang dijelaskan dalam prosedur, Anda akan melihat salinan pesan input setiap kali Anda mempublikasikannya.

    Jika Anda tidak melihat pesan, periksa nama topik yang Anda langgani dan bandingkan dengan topik yang Anda terbitkan. Nama topik peka huruf besar/kecil dan topik yang Anda langgani harus identik dengan topik yang Anda publikasikan payload pesan.
  + 

**Periksa fungsi publikasi pesan**  
**Di klien MQTT, di bawah **Langganan**, pilih **perangkat/\$1/data**, periksa topik pesan terbitkan, lalu pilih Publikasikan ke topik.** Anda akan melihat payload pesan dari kotak edit di bawah topik yang muncul di daftar pesan. 
+ 

**Anda tidak melihat data Anda di tabel DynamoDB**  
Hal pertama yang harus dilakukan adalah menyegarkan tampilan dengan memilih ikon penyegaran di sudut kanan atas header tabel. Jika itu tidak menampilkan data yang Anda cari, periksa yang berikut ini.

**Hal-hal yang harus diperiksa**
  + 

**Periksa klien MQTT Anda dan aturan yang Anda buat Wilayah AWS**  
Konsol tempat Anda menjalankan klien MQTT harus berada di AWS Wilayah yang sama dengan aturan yang Anda buat. 
  + 

**Periksa topik pesan masukan dalam pernyataan kueri aturan**  
Agar aturan berfungsi, aturan harus menerima pesan dengan nama topik yang cocok dengan filter topik dalam klausa FROM dari pernyataan kueri aturan.

    Periksa ejaan filter topik dalam pernyataan kueri aturan dengan topik di klien MQTT. Nama topik peka huruf besar/kecil dan topik pesan harus cocok dengan filter topik dalam pernyataan kueri aturan.
  + 

**Periksa isi payload pesan masukan**  
Agar aturan berfungsi, ia harus menemukan bidang data di payload pesan yang dideklarasikan dalam pernyataan SELECT.

    Periksa ejaan `temperature` bidang dalam pernyataan kueri aturan dengan payload pesan di klien MQTT. Nama bidang peka huruf besar/kecil dan `temperature` bidang dalam pernyataan kueri aturan harus identik dengan `temperature` bidang di payload pesan.

    Pastikan dokumen JSON di payload pesan diformat dengan benar. Jika JSON memiliki kesalahan, seperti koma yang hilang, aturan tidak akan dapat membacanya. 
  + 

**Periksa nama kunci dan bidang yang digunakan dalam tindakan aturan**  
Nama bidang yang digunakan dalam aturan topik harus cocok dengan nama yang ditemukan di payload pesan JSON dari pesan yang dipublikasikan.

    Buka aturan yang Anda buat di konsol dan periksa nama bidang dalam konfigurasi tindakan aturan dengan yang digunakan dalam klien MQTT.
  + 

**Periksa peran yang digunakan oleh aturan**  
Tindakan aturan harus memiliki izin untuk menerima topik asli dan mempublikasikan topik baru. 

    Kebijakan yang mengotorisasi aturan untuk menerima data pesan dan memperbarui tabel DynamoDB khusus untuk topik yang digunakan. Jika mengubah topik atau nama tabel DynamoDB yang digunakan oleh aturan, Anda harus memperbarui peran tindakan aturan untuk memperbarui kebijakannya agar sesuai.

    Jika Anda mencurigai ini masalahnya, edit tindakan aturan dan buat peran baru. Peran baru yang dibuat oleh tindakan aturan menerima otorisasi yang diperlukan untuk melakukan tindakan ini.

## Langkah 4: Tinjau hasil dan langkah selanjutnya
<a name="iot-ddb-rule-review"></a>

Setelah Anda mengirim beberapa pesan ke tabel DynamoDB dengan aturan ini, coba bereksperimen dengannya untuk melihat bagaimana mengubah beberapa aspek dari tutorial memengaruhi data yang ditulis ke tabel. Berikut adalah beberapa ide untuk Anda mulai.
+ *device\$1id*Ubah topik pesan masukan dan amati efeknya pada data. Anda dapat menggunakan ini untuk mensimulasikan penerimaan data dari beberapa sensor cuaca.
+ Ubah bidang yang dipilih dalam pernyataan kueri aturan dan amati efeknya pada data. Anda dapat menggunakan ini untuk memfilter data yang disimpan dalam tabel.
+ Tambahkan tindakan aturan penerbitan ulang untuk mengirim pesan MQTT untuk setiap baris yang ditambahkan ke tabel. Anda dapat menggunakan ini untuk debugging.

Setelah Anda menyelesaikan tutorial ini, periksa[Tutorial: Memformat notifikasi dengan menggunakan fungsi AWS Lambda](iot-lambda-rule.md).

# Tutorial: Memformat notifikasi dengan menggunakan fungsi AWS Lambda
<a name="iot-lambda-rule"></a>

Tutorial ini menunjukkan cara mengirim data pesan MQTT ke AWS Lambda tindakan untuk memformat dan mengirim ke layanan lain. AWS Dalam tutorial ini, AWS Lambda tindakan menggunakan AWS SDK untuk mengirim pesan yang diformat ke topik Amazon SNS yang Anda buat dalam tutorial tentang cara melakukannya. [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)

Dalam tutorial tentang bagaimana caranya[Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md), dokumen JSON yang dihasilkan dari pernyataan kueri aturan dikirim sebagai badan pesan teks. Hasilnya adalah pesan teks yang terlihat seperti contoh ini:

```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```

Dalam tutorial ini, Anda akan menggunakan tindakan AWS Lambda aturan untuk memanggil AWS Lambda fungsi yang memformat data dari pernyataan kueri aturan ke dalam format yang lebih ramah, seperti contoh ini:

```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```

 AWS Lambda Fungsi yang akan Anda buat dalam tutorial ini memformat string pesan dengan menggunakan data dari pernyataan kueri aturan dan memanggil fungsi [publikasi SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) AWS SDK untuk membuat notifikasi.

**Apa yang akan Anda pelajari dalam tutorial ini**
+ Cara membuat dan menguji suatu AWS Lambda fungsi
+ Cara menggunakan AWS SDK dalam AWS Lambda fungsi untuk mempublikasikan notifikasi Amazon SNS
+ Cara menggunakan query SQL sederhana dan fungsi dalam pernyataan query aturan
+ Cara menggunakan klien MQTT untuk menguji aturan AWS IoT 

Tutorial ini membutuhkan waktu sekitar 45 menit untuk menyelesaikannya.

**Topics**
+ [Langkah 1: Buat AWS Lambda fungsi yang mengirim pesan teks](#iot-lambda-rule-create-lambda)
+ [Langkah 2: Buat AWS IoT aturan dengan tindakan AWS Lambda aturan](#iot-lambda-rule-create-rule)
+ [Langkah 3: Uji AWS IoT aturan dan tindakan AWS Lambda aturan](#iot-lambda-rule-test-rule)
+ [Langkah 4: Tinjau hasil dan langkah selanjutnya](#iot-lambda-rule-next-steps)

**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ 

**[Mengatur Akun AWS](setting-up.md)**  
Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini.
+ 

**Diulas [Lihat pesan MQTT dengan klien MQTT AWS IoT](view-mqtt-messages.md)**  
Pastikan Anda dapat menggunakan klien MQTT untuk berlangganan dan mempublikasikan ke suatu topik. Anda akan menggunakan klien MQTT untuk menguji aturan baru Anda dalam prosedur ini.
+ 

**Menyelesaikan tutorial aturan lain di bagian ini**  
Tutorial ini membutuhkan topik notifikasi SNS yang Anda buat di tutorial tentang cara [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md) melakukannya. Ini juga mengasumsikan bahwa Anda telah menyelesaikan tutorial terkait aturan lainnya di bagian ini.
+ 

**Meninjau [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)ikhtisar**  
Jika Anda belum pernah menggunakannya AWS Lambda sebelumnya, tinjau [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)dan [Mulai dengan Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) untuk mempelajari istilah dan konsepnya.

## Langkah 1: Buat AWS Lambda fungsi yang mengirim pesan teks
<a name="iot-lambda-rule-create-lambda"></a>

 AWS Lambda Fungsi dalam tutorial ini menerima hasil dari pernyataan kueri aturan, menyisipkan elemen ke dalam string teks, dan mengirimkan string yang dihasilkan ke Amazon SNS sebagai pesan dalam notifikasi.

Berbeda dengan tutorial tentang bagaimana caranya[Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md), yang menggunakan tindakan AWS IoT aturan untuk mengirim notifikasi, tutorial ini mengirimkan notifikasi dari fungsi Lambda dengan menggunakan fungsi SDK. AWS Topik notifikasi Amazon SNS yang sebenarnya digunakan dalam tutorial ini, bagaimanapun, adalah topik yang sama yang Anda gunakan dalam tutorial tentang cara melakukannya. [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)

**Untuk membuat AWS Lambda fungsi yang mengirim pesan teks**

1. Buat AWS Lambda fungsi baru.

   1. Di [AWS Lambda konsol](https://console.aws.amazon.com//lambda/home), pilih **Buat fungsi**.

   1. Dalam **fungsi Buat**, pilih **Gunakan cetak biru**.

      **Cari dan pilih **hello-world-python** cetak biru, lalu pilih Konfigurasi.**

   1. Dalam **informasi Dasar**:

      1. Dalam **nama Fungsi**, masukkan nama fungsi ini,**format-high-temp-notification**. 

      1. Di **Peran eksekusi**, pilih **Buat peran baru dari templat AWS kebijakan**.

      1. Di Nama peran, masukkan nama peran baru,**format-high-temp-notification-role**.

      1. Di **Templat kebijakan - *opsional***, cari dan pilih kebijakan **publikasi Amazon SNS**.

      1. Pilih **Buat fungsi**.

1. Ubah kode cetak biru untuk memformat dan mengirim pemberitahuan Amazon SNS.

   1. Setelah Anda membuat fungsi Anda, Anda akan melihat halaman **format-high-temp-notification**detail. Jika tidak, buka dari halaman [**Fungsi** Lambda](https://console.aws.amazon.com//lambda/home#/functions).

   1. Di halaman **format-high-temp-notification**detail, pilih tab **Konfigurasi** dan gulir ke panel **Kode fungsi**.

   1. Di jendela **Function code**, di panel **Environment**, pilih file Python,. `lambda_function.py`

   1. Di jendela **Function code**, hapus semua kode program asli dari cetak biru dan ganti dengan kode ini.

      ```
      import boto3
      #
      #   expects event parameter to contain:
      #   {
      #       "device_id": "32",
      #       "reported_temperature": 38,
      #       "max_temperature": 30,
      #       "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
      #   }
      # 
      #   sends a plain text string to be used in a text message
      #
      #      "Device {0} reports a temperature of {1}, which exceeds the limit of {2}."
      #   
      #   where:
      #       {0} is the device_id value
      #       {1} is the reported_temperature value
      #       {2} is the max_temperature value
      #
      def lambda_handler(event, context):
      
          # Create an SNS client to send notification
          sns = boto3.client('sns')
      
          # Format text message from data
          message_text = "Device {0} reports a temperature of {1}, which exceeds the limit of {2}.".format(
                  str(event['device_id']),
                  str(event['reported_temperature']),
                  str(event['max_temperature'])
              )
      
          # Publish the formatted message
          response = sns.publish(
                  TopicArn = event['notify_topic_arn'],
                  Message = message_text
              )
      
          return response
      ```

   1. Pilih **Deploy**.

1. Di jendela baru, cari Nama Sumber Daya Amazon (ARN) dari topik Amazon SNS Anda dari tutorial tentang cara melakukannya. [Tutorial: Mengirim notifikasi Amazon SNS](iot-sns-rule.md)

   1. Di jendela baru, buka [halaman Topik konsol Amazon SNS](https://console.aws.amazon.com//sns/v3/home#/topics). 

   1. Di halaman **Topik**, temukan topik notifikasi **high\$1temp\$1notice** dalam daftar topik Amazon SNS.

   1. Temukan **ARN** dari topik notifikasi **high\$1temp\$1notice** untuk digunakan pada langkah berikutnya.

1. Buat kasus uji untuk fungsi Lambda Anda.

   1. Di halaman [**Fungsi** Lambda](https://console.aws.amazon.com//lambda/home#/functions) konsol, pada halaman **format-high-temp-notification**detail, **pilih Pilih acara pengujian** di sudut kanan atas halaman (meskipun terlihat dinonaktifkan), lalu pilih **Konfigurasi peristiwa pengujian**.

   1. Di **Configure test event**, pilih **Create new test event**.

   1. Dalam **nama acara**, masukkan**SampleRuleOutput**.

   1. Di editor JSON di bawah **nama Acara**, tempel contoh dokumen JSON ini. Ini adalah contoh dari apa yang akan dikirim AWS IoT aturan Anda ke fungsi Lambda.

      ```
      {
        "device_id": "32",
        "reported_temperature": 38,
        "max_temperature": 30,
        "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
      }
      ```

   1. Lihat jendela yang memiliki **ARN** dari topik notifikasi **high\$1temp\$1notice** dan salin nilai ARN.

   1. Ganti `notify_topic_arn` nilai di editor JSON dengan ARN dari topik notifikasi Anda.

      Biarkan jendela ini tetap terbuka sehingga Anda dapat menggunakan nilai ARN ini lagi saat Anda membuat aturan. AWS IoT 

   1. Pilih **Buat**.

1. Uji fungsi dengan data sampel.

   1. **Di halaman **format-high-temp-notification**detail, di sudut kanan atas halaman, konfirmasikan yang **SampleRuleOutput**muncul di sebelah tombol Uji.** Jika tidak, pilih dari daftar acara pengujian yang tersedia.

   1. Untuk mengirim pesan keluaran aturan sampel ke fungsi Anda, pilih **Uji**.

Jika fungsi dan notifikasi keduanya berfungsi, Anda akan mendapatkan pesan teks di ponsel yang berlangganan notifikasi.

Jika Anda tidak mendapatkan pesan teks di telepon, periksa hasil operasi. Di panel **Kode fungsi**, di tab **Hasil eksekusi**, tinjau respons untuk menemukan kesalahan yang terjadi. Jangan melanjutkan ke langkah berikutnya sampai fungsi Anda dapat mengirim notifikasi ke ponsel Anda.

## Langkah 2: Buat AWS IoT aturan dengan tindakan AWS Lambda aturan
<a name="iot-lambda-rule-create-rule"></a>

Pada langkah ini, Anda akan menggunakan pernyataan kueri aturan untuk memformat data dari perangkat sensor cuaca imajiner untuk dikirim ke fungsi Lambda, yang akan memformat dan mengirim pesan teks.

Contoh payload pesan yang diterima dari perangkat cuaca terlihat seperti ini:

```
{
  "temperature": 28,
  "humidity": 80,
  "barometer": 1013,
  "wind": {
    "velocity": 22,
    "bearing": 255
  }
}
```

Dalam aturan ini, Anda akan menggunakan pernyataan kueri aturan untuk membuat payload pesan untuk fungsi Lambda yang terlihat seperti ini:

```
{
  "device_id": "32",
  "reported_temperature": 38,
  "max_temperature": 30,
  "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```

Ini berisi semua informasi yang diperlukan fungsi Lambda untuk memformat dan mengirim pesan teks yang benar.

**Untuk membuat AWS IoT aturan untuk memanggil fungsi Lambda**

1. Buka [hub **Aturan**AWS IoT konsol](https://console.aws.amazon.com//iot/home#/rulehub).

1. Untuk mulai membuat aturan baru Anda di **Aturan**, pilih **Buat**.

1. Di bagian atas **Buat aturan**:

   1. Dalam **Nama**, masukkan nama aturan,**wx\$1friendly\$1text**.

      Ingat bahwa nama aturan harus unik di dalam Anda Akun AWS dan Wilayah, dan tidak dapat memiliki spasi apa pun. Kami telah menggunakan karakter garis bawah dalam nama ini untuk memisahkan dua kata dalam nama aturan.

   1.  Dalam **Deskripsi**, jelaskan aturannya. 

      Deskripsi yang bermakna membuatnya lebih mudah untuk mengingat apa yang dilakukan aturan ini dan mengapa Anda membuatnya. Deskripsi bisa selama dibutuhkan, jadi sedetail mungkin. 

1. Dalam **pernyataan kueri Aturan** **Buat aturan**:

   1.  Dalam **Menggunakan versi SQL**, pilih**2016-03-23**. 

   1. Dalam kotak edit **pernyataan kueri aturan**, masukkan pernyataan: 

      ```
      SELECT 
        cast(topic(2) AS DECIMAL) as device_id, 
        temperature as reported_temperature,
        30 as max_temperature,
        'arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice' as notify_topic_arn
      FROM 'device/+/data' WHERE temperature > 30
      ```

      Pernyataan ini:
      + Mendengarkan pesan MQTT dengan topik yang cocok dengan filter `device/+/data` topik dan yang memiliki `temperature` nilai lebih besar dari 30. 
      + Memilih elemen kedua dari string topik, mengubahnya menjadi angka desimal, dan kemudian menetapkannya ke bidang. `device_id`
      + Memilih nilai `temperature` bidang dari payload pesan dan menetapkannya ke bidang. `reported_temperature` 
      + Menciptakan nilai konstan`30`,, untuk mewakili nilai batas dan menetapkannya ke `max_temperature` bidang. 
      + Menciptakan nilai konstan untuk `notify_topic_arn` bidang.

   1. Lihat jendela yang memiliki **ARN** dari topik notifikasi **high\$1temp\$1notice** dan salin nilai ARN.

   1. Ganti nilai ARN (*arn:aws:sns:us-east-1:57EXAMPLE833:high\$1temp\$1notice*) di editor pernyataan kueri aturan dengan ARN topik notifikasi Anda.

1. Di **Tetapkan satu atau lebih tindakan**:

   1. Untuk membuka daftar tindakan aturan untuk aturan ini, pilih **Tambah tindakan**.

   1. Di **Pilih tindakan**, pilih **Kirim pesan ke fungsi Lambda**.

   1. Untuk membuka halaman konfigurasi tindakan yang dipilih, di bagian bawah daftar tindakan, pilih **Konfigurasi tindakan**.

1. Dalam **tindakan Konfigurasi**:

   1. Di **Nama fungsi**, pilih **Pilih**.

   1. Pilih **format-high-temp-notification**.

   1. Di bagian bawah **Configure action**, pilih **Add action**.

   1. Untuk membuat aturan, di bagian bawah **Buat aturan**, pilih **Buat aturan**.

## Langkah 3: Uji AWS IoT aturan dan tindakan AWS Lambda aturan
<a name="iot-lambda-rule-test-rule"></a>

Untuk menguji aturan baru Anda, Anda akan menggunakan klien MQTT untuk mempublikasikan dan berlangganan pesan MQTT yang digunakan oleh aturan ini.

Buka [klien MQTT di AWS IoT konsol di jendela](https://console.aws.amazon.com//iot/home#/test) baru. Sekarang Anda dapat mengedit aturan tanpa kehilangan konfigurasi klien MQTT Anda. Jika Anda meninggalkan klien MQTT untuk pergi ke halaman lain di konsol, Anda akan kehilangan langganan atau log pesan Anda.

**Untuk menggunakan klien MQTT untuk menguji aturan Anda**

1. Di [klien MQTT di AWS IoT konsol](https://console.aws.amazon.com//iot/home#/test), berlangganan topik input, dalam hal ini,. `device/+/data`

   1. Di klien MQTT, di bawah **Langganan, pilih **Berlangganan**** topik.

   1. Dalam **topik Langganan**, masukkan topik filter topik masukan,**device/\$1/data**.

   1. Simpan sisa bidang di pengaturan defaultnya.

   1. Pilih **Berlangganan topik**.

      Di kolom **Langganan**, di bawah **Publikasikan ke topik**, **device/\$1/data** muncul. 

1. Publikasikan pesan ke topik input dengan ID perangkat tertentu,**device/32/data**. Anda tidak dapat mempublikasikan ke topik MQTT yang berisi karakter wildcard.

   1. **Di klien MQTT, di bawah **Langganan**, pilih Publikasikan ke topik.**

   1. Di bidang **Publikasikan**, masukkan nama topik masukan,**device/32/data**.

   1. Salin data sampel yang ditampilkan di sini dan, di kotak edit di bawah nama topik, tempel data sampel.

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Untuk mempublikasikan pesan MQTT Anda, pilih **Publikasikan** ke topik.

1. Konfirmasikan bahwa pesan teks telah dikirim.

   1. Di klien MQTT, di bawah **Langganan**, ada titik hijau di sebelah topik yang Anda berlangganan sebelumnya.

      Titik hijau menunjukkan bahwa satu atau lebih pesan baru telah diterima sejak terakhir kali Anda melihatnya.

   1. Di bawah **Langganan**, pilih **perangkat/\$1/data** untuk memeriksa apakah muatan pesan cocok dengan apa yang baru saja Anda terbitkan dan terlihat seperti ini:

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Periksa ponsel yang Anda gunakan untuk berlangganan topik SNS dan konfirmasikan isi payload pesan terlihat seperti ini:

      ```
      Device 32 reports a temperature of 38, which exceeds the limit of 30.
      ```

      Jika Anda mengubah elemen ID topik dalam topik pesan, ingatlah bahwa `topic(2)` mentransmisikan nilai ke nilai numerik hanya akan berfungsi jika elemen dalam topik pesan hanya berisi karakter numerik.

1. Coba kirim pesan MQTT di mana suhunya tidak melebihi batas.

   1. **Di klien MQTT, di bawah **Langganan**, pilih Publikasikan ke topik.**

   1. Di bidang **Publikasikan**, masukkan nama topik masukan,**device/33/data**.

   1. Salin data sampel yang ditampilkan di sini dan, di kotak edit di bawah nama topik, tempel data sampel.

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Untuk mengirim pesan MQTT Anda, pilih **Publikasikan** ke topik.

   Anda akan melihat pesan yang Anda kirim dalam **device/\$1/data** langganan; Namun, karena nilai suhu di bawah suhu maks dalam pernyataan kueri aturan, Anda seharusnya tidak menerima pesan teks.

   Jika Anda tidak melihat perilaku yang benar, periksa tips pemecahan masalah.

### Memecahkan masalah AWS Lambda aturan dan pemberitahuan
<a name="iot-lambda-rule-troubleshoot"></a>

Berikut adalah beberapa hal untuk diperiksa, jika Anda tidak melihat hasil yang Anda harapkan.
+ 

**Anda mendapat spanduk kesalahan**  
Jika kesalahan muncul saat Anda mempublikasikan pesan input, perbaiki kesalahan itu terlebih dahulu. Langkah-langkah berikut dapat membantu Anda memperbaiki kesalahan itu.
+ 

**Anda tidak melihat pesan masukan di klien MQTT**  
Setiap kali Anda mempublikasikan pesan masukan Anda ke `device/32/data` topik, pesan itu akan muncul di klien MQTT, jika Anda berlangganan filter `device/+/data` topik seperti yang dijelaskan dalam prosedur.

**Hal-hal yang harus diperiksa**
  + 

**Periksa filter topik yang Anda langgani**  
Jika Anda berlangganan topik pesan input seperti yang dijelaskan dalam prosedur, Anda akan melihat salinan pesan input setiap kali Anda mempublikasikannya.

    Jika Anda tidak melihat pesan, periksa nama topik yang Anda langgani dan bandingkan dengan topik yang Anda terbitkan. Nama topik peka huruf besar/kecil dan topik yang Anda langgani harus identik dengan topik yang Anda publikasikan payload pesan.
  + 

**Periksa fungsi publikasi pesan**  
**Di klien MQTT, di bawah **Langganan**, pilih **perangkat/\$1/data**, periksa topik pesan terbitkan, lalu pilih Publikasikan ke topik.** Anda akan melihat payload pesan dari kotak edit di bawah topik yang muncul di daftar pesan. 
+ 

**Anda tidak menerima pesan SMS**  
Agar aturan Anda berfungsi, itu harus memiliki kebijakan yang benar yang mengizinkannya untuk menerima pesan dan mengirim pemberitahuan SNS, dan itu harus menerima pesan.

**Hal-hal yang harus diperiksa**
  + 

**Periksa klien MQTT Anda dan aturan yang Anda buat Wilayah AWS**  
Konsol tempat Anda menjalankan klien MQTT harus berada di AWS Wilayah yang sama dengan aturan yang Anda buat.
  + 

**Periksa apakah nilai suhu dalam muatan pesan melebihi ambang uji**  
Jika nilai suhu kurang dari atau sama dengan 30, seperti yang didefinisikan dalam pernyataan kueri aturan, aturan tidak akan melakukan tindakannya.
  + 

**Periksa topik pesan masukan dalam pernyataan kueri aturan**  
Agar aturan berfungsi, aturan harus menerima pesan dengan nama topik yang cocok dengan filter topik dalam klausa FROM dari pernyataan kueri aturan.

    Periksa ejaan filter topik dalam pernyataan kueri aturan dengan topik di klien MQTT. Nama topik peka huruf besar/kecil dan topik pesan harus cocok dengan filter topik dalam pernyataan kueri aturan.
  + 

**Periksa isi payload pesan masukan**  
Agar aturan berfungsi, ia harus menemukan bidang data di payload pesan yang dideklarasikan dalam pernyataan SELECT.

    Periksa ejaan `temperature` bidang dalam pernyataan kueri aturan dengan payload pesan di klien MQTT. Nama bidang peka huruf besar/kecil dan `temperature` bidang dalam pernyataan kueri aturan harus identik dengan `temperature` bidang di payload pesan.

    Pastikan dokumen JSON di payload pesan diformat dengan benar. Jika JSON memiliki kesalahan, seperti koma yang hilang, aturan tidak akan dapat membacanya.
  + 

**Periksa notifikasi Amazon SNS**  
Di[Langkah 1: Buat topik Amazon SNS yang mengirim pesan teks SMS](iot-sns-rule.md#iot-sns-rule-create-sns-topic), lihat langkah 3 yang menjelaskan cara menguji notifikasi Amazon SNS dan menguji notifikasi untuk memastikan notifikasi berfungsi.
  + 

**Periksa fungsi Lambda**  
Di[Langkah 1: Buat AWS Lambda fungsi yang mengirim pesan teks](#iot-lambda-rule-create-lambda), lihat langkah 5 yang menjelaskan cara menguji fungsi Lambda menggunakan data uji dan menguji fungsi Lambda.
  + 

**Periksa peran yang digunakan oleh aturan**  
Tindakan aturan harus memiliki izin untuk menerima topik asli dan mempublikasikan topik baru. 

    Kebijakan yang mengizinkan aturan untuk menerima data pesan dan mempublikasikannya khusus untuk topik yang digunakan. Jika mengubah topik yang digunakan untuk memublikasikan ulang data pesan, Anda harus memperbarui peran tindakan aturan untuk memperbarui kebijakannya agar sesuai dengan topik saat ini.

    Jika Anda mencurigai ini masalahnya, edit tindakan aturan Republish dan buat peran baru. Peran baru yang dibuat oleh tindakan aturan menerima otorisasi yang diperlukan untuk melakukan tindakan ini.

## Langkah 4: Tinjau hasil dan langkah selanjutnya
<a name="iot-lambda-rule-next-steps"></a>

**Dalam tutorial ini:**
+ Anda membuat AWS IoT aturan untuk memanggil fungsi Lambda yang mengirim notifikasi Amazon SNS yang menggunakan payload pesan yang disesuaikan.
+ Anda menggunakan kueri dan fungsi SQL sederhana dalam pernyataan kueri aturan untuk membuat payload pesan baru untuk fungsi Lambda Anda.
+ Anda menggunakan klien MQTT untuk menguji aturan Anda. AWS IoT 

**Langkah selanjutnya**  
Setelah Anda mengirim beberapa pesan teks dengan aturan ini, coba bereksperimen dengannya untuk melihat bagaimana mengubah beberapa aspek tutorial memengaruhi pesan dan kapan dikirim. Berikut adalah beberapa ide untuk Anda mulai.
+ *device\$1id*Ubah topik pesan masukan dan amati efeknya dalam isi pesan teks.
+ Ubah bidang yang dipilih dalam pernyataan kueri aturan, perbarui fungsi Lambda untuk menggunakannya dalam pesan baru, dan amati efeknya dalam isi pesan teks.
+ Ubah pengujian dalam pernyataan kueri aturan untuk menguji suhu minimum, bukan suhu maksimum. Perbarui fungsi Lambda untuk memformat pesan baru dan ingat untuk mengubah nama. `max_temperature`
+ Untuk mempelajari lebih lanjut tentang cara menemukan kesalahan yang mungkin terjadi saat Anda mengembangkan dan menggunakan AWS IoT aturan, lihat[Pemantauan AWS IoT](monitoring_overview.md).

# Mempertahankan status perangkat saat perangkat offline dengan Device Shadows
<a name="iot-shadows-tutorial"></a>

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
<a name="create-resources-shadow"></a>

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
<a name="setup-device-shadow"></a>

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
<a name="shadow-provision-cloud"></a>

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
<a name="create-policy-shadow"></a>

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
<a name="create-thing-shadow"></a>

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
<a name="resources-shadow-review"></a>

**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
<a name="lightbulb-shadow-application"></a>

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
<a name="run-sample-application-shadows"></a>

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
<a name="review-shadow-sample-code"></a>

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`
<a name="shadow-sample-app-troubleshoot"></a>

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
<a name="sample-app-shadow-review"></a>

**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
<a name="interact-lights-device-shadows"></a>

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
<a name="update-desired-shadow-sample"></a>

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
<a name="shadow-sample-view-msg"></a>

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
<a name="shadow-observe-messages-troubleshoot"></a>

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
<a name="sample-shadow-review"></a>

**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).

# Tutorial: Membuat otorisasi khusus untuk AWS IoT Core
<a name="custom-auth-tutorial"></a>

Tutorial ini menunjukkan langkah-langkah untuk membuat, memvalidasi, dan menggunakan Custom Authentication dengan menggunakan. AWS CLI Secara opsional, menggunakan tutorial ini, Anda dapat menggunakan Postman untuk mengirim data AWS IoT Core dengan menggunakan HTTP Publish API.

Tutorial ini menunjukkan cara membuat contoh fungsi Lambda yang mengimplementasikan logika otorisasi dan otentikasi dan otorisasi khusus menggunakan panggilan dengan penandatanganan token diaktifkan. **create-authorizer** Authorizer kemudian divalidasi menggunakan**test-invoke-authorizer**, dan akhirnya Anda dapat mengirim data AWS IoT Core dengan menggunakan HTTP Publish API ke topik MQTT pengujian. Permintaan sampel akan menentukan otorisasi untuk dipanggil dengan menggunakan `x-amz-customauthorizer-name` header dan meneruskan header token-key-name and `x-amz-customauthorizer-signature` in request.

**Apa yang akan Anda pelajari dalam tutorial ini:**
+ Cara membuat fungsi Lambda menjadi penangan otorisasi khusus
+ Cara membuat otorisasi khusus menggunakan penandatanganan token AWS CLI dengan diaktifkan
+ Cara menguji otorisasi khusus Anda menggunakan perintah **test-invoke-authorizer**
+ Cara mempublikasikan topik MQTT dengan menggunakan [Postman](https://www.postman.com/) dan memvalidasi permintaan dengan otorisasi khusus Anda

Tutorial ini membutuhkan waktu sekitar 60 menit untuk menyelesaikannya.

**Topics**
+ [Langkah 1: Buat fungsi Lambda untuk otorisasi kustom Anda](#custom-auth-tutorial-define)
+ [Langkah 2: Buat key pair publik dan pribadi untuk otorisasi kustom Anda](#custom-auth-tutorial-keys)
+ [Langkah 3: Buat sumber otorisasi khusus dan otorisasi](#custom-auth-tutorial-authorizer)
+ [Langkah 4: Uji otorisasi dengan menelepon test-invoke-authorizer](#custom-auth-tutorial-test)
+ [Langkah 5: Uji penerbitan pesan MQTT menggunakan Postman](#custom-auth-tutorial-postman)
+ [Langkah 6: Lihat pesan di klien pengujian MQTT](#custom-auth-tutorial-testclient)
+ [Langkah 7: Tinjau hasil dan langkah selanjutnya](#custom-auth-tutorial-review)
+ [Langkah 8: Membersihkan](#custom-auth-tutorial-cleanup)

**Sebelum Anda memulai tutorial ini, pastikan Anda memiliki:**
+ 

**[Mengatur Akun AWS](setting-up.md)**  
Anda akan membutuhkan Akun AWS dan AWS IoT konsol Anda untuk menyelesaikan tutorial ini. 

  Akun yang Anda gunakan untuk tutorial ini berfungsi paling baik jika menyertakan setidaknya kebijakan AWS terkelola ini:
  + [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor)
  + [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor)
  + [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor)
**penting**  
Kebijakan IAM yang digunakan dalam tutorial ini lebih permisif daripada yang harus Anda ikuti dalam implementasi produksi. Di lingkungan produksi, pastikan kebijakan akun dan sumber daya Anda hanya memberikan izin yang diperlukan.  
Saat Anda membuat kebijakan IAM untuk produksi, tentukan akses apa yang dibutuhkan pengguna dan peran, lalu rancang kebijakan yang memungkinkan mereka hanya melakukan tugas tersebut.  
Untuk informasi selengkapnya, lihat [Praktik terbaik keamanan di IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/best-practices.html)
+ 

**Menginstal AWS CLI**  
Untuk informasi tentang cara menginstal AWS CLI, lihat [Menginstal AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-install.html). Tutorial ini membutuhkan AWS CLI versi `aws-cli/2.1.3 Python/3.7.4 Darwin/18.7.0 exe/x86_64` atau yang lebih baru.
+ 

**Alat OpenSSL**  
Contoh dalam tutorial ini menggunakan [LibreSSL](https://www.libressl.org/) 2.6.5. Anda juga dapat menggunakan alat [OpenSSL](https://www.openssl.org/) v1.1.1i untuk tutorial ini.
+ 

**Meninjau [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)ikhtisar**  
Jika Anda belum pernah menggunakannya AWS Lambda sebelumnya, tinjau [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)dan [Mulai dengan Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) untuk mempelajari istilah dan konsepnya.
+ 

**Meninjau cara membuat permintaan di Postman**  
Untuk informasi selengkapnya, lihat [Permintaan bangunan](https://learning.postman.com/docs/sending-requests/requests/).
+ 

**Dihapus otorisasi kustom dari tutorial sebelumnya**  
Anda hanya Akun AWS dapat memiliki sejumlah otorisasi khusus yang dikonfigurasi pada satu waktu. Untuk informasi tentang cara menghapus otorisasi kustom, lihat[Langkah 8: Membersihkan](#custom-auth-tutorial-cleanup).

## Langkah 1: Buat fungsi Lambda untuk otorisasi kustom Anda
<a name="custom-auth-tutorial-define"></a>

Otentikasi kustom AWS IoT Core menggunakan [sumber daya otorisasi](https://docs.aws.amazon.com//iot/latest/apireference/API_AuthorizerDescription.html) yang Anda buat untuk mengautentikasi dan mengotorisasi klien. Fungsi yang akan Anda buat di bagian ini mengautentikasi dan mengotorisasi klien saat mereka terhubung AWS IoT Core dan mengakses AWS IoT sumber daya.

Fungsi Lambda melakukan hal berikut:
+ Jika permintaan berasal**test-invoke-authorizer**, ia mengembalikan kebijakan IAM dengan `Deny` tindakan.
+ Jika permintaan berasal dari Postman menggunakan HTTP dan `actionToken` parameter memiliki nilai`allow`, ia mengembalikan kebijakan IAM dengan tindakan`Allow`. Jika tidak, ia mengembalikan kebijakan IAM dengan `Deny` tindakan.

**Untuk membuat fungsi Lambda untuk otorisasi kustom Anda**

1. [Di konsol [Lambda](https://console.aws.amazon.com//lambda/home#), buka Fungsi.](https://console.aws.amazon.com//lambda/home#/functions)

1. Pilih **Buat fungsi**.

1. Konfirmasi **Penulis dari awal** dipilih.

1. Di bawah **Informasi dasar**:

   1. Dalam **nama Fungsi**, masukkan**custom-auth-function**.

   1. Di **Runtime**, konfirmasikan **Node.js 18.x** 

1. Pilih **Buat fungsi**.

   Lambda membuat fungsi Node.js dan [peran eksekusi](https://docs.aws.amazon.com//lambda/latest/dg/lambda-intro-execution-role.html) yang memberikan izin fungsi untuk mengunggah log. Fungsi Lambda mengasumsikan peran eksekusi saat Anda menjalankan fungsi dan menggunakan peran eksekusi untuk membuat kredensi AWS SDK dan membaca data dari sumber peristiwa.

1. Untuk melihat kode dan konfigurasi fungsi di [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)editor, pilih **custom-auth-function**di jendela desainer, lalu pilih **index.js** di panel navigasi editor.

   Untuk bahasa scripting seperti Node.js, Lambda menyertakan fungsi dasar yang mengembalikan respons sukses. Anda dapat menggunakan [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)editor untuk mengedit fungsi Anda selama kode sumber Anda tidak melebihi 3 MB.

1. Ganti kode **index.js** di editor dengan kode berikut:

   ```
   // A simple Lambda function for an authorizer. It demonstrates
   // How to parse a CLI and Http password to generate a response.
   
   export const handler = async (event, context, callback) => {
   
       //Http parameter to initiate allow/deny request
       const HTTP_PARAM_NAME='actionToken';
       const ALLOW_ACTION = 'Allow';
       const DENY_ACTION = 'Deny';
   
       //Event data passed to Lambda function
       var event_str = JSON.stringify(event);
       console.log('Complete event :'+ event_str);
   
       //Read protocolData from the event json passed to Lambda function
       var protocolData = event.protocolData;
       console.log('protocolData value---> ' + protocolData);
   
       //Get the dynamic account ID from function's ARN to be used
       // as full resource for IAM policy
       var ACCOUNT_ID = context.invokedFunctionArn.split(":")[4];
       console.log("ACCOUNT_ID---"+ACCOUNT_ID);
   
       //Get the dynamic region from function's ARN to be used
       // as full resource for IAM policy
       var REGION = context.invokedFunctionArn.split(":")[3];
       console.log("REGION---"+REGION);
   
       //protocolData data will be undefined if testing is done via CLI.
       // This will help to test the set up.
       if (protocolData === undefined) {
   
           //If CLI testing, pass deny action as this is for testing purpose only.
           console.log('Using the test-invoke-authorizer cli for testing only');
           callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
   
       } else{
   
           //Http Testing from Postman
           //Get the query string from the request
           var queryString = event.protocolData.http.queryString;
           console.log('queryString values -- ' + queryString);
           /*         global URLSearchParams       */
           const params = new URLSearchParams(queryString);
           var action = params.get(HTTP_PARAM_NAME);
   
           if(action!=null && action.toLowerCase() === 'allow'){
   
               callback(null, generateAuthResponse(ALLOW_ACTION,ACCOUNT_ID,REGION));
   
           }else{
   
               callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
   
           }
   
       }
   
   };
   
   // Helper function to generate the authorization IAM response.
   var generateAuthResponse = function(effect,ACCOUNT_ID,REGION) {
   
       var full_resource = "arn:aws:iot:"+ REGION + ":" + ACCOUNT_ID + ":*";
       console.log("full_resource---"+full_resource);
   
       var authResponse = {};
       authResponse.isAuthenticated = true;
       authResponse.principalId = 'principalId';
   
       var policyDocument = {};
       policyDocument.Version = '2012-10-17';		 	 	 
       policyDocument.Statement = [];
       var statement = {};
       statement.Action = 'iot:*';
       statement.Effect = effect;
       statement.Resource = full_resource;
       policyDocument.Statement[0] = statement;
       authResponse.policyDocuments = [policyDocument];
       authResponse.disconnectAfterInSeconds = 3600;
       authResponse.refreshAfterInSeconds = 600;
   
       console.log('custom auth policy function called from http');
       console.log('authResponse --> ' + JSON.stringify(authResponse));
       console.log(authResponse.policyDocuments[0]);
   
       return authResponse;
   }
   ```

1. Pilih **Deploy**.

1. Setelah **Perubahan diterapkan** muncul di atas editor:

   1. Gulir ke bagian **Ikhtisar fungsi** di atas editor.

   1. Salin **Fungsi ARN** dan simpan untuk digunakan nanti dalam tutorial ini.

1. Uji fungsi Anda.

   1. Pilih tab **Uji**.

   1. Menggunakan pengaturan pengujian default, pilih **Invoke**.

   1. Jika tes berhasil, dalam **hasil Eksekusi**, buka tampilan **Detail**. Anda akan melihat dokumen kebijakan yang dikembalikan fungsi.

      Jika pengujian gagal atau Anda tidak melihat dokumen kebijakan, tinjau kode untuk menemukan dan memperbaiki kesalahan.

## Langkah 2: Buat key pair publik dan pribadi untuk otorisasi kustom Anda
<a name="custom-auth-tutorial-keys"></a>

Authorizer kustom Anda memerlukan kunci publik dan pribadi untuk mengotentikasi itu. Perintah di bagian ini menggunakan alat OpenSSL untuk membuat key pair ini.

**Untuk membuat key pair publik dan pribadi untuk otorisasi kustom Anda**

1. Buat file kunci pribadi.

   ```
   openssl genrsa -out private-key.pem 4096
   ```

1. Verifikasi file kunci pribadi yang baru saja Anda buat.

   ```
   openssl rsa -check -in private-key.pem -noout
   ```

   Jika perintah tidak menampilkan kesalahan apa pun, file kunci pribadi valid.

1. Buat file kunci publik.

   ```
   openssl rsa -in private-key.pem -pubout -out public-key.pem
   ```

1. Verifikasi file kunci publik.

   ```
   openssl pkey -inform PEM -pubin -in public-key.pem -noout
   ```

   Jika perintah tidak menampilkan kesalahan apa pun, file kunci publik valid.

## Langkah 3: Buat sumber otorisasi khusus dan otorisasi
<a name="custom-auth-tutorial-authorizer"></a>

Authorizer AWS IoT kustom adalah sumber daya yang mengikat semua elemen yang dibuat pada langkah sebelumnya. Di bagian ini, Anda akan membuat sumber otorisasi khusus dan memberinya izin untuk menjalankan fungsi Lambda yang Anda buat sebelumnya. Anda dapat membuat resource otorisasi kustom dengan menggunakan AWS IoT konsol, API AWS CLI, atau AWS API. 

Untuk tutorial ini, Anda hanya perlu membuat satu otorisasi khusus. Bagian ini menjelaskan cara membuat dengan menggunakan AWS IoT konsol dan AWS CLI, sehingga Anda dapat menggunakan metode yang paling nyaman bagi Anda. Tidak ada perbedaan antara sumber daya otorisasi khusus yang dibuat oleh salah satu metode.

### Buat sumber otorisasi kustom
<a name="custom-auth-tutorial-authorizer-resource"></a>

**Pilih salah satu opsi ini untuk membuat sumber otorisasi kustom Anda**
+ [Buat otorisasi khusus dengan menggunakan konsol AWS IoT](#create-custom-auth-in-console)
+ [Buat otorisasi khusus menggunakan AWS CLI](#create-custom-auth-in-cli)

**Untuk membuat otorisasi kustom (konsol)**

1. Buka [halaman Custom Authorizer AWS IoT konsol](https://console.aws.amazon.com//iot/home#/authorizerhub), dan pilih **Create Authorizer**.

1. Di **Create Authorizer**:

   1. Dalam **nama Authorizer**, masukkan**my-new-authorizer**.

   1. Dalam **status Authorizer**, periksa **Aktif**.

   1. Dalam fungsi **Authorizer, pilih fungsi** Lambda yang Anda buat sebelumnya.

   1. Dalam **validasi Token - opsional**:

      1. Beralih pada validasi **Token**.

      1. Dalam **nama kunci Token**, masukkan**tokenKeyName**.

      1. Pilih **Tambah kunci**.

      1. Dalam **Nama kunci**, masukkan**FirstKey**.

      1. Dalam **kunci Publik**, masukkan isi `public-key.pem` file. Pastikan untuk menyertakan baris dari file dengan `-----BEGIN PUBLIC KEY-----` dan `-----END PUBLIC KEY-----` dan jangan menambahkan atau menghapus umpan baris, pengembalian carriage, atau karakter lain dari konten file. String yang Anda masukkan akan terlihat seperti contoh ini.

         ```
         -----BEGIN PUBLIC KEY-----
         MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
         sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
         QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
         lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
         oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
         FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
         QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
         KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
         gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
         /NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
         8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
         JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
         -----END PUBLIC KEY-----
         ```

1. Pilih **Buat Authorizer**.

1. Jika sumber otorisasi kustom dibuat, Anda akan melihat daftar otorisasi kustom dan otorisasi kustom baru Anda akan muncul dalam daftar dan Anda dapat melanjutkan ke bagian berikutnya untuk mengujinya.

   Jika Anda melihat kesalahan, tinjau kesalahan dan coba buat otorisasi kustom Anda lagi dan periksa kembali entri. Perhatikan bahwa setiap sumber otorisasi kustom harus memiliki nama yang unik.

**Untuk membuat otorisasi kustom ()AWS CLI**

1. Gantikan nilai Anda untuk `authorizer-function-arn` dan`token-signing-public-keys`, lalu jalankan perintah berikut:

   ```
   aws iot create-authorizer \
   --authorizer-name "my-new-authorizer" \
   --token-key-name "tokenKeyName" \
   --status ACTIVE \
   --no-signing-disabled \
   --authorizer-function-arn "arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function" \
   --token-signing-public-keys FirstKey="-----BEGIN PUBLIC KEY-----
   MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
   sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
   QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
   lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
   oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
   FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
   QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
   KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
   gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
   /NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
   8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
   JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
   -----END PUBLIC KEY-----"
   ```

**Di mana:**
   + `authorizer-function-arn`Nilainya adalah Nama Sumber Daya Amazon (ARN) dari fungsi Lambda yang Anda buat untuk otorisasi khusus Anda.
   + `token-signing-public-keys`Nilai termasuk nama kunci,**FirstKey**, dan isi `public-key.pem` file. Pastikan untuk menyertakan baris dari file dengan `-----BEGIN PUBLIC KEY-----` dan `-----END PUBLIC KEY-----` dan jangan menambahkan atau menghapus umpan baris, pengembalian carriage, atau karakter lain dari konten file. 

     Catatan: hati-hati memasukkan kunci publik karena setiap perubahan pada nilai kunci publik membuatnya tidak dapat digunakan.

1. Jika otorisasi kustom dibuat, perintah mengembalikan nama dan ARN dari sumber daya baru, seperti berikut ini.

   ```
   {
       "authorizerName": "my-new-authorizer",
       "authorizerArn": "arn:aws:iot:Region:57EXAMPLE833:authorizer/my-new-authorizer"
   }
   ```

   Simpan `authorizerArn` nilai untuk digunakan pada langkah berikutnya.

   Ingat bahwa setiap sumber otorisasi kustom harus memiliki nama yang unik.

### Otorisasi sumber otorisasi kustom
<a name="custom-auth-tutorial-authorizer-permission"></a>

Di bagian ini, Anda akan memberikan izin sumber otorisasi khusus yang baru saja Anda buat izin untuk menjalankan fungsi Lambda. Untuk memberikan izin, Anda dapat menggunakan perintah CLI [izin tambahan](https://docs.aws.amazon.com//cli/latest/reference/lambda/add-permission.html).

**Berikan izin ke fungsi Lambda Anda menggunakan AWS CLI**

1. Setelah memasukkan nilai Anda, masukkan perintah berikut. Perhatikan bahwa `statement-id` nilainya harus unik. Ganti `Id-1234` dengan nilai lain jika Anda telah menjalankan tutorial ini sebelumnya atau jika Anda mendapatkan `ResourceConflictException` kesalahan.

   ```
   aws lambda add-permission  \
   --function-name "custom-auth-function" \
   --principal "iot.amazonaws.com" \
   --action "lambda:InvokeFunction" \
   --statement-id "Id-1234" \
   --source-arn authorizerArn
   ```

1. Jika perintah berhasil, ia mengembalikan pernyataan izin, seperti contoh ini. Anda dapat melanjutkan ke bagian berikutnya untuk menguji otorisasi khusus.

   ```
   {
       "Statement": "{\"Sid\":\"Id-1234\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\"}}}"
   }
   ```

   Jika perintah tidak berhasil, ia mengembalikan kesalahan, seperti contoh ini. Anda harus meninjau dan memperbaiki kesalahan sebelum melanjutkan.

   ```
   An error occurred (AccessDeniedException) when calling the AddPermission operation: User: arn:aws:iam::57EXAMPLE833:user/EXAMPLE-1 is not authorized to perform: lambda:AddPer
   mission on resource: arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function
   ```

## Langkah 4: Uji otorisasi dengan menelepon test-invoke-authorizer
<a name="custom-auth-tutorial-test"></a>

Dengan semua sumber daya yang ditentukan, di bagian ini, Anda akan memanggil test-invoke-authorizer dari baris perintah untuk menguji izin otorisasi.

Perhatikan bahwa ketika memanggil otorisasi dari baris perintah, tidak `protocolData` ditentukan, sehingga otorisasi akan selalu mengembalikan dokumen DENY. Namun, pengujian ini mengonfirmasi bahwa otorisasi khusus dan fungsi Lambda Anda dikonfigurasi dengan benar - bahkan jika itu tidak sepenuhnya menguji fungsi Lambda.

**Untuk menguji otorisasi kustom Anda dan fungsi Lambda dengan menggunakan AWS CLI**

1. Di direktori yang memiliki `private-key.pem` file yang Anda buat pada langkah sebelumnya, jalankan perintah berikut.

   ```
   echo -n "tokenKeyValue" | openssl dgst -sha256 -sign private-key.pem | openssl base64 -A
   ```

   Perintah ini membuat string tanda tangan untuk digunakan pada langkah berikutnya. String tanda tangan terlihat seperti ini:

   ```
   dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mn
   VB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeeh
   bQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjj
   szEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29V
   QJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuX
   f3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+K
   EWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFH
   xRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
   ```

   Salin string tanda tangan ini untuk digunakan pada langkah berikutnya. Berhati-hatilah untuk tidak menyertakan karakter tambahan atau meninggalkannya.

1. Dalam perintah ini, ganti `token-signature` nilai dengan string tanda tangan dari langkah sebelumnya dan jalankan perintah ini untuk menguji otorisasi Anda.

   ```
   aws iot test-invoke-authorizer \
   --authorizer-name my-new-authorizer \
   --token tokenKeyValue \
   --token-signature dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mnVB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeehbQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjjszEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29VQJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuXf3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+KEWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFHxRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
   ```

   Jika perintah berhasil, ia mengembalikan informasi yang dihasilkan oleh fungsi otorisasi kustom Anda, seperti contoh ini.

   ```
   {
       "isAuthenticated": true,
       "principalId": "principalId",
       "policyDocuments": [
           "{\"Version\":\"2012-10-17\",		 	 	 \"Statement\":[{\"Action\":\"iot:*\",\"Effect\":\"Deny\",\"Resource\":\"arn:aws:iot:Region:57EXAMPLE833:*\"}]}"
       ],
       "refreshAfterInSeconds": 600,
       "disconnectAfterInSeconds": 3600
   }
   ```

   Jika perintah mengembalikan kesalahan, tinjau kesalahan dan periksa kembali perintah yang Anda gunakan di bagian ini.

## Langkah 5: Uji penerbitan pesan MQTT menggunakan Postman
<a name="custom-auth-tutorial-postman"></a>

1. Untuk mendapatkan titik akhir data perangkat Anda dari baris perintah, panggil [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) seperti yang ditunjukkan di sini

   ```
   aws iot describe-endpoint --output text --endpoint-type iot:Data-ATS
   ```

   Simpan alamat ini untuk digunakan sebagai *device\$1data\$1endpoint\$1address* di langkah selanjutnya.

1. Buka jendela Postman baru dan buat permintaan HTTP POST baru.

   1. Dari komputer Anda, buka aplikasi Postman.

   1. Di Postman, di menu **File**, pilih **New**... .

   1. Di kotak dialog **Baru**, pilih **Permintaan**.

   1. Dalam permintaan Simpan,

      1. Dalam **nama Permintaan** masukkan**Custom authorizer test request**.

      1. Di **Pilih koleksi atau folder untuk disimpan:** pilih atau buat koleksi untuk menyimpan permintaan ini.

      1. Pilih **Simpan ke *collection\$1name***.

1. Buat permintaan POST untuk menguji otorisasi kustom Anda.

   1. Dalam pemilih metode permintaan di sebelah bidang URL, pilih **POST**. 

   1. Di bidang URL, buat URL untuk permintaan Anda dengan menggunakan URL berikut dengan perintah *device\$1data\$1endpoint\$1address* from the [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) pada langkah sebelumnya.

      ```
      https://device_data_endpoint_address:443/topics/test/cust-auth/topic?qos=0&actionToken=allow
      ```

      Perhatikan bahwa URL ini menyertakan parameter `actionToken=allow` kueri yang akan memberi tahu fungsi Lambda Anda untuk mengembalikan dokumen kebijakan yang memungkinkan akses ke. AWS IoT Setelah Anda memasukkan URL, parameter kueri juga muncul di tab **Params** Postman.

   1. Di tab **Auth**, di bidang **Type**, pilih **No Auth**.

   1. Di tab Header:

      1. Jika ada kunci **Host** yang dicentang, hapus centang yang satu ini.

      1. Di bagian bawah daftar header tambahkan header baru ini dan konfirmasikan bahwa mereka dicentang. Ganti **Host** nilai dengan nilai Anda *device\$1data\$1endpoint\$1address* dan **x-amz-customauthorizer-signature** nilai dengan string tanda tangan yang Anda gunakan dengan **test-invoke-authorize** perintah di bagian sebelumnya.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/iot/latest/developerguide/custom-auth-tutorial.html)

   1. Di tab Tubuh:

      1. Di kotak opsi format data, pilih **Raw**.

      1. Dalam daftar tipe data, pilih **JavaScript**.

      1. Di bidang teks, masukkan payload pesan JSON ini untuk pesan pengujian Anda:

         ```
         {
             "data_mode": "test",
             "vibration": 200,
             "temperature": 40
         }
         ```

1. Pilih **Kirim** untuk mengirim permintaan.

   Jika permintaan berhasil, ia mengembalikan:

   ```
   {
       "message": "OK",
       "traceId": "ff35c33f-409a-ea90-b06f-fbEXAMPLE25c"
   }
   ```

   Respons yang berhasil menunjukkan bahwa otorisasi khusus Anda mengizinkan koneksi ke AWS IoT dan bahwa pesan pengujian dikirimkan ke broker di AWS IoT Core. 

   Jika mengembalikan kesalahan, tinjau pesan kesalahan*device\$1data\$1endpoint\$1address*, string tanda tangan, dan nilai header lainnya.

Simpan permintaan ini di Postman untuk digunakan di bagian berikutnya.

## Langkah 6: Lihat pesan di klien pengujian MQTT
<a name="custom-auth-tutorial-testclient"></a>

Pada langkah sebelumnya, Anda mengirim pesan perangkat simulasi ke AWS IoT dengan menggunakan Postman. Tanggapan yang berhasil menunjukkan bahwa otorisasi khusus Anda mengizinkan koneksi ke AWS IoT dan bahwa pesan pengujian dikirimkan ke broker di AWS IoT Core. Di bagian ini, Anda akan menggunakan klien pengujian MQTT di AWS IoT konsol untuk melihat konten pesan dari pesan tersebut seperti perangkat dan layanan lain.

**Untuk melihat pesan pengujian yang diotorisasi oleh otorisasi kustom Anda**

1. Di AWS IoT konsol, buka klien uji [MQTT](https://console.aws.amazon.com//iot/home#/test).

1. Di tab **Berlangganan topik**, di **Filter topik**, masukkan**test/cust-auth/topic**, yang merupakan topik pesan yang digunakan dalam contoh Tukang Pos dari bagian sebelumnya.

1. Pilih **Langganan**.

   Biarkan jendela ini terlihat untuk langkah berikutnya.

1. Di Postman, dalam permintaan yang Anda buat untuk bagian sebelumnya, pilih **Kirim**.

   Tinjau tanggapan untuk memastikan itu berhasil. Jika tidak, pecahkan masalah kesalahan seperti yang dijelaskan bagian sebelumnya.

1. Di **klien pengujian MQTT**, Anda akan melihat entri baru yang menunjukkan topik pesan dan, jika diperluas, muatan pesan dari permintaan yang Anda kirim dari Tukang Pos.

   Jika Anda tidak melihat pesan Anda di **klien pengujian MQTT**, berikut adalah beberapa hal yang perlu diperiksa:
   + Pastikan permintaan Tukang Pos Anda berhasil dikembalikan. Jika AWS IoT menolak koneksi dan mengembalikan kesalahan, pesan dalam permintaan tidak diteruskan ke broker pesan.
   + Pastikan Akun AWS dan yang Wilayah AWS digunakan untuk membuka AWS IoT konsol sama dengan yang Anda gunakan di URL Postman.
   + Pastikan Anda menggunakan titik akhir yang sesuai untuk otorisasi kustom. Titik akhir IoT default mungkin tidak mendukung penggunaan otorisasi khusus dengan fungsi Lambda. Sebagai gantinya, Anda dapat menggunakan konfigurasi domain untuk menentukan titik akhir baru dan kemudian menentukan titik akhir tersebut untuk otorisasi kustom.
   + Pastikan Anda telah memasukkan topik dengan benar di klien pengujian **MQTT**. Filter topik peka huruf besar/kecil. Jika ragu, Anda juga dapat berlangganan **\$1** topik, yang berlangganan semua pesan MQTT yang melewati broker pesan Akun AWS dan Wilayah AWS digunakan untuk membuka konsol. AWS IoT 

## Langkah 7: Tinjau hasil dan langkah selanjutnya
<a name="custom-auth-tutorial-review"></a>

**Dalam tutorial ini:**
+ Anda membuat fungsi Lambda untuk menjadi penangan otorisasi khusus
+ Anda membuat otorisasi khusus dengan penandatanganan token diaktifkan
+ Anda menguji otorisasi kustom Anda menggunakan perintah **test-invoke-authorizer**
+ Anda menerbitkan topik MQTT dengan menggunakan [Postman](https://www.postman.com/) dan memvalidasi permintaan dengan otorisasi khusus Anda
+ Anda menggunakan **klien pengujian MQTT untuk melihat pesan yang dikirim dari tes** Postman Anda

**Langkah selanjutnya**  
Setelah Anda mengirim beberapa pesan dari Postman untuk memverifikasi bahwa otorisasi kustom berfungsi, coba bereksperimen untuk melihat bagaimana mengubah berbagai aspek tutorial ini memengaruhi hasil. Berikut adalah beberapa contoh untuk Anda mulai.
+ Ubah string tanda tangan sehingga tidak lagi valid untuk melihat bagaimana upaya koneksi yang tidak sah ditangani. Anda akan mendapatkan respons kesalahan, seperti ini, dan pesan tidak akan muncul di klien pengujian **MQTT**. 

  ```
  {
      "message": "Forbidden",
      "traceId": "15969756-a4a4-917c-b47a-5433e25b1356"
  }
  ```
+ Untuk mempelajari lebih lanjut tentang cara menemukan kesalahan yang mungkin terjadi saat Anda mengembangkan dan menggunakan AWS IoT aturan, lihat[Pemantauan AWS IoT](monitoring_overview.md).

## Langkah 8: Membersihkan
<a name="custom-auth-tutorial-cleanup"></a>

Jika Anda ingin mengulangi tutorial ini, Anda mungkin perlu menghapus beberapa otorisasi kustom Anda. Anda hanya Akun AWS dapat memiliki sejumlah otorisasi khusus yang dikonfigurasi pada satu waktu dan Anda bisa mendapatkan `LimitExceededException` ketika Anda mencoba menambahkan yang baru tanpa menghapus otorisasi kustom yang ada.

**Untuk menghapus otorisasi khusus (konsol)**

1. Buka [halaman otorisasi khusus AWS IoT konsol](https://console.aws.amazon.com//iot/home#/authorizerhub), dan dalam daftar otorisasi khusus, temukan otorisasi khusus untuk dihapus.

1. Buka halaman detail otorisasi kustom dan, dari menu **Tindakan**, pilih **Edit**.

1. **Hapus centang pada **Activate authorizer**, lalu pilih Update.**

   Anda tidak dapat menghapus otorisasi khusus saat sedang aktif.

1. Dari halaman Detail otorisasi khusus, buka menu **Tindakan**, dan pilih **Hapus**.

**Untuk menghapus otorisasi kustom ()AWS CLI**

1. Buat daftar otorisasi khusus yang telah Anda instal dan temukan nama otorisasi khusus yang ingin Anda hapus.

   ```
   aws iot list-authorizers 
   ```

1. Atur otorisasi khusus `inactive` dengan menjalankan perintah ini setelah mengganti `Custom_Auth_Name` dengan otorisasi khusus untuk dihapus. `authorizerName`

   ```
   aws iot update-authorizer --status INACTIVE --authorizer-name Custom_Auth_Name
   ```

1. Hapus otorisasi khusus dengan menjalankan perintah ini setelah mengganti `Custom_Auth_Name` dengan otorisasi khusus untuk dihapus. `authorizerName`

   ```
   aws iot delete-authorizer --authorizer-name Custom_Auth_Name
   ```

# Tutorial: Memantau kelembaban tanah dengan AWS IoT dan Raspberry Pi
<a name="iot-moisture-tutorial"></a>

Tutorial ini menunjukkan kepada Anda cara menggunakan [Raspberry Pi](https://www.raspberrypi.org/), sensor kelembaban, dan AWS IoT untuk memantau tingkat kelembaban tanah untuk tanaman rumah atau taman. Raspberry Pi menjalankan kode yang membaca tingkat kelembaban dan suhu dari sensor dan kemudian mengirimkan data ke AWS IoT. Anda membuat aturan AWS IoT yang mengirim email ke alamat yang berlangganan topik Amazon SNS saat tingkat kelembaban turun di bawah ambang batas.

**catatan**  
Tutorial ini mungkin tidak up to date. Beberapa referensi mungkin telah digantikan karena topik ini awalnya diterbitkan.

**Contents**
+ [Prasyarat](#iot-moisture-prereqs)
+ [Menyiapkan AWS IoT](iot-moisture-setup.md)
  + [Langkah 1: Buat AWS IoT kebijakan](iot-moisture-policy.md)
  + [Langkah 2: Buat AWS IoT benda, sertifikat, dan kunci pribadi](iot-moisture-create-thing.md)
  + [Langkah 3: Buat topik dan langganan Amazon SNS](iot-moisture-create-sns-topic.md)
  + [Langkah 4: Buat AWS IoT aturan untuk mengirim email](iot-moisture-create-rule.md)
+ [Menyiapkan Raspberry Pi dan sensor kelembaban](iot-moisture-raspi-setup.md)

## Prasyarat
<a name="iot-moisture-prereqs"></a>

Untuk menyelesaikan tutorial ini, Anda memerlukan:
+ Sebuah Akun AWS.
+ Pengguna IAM dengan izin administrator.
+ [Komputer pengembangan yang menjalankan Windows, macOS, Linux, atau Unix untuk mengakses konsol.AWS IoT](https://console.aws.amazon.com/iot/home)
+ [Raspberry Pi 3B atau 4B yang menjalankan OS](https://www.raspberrypi.com/products/) [Raspberry Pi](https://www.raspberrypi.com/software/operating-systems/) terbaru. Untuk petunjuk penginstalan, lihat [Menginstal sistem operasi](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) di situs web Raspberry Pi. 
+ Monitor, keyboard, mouse, dan jaringan Wi-Fi atau koneksi Ethernet untuk Raspberry Pi Anda.
+ Sensor kelembaban yang kompatibel dengan Raspberry Pi. Sensor yang digunakan dalam tutorial ini adalah [Adafruit STEMMA I2C Capacitive Moisture Sensor](https://www.adafruit.com/product/4026) dengan header kabel soket 4-pin [JST](https://www.adafruit.com/product/3950) ke wanita. 

# Menyiapkan AWS IoT
<a name="iot-moisture-setup"></a>

Untuk menyelesaikan tutorial ini, Anda perlu membuat sumber daya berikut. Untuk menghubungkan perangkat AWS IoT, Anda membuat IoT, sertifikat perangkat, dan kebijakan. AWS IoT 
+  AWS IoT Sesuatu.

  Sesuatu mewakili perangkat fisik (dalam hal ini, Rasberry Pi Anda) dan berisi metadata statis tentang perangkat. 
+ Sertifikat perangkat.

  Semua perangkat harus memiliki sertifikat perangkat untuk terhubung dan mengautentikasi. AWS IoT
+ Sebuah AWS IoT kebijakan.

  Setiap sertifikat perangkat memiliki satu atau lebih AWS IoT kebijakan yang terkait dengannya. Kebijakan ini menentukan AWS IoT sumber daya mana yang dapat diakses perangkat. 
+ Sertifikat CA AWS IoT root.

  Perangkat dan klien lain menggunakan sertifikat CA AWS IoT root untuk mengautentikasi AWS IoT server yang dengannya mereka berkomunikasi. Untuk informasi selengkapnya, lihat [Otentikasi server](server-authentication.md).
+ Sebuah AWS IoT aturan.

  Aturan berisi kueri dan satu atau beberapa tindakan aturan. Kueri mengekstrak data dari pesan perangkat untuk menentukan apakah data pesan harus diproses. Tindakan aturan menentukan apa yang harus dilakukan jika data cocok dengan query.
+ Langganan topik dan topik Amazon SNS.

  Aturan mendengarkan data kelembaban dari Raspberry Pi Anda. Jika nilainya di bawah ambang batas, ia mengirim pesan ke topik Amazon SNS. Amazon SNS mengirimkan pesan itu ke semua alamat email yang berlangganan topik tersebut.

 



# Langkah 1: Buat AWS IoT kebijakan
<a name="iot-moisture-policy"></a>

Buat AWS IoT kebijakan yang memungkinkan Raspberry Pi Anda terhubung dan mengirim pesan AWS IoT.

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot), jika tombol **Mulai** muncul, pilih. Jika tidak, di panel navigasi, perluas **Keamanan**, lalu pilih **Kebijakan**.

1. Jika kotak dialog **Anda belum memiliki kebijakan apa pun** muncul, pilih **Buat kebijakan**. Jika tidak, pilih **Buat**.

1. Masukkan nama untuk AWS IoT kebijakan (misalnya,**MoistureSensorPolicy**).

1. Di bagian **Tambah pernyataan**, ganti kebijakan yang ada dengan JSON berikut. Ganti *region* dan *account* dengan Akun AWS nomor Wilayah AWS dan Anda.  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "iot:Connect",
               "Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
           },
           {
               "Effect": "Allow",
               "Action": "iot:Publish",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
               ]
           },
           {
               "Effect": "Allow",
               "Action": "iot:Receive",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
               ]
           },
           {
               "Effect": "Allow",
               "Action": "iot:Subscribe",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "iot:GetThingShadow",
                   "iot:UpdateThingShadow",
                   "iot:DeleteThingShadow"
               ],
               "Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
           }
       ]
   }
   ```

1. Pilih **Buat**.

# Langkah 2: Buat AWS IoT benda, sertifikat, dan kunci pribadi
<a name="iot-moisture-create-thing"></a>

Buat sesuatu di AWS IoT registri untuk mewakili Raspberry Pi Anda.

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), di panel navigasi, pilih **Kelola**, lalu pilih **Things**.

1. Jika kotak dialog **Anda belum memiliki hal apa pun** ditampilkan, pilih **Daftarkan sesuatu**. Jika tidak, pilih **Buat**.

1. Pada halaman **Creating AWS IoT things**, pilih **Create a single**.

1. **Pada halaman **Tambahkan perangkat Anda ke registri perangkat**, masukkan nama untuk hal IoT Anda (misalnya,**RaspberryPi**), lalu pilih Berikutnya.** Anda tidak dapat mengubah nama sesuatu setelah Anda membuatnya. Untuk mengubah nama hal, Anda harus membuat hal baru, memberikan nama baru, dan kemudian menghapus hal lama.

1. Pada halaman **Tambahkan sertifikat untuk hal Anda**, pilih **Buat sertifikat**.

1. Pilih tautan **Unduh** untuk mengunduh sertifikat, kunci pribadi, dan sertifikat root CA.
**penting**  
Ini adalah satu-satunya waktu Anda dapat mengunduh sertifikat dan kunci pribadi Anda.

1. Untuk mengaktifkan sertifikat, pilih **Aktifkan**. Sertifikat harus aktif agar perangkat dapat terhubung AWS IoT.

1. Pilih **Lampirkan kebijakan**.

1. Untuk **Tambahkan kebijakan untuk barang Anda**, pilih **MoistureSensorPolicy**, lalu pilih **Register Thing**.

# Langkah 3: Buat topik dan langganan Amazon SNS
<a name="iot-moisture-create-sns-topic"></a>

Buat topik dan langganan Amazon SNS.

1. Dari [konsol AWS SNS](https://console.aws.amazon.com/sns/home), di panel navigasi, pilih **Topik**, lalu pilih **Buat** topik.

1. Pilih ketik sebagai **Standar** dan masukkan nama untuk topik (misalnya,**MoistureSensorTopic**).

1. Masukkan nama tampilan untuk topik (misalnya,**Moisture Sensor Topic**). Ini adalah nama yang ditampilkan untuk topik Anda di konsol Amazon SNS.

1. Pilih **Buat topik**.

1. Di halaman detail topik Amazon SNS, pilih **Buat** langganan.

1. Untuk **Protokol**, pilih **Email**.

1. Untuk **Titik Akhir**, masukkan alamat email Anda.

1. Pilih **Buat langganan**.

1. Buka klien email Anda dan cari pesan dengan subjek**MoistureSensorTopic**. Buka email dan klik tautan **Konfirmasi berlangganan**.
**penting**  
Anda tidak akan menerima peringatan email apa pun dari topik Amazon SNS ini sampai Anda mengonfirmasi langganan.

Anda harus menerima pesan email dengan teks yang Anda ketik.

# Langkah 4: Buat AWS IoT aturan untuk mengirim email
<a name="iot-moisture-create-rule"></a>

 AWS IoT Aturan mendefinisikan kueri dan satu atau beberapa tindakan yang harus diambil saat pesan diterima dari perangkat. Mesin AWS IoT aturan mendengarkan pesan yang dikirim oleh perangkat dan menggunakan data dalam pesan untuk menentukan apakah beberapa tindakan harus diambil. Untuk informasi selengkapnya, lihat [Aturan untuk AWS IoT](iot-rules.md). 

Dalam tutorial ini, Raspberry Pi Anda menerbitkan pesan di`aws/things/RaspberryPi/shadow/update`. Ini adalah topik MQTT internal yang digunakan oleh perangkat dan layanan Thing Shadow. Raspberry Pi menerbitkan pesan yang memiliki bentuk berikut:

```
{
    "reported": {
        "moisture" : moisture-reading,
        "temp" : temperature-reading
    }
}
```

Anda membuat kueri yang mengekstrak data kelembaban dan suhu dari pesan yang masuk. Anda juga membuat tindakan Amazon SNS yang mengambil data dan mengirimkannya ke pelanggan topik Amazon SNS jika pembacaan kelembaban di bawah nilai ambang batas.

**Buat aturan Amazon SNS**

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), pilih **Perutean pesan,** lalu pilih **Aturan**. Jika kotak dialog **Anda belum memiliki aturan apa pun** muncul, pilih **Buat aturan**. Jika tidak, pilih **Buat aturan**.

1. Di halaman **properti Aturan**, masukkan **nama Aturan** seperti**MoistureSensorRule**, dan berikan **deskripsi Aturan** singkat seperti**Sends an alert when soil moisture level readings are too low**.

1. Pilih **Berikutnya** dan konfigurasikan pernyataan SQL Anda. Pilih **versi SQL** sebagai **2016-03-23**, dan masukkan pernyataan query SQL berikut: AWS IoT 

   ```
   SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
   ```

   Pernyataan ini memicu tindakan aturan ketika `moisture` pembacaan kurang dari`400`.
**catatan**  
Anda mungkin harus menggunakan nilai yang berbeda. Setelah kode berjalan pada Raspberry Pi Anda, Anda dapat melihat nilai yang Anda dapatkan dari sensor Anda dengan menyentuh sensor, menempatkannya di air, atau menempatkannya di penanam. 

1. Pilih **Berikutnya** dan lampirkan tindakan aturan. Untuk **Tindakan 1**, pilih **Layanan Pemberitahuan Sederhana**. Deskripsi untuk tindakan aturan ini adalah **Kirim pesan sebagai pemberitahuan push SNS**.

1. Untuk **topik SNS**, pilih topik yang Anda buat [Langkah 3: Buat topik dan langganan Amazon SNS](iot-moisture-create-sns-topic.md) **MoistureSensorTopic**, dan biarkan **format Pesan** sebagai **RAW**. Untuk **Peran IAM**, pilih **Buat Peran Baru**. Masukkan nama untuk peran, misalnya**LowMoistureTopicRole**, lalu pilih **Buat peran**.

1. Pilih **Berikutnya** untuk meninjau dan kemudian pilih **Buat** untuk membuat aturan.

# Menyiapkan Raspberry Pi dan sensor kelembaban
<a name="iot-moisture-raspi-setup"></a>



Masukkan kartu microSD Anda ke Raspberry Pi, sambungkan monitor, keyboard, mouse, dan, jika Anda tidak menggunakan Wi-Fi, kabel Ethernet. Jangan sambungkan kabel daya dulu.

Hubungkan kabel jumper JST ke sensor kelembaban. Sisi lain dari jumper memiliki empat kabel:
+ Hijau: I2C SCL
+ Putih: I2C SDA
+ Merah: daya (3,5 V)
+ Hitam: tanah

Pegang Raspberry Pi dengan jack Ethernet di sebelah kanan. Dalam orientasi ini, ada dua baris pin GPIO di bagian atas. Hubungkan kabel dari sensor kelembaban ke baris bawah pin dengan urutan berikut. Mulai dari pin paling kiri, sambungkan merah (power), putih (SDA), dan hijau (SCL). Lewati satu pin, lalu hubungkan kabel hitam (ground). Untuk informasi selengkapnya, lihat Pengkabelan [Komputer Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).

Pasang kabel daya ke Raspberry Pi dan colokkan ujung lainnya ke stopkontak untuk menyalakannya.

**Konfigurasikan Raspberry Pi Anda**

1. Pada **Selamat Datang di Raspberry Pi**, pilih **Berikutnya**.

1. Pilih negara, bahasa, zona waktu, dan tata letak keyboard Anda. Pilih **Berikutnya**.

1. Masukkan kata sandi untuk Raspberry Pi Anda, lalu pilih **Berikutnya**.

1. Pilih jaringan Wi-Fi Anda, lalu pilih **Berikutnya**. Jika Anda tidak menggunakan jaringan Wi-Fi, pilih **Lewati**.

1. Pilih **Berikutnya** untuk memeriksa pembaruan perangkat lunak. Ketika pembaruan selesai, pilih **Restart untuk memulai ulang** Raspberry Pi Anda.

Setelah Raspberry Pi Anda dimulai, aktifkan antarmuka I2C.

1. Di sudut kiri atas desktop Raspbian, klik ikon Raspberry, pilih **Preferences**, dan kemudian pilih **Raspberry Pi Configuration**.

1. **Pada tab **Antarmuka**, untuk **I2C**, pilih Aktifkan.**

1. Pilih **OK**.

Perpustakaan untuk sensor kelembaban Adafruit STEMMA ditulis untuk. CircuitPython Untuk menjalankannya di Raspberry Pi, Anda perlu menginstal versi terbaru Python 3.

1. Jalankan perintah berikut dari prompt perintah untuk memperbarui perangkat lunak Raspberry Pi Anda:

   `sudo apt-get update`

   `sudo apt-get upgrade`

1. Jalankan perintah berikut untuk memperbarui instalasi Python 3 Anda:

   `sudo pip3 install --upgrade setuptools`

1. Jalankan perintah berikut untuk menginstal perpustakaan Raspberry Pi GPIO:

   `pip3 install RPI.GPIO`

1. Jalankan perintah berikut untuk menginstal perpustakaan Adafruit Blinka:

   `pip3 install adafruit-blinka`

   Untuk informasi selengkapnya, lihat [Menginstal CircuitPython Pustaka di Raspberry Pi](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi).

1. Jalankan perintah berikut untuk menginstal perpustakaan Adafruit Seesaw:

   `sudo pip3 install adafruit-circuitpython-seesaw`

1. Jalankan perintah berikut untuk menginstal AWS IoT Device SDK untuk Python:

   `pip3 install AWSIoTPythonSDK`

Raspberry Pi Anda sekarang memiliki semua pustaka yang diperlukan. Buat file bernama **moistureSensor.py** dan salin kode Python berikut ke dalam file:

```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA

import logging
import time
import json
import argparse
import busio

# Shadow JSON schema:
#
# {
#   "state": {
#       "desired":{
#           "moisture":<INT VALUE>,
#           "temp":<INT VALUE>            
#       }
#   }
# }

# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):

    # Display status and data from update request
    if responseStatus == "timeout":
        print("Update request " + token + " time out!")

    if responseStatus == "accepted":
        payloadDict = json.loads(payload)
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Update request with token: " + token + " accepted!")
        print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
        print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Update request " + token + " rejected!")

# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):

     # Display status and data from delete request
    if responseStatus == "timeout":
        print("Delete request " + token + " time out!")

    if responseStatus == "accepted":
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Delete request with token: " + token + " accepted!")
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Delete request " + token + " rejected!")


# Read in command-line parameters
def parseArgs():

    parser = argparse.ArgumentParser()
    parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
    parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
    parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
    parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
    parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
    parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
    parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")

    args = parser.parse_args()
    return args


# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():

    logger = logging.getLogger("AWSIoTPythonSDK.core")
    logger.setLevel(logging.DEBUG)
    streamHandler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    streamHandler.setFormatter(formatter)
    logger.addHandler(streamHandler)


# Parse command line arguments
args = parseArgs()

if not args.certificatePath or not args.privateKeyPath:
    parser.error("Missing credentials for authentication.")
    exit(2)

# If no --port argument is passed, default to 8883
if not args.port: 
    args.port = 8883


# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)

# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec

# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)

# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)

# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()

# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)

# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)

# Read data from moisture sensor and update shadow
while True:

    # read moisture level through capacitive touch pad
    moistureLevel = ss.moisture_read()

    # read temperature from the temperature sensor
    temp = ss.get_temp()

    # Display moisture and temp readings
    print("Moisture Level: {}".format(moistureLevel))
    print("Temperature: {}".format(temp))
    
    # Create message payload
    payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}

    # Update shadow
    deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
    time.sleep(1)
```

Simpan file ke tempat Anda dapat menemukannya. Jalankan `moistureSensor.py` dari baris perintah dengan parameter berikut:

titik akhir  
 AWS IoT Titik akhir kustom Anda. Untuk informasi selengkapnya, lihat [Device Shadow REST API](device-shadow-rest-api.md).

rootCA  
Jalur lengkap ke sertifikat CA AWS IoT root Anda.

sertifikat  
Jalur lengkap ke sertifikat AWS IoT perangkat Anda.

kunci  
Jalur lengkap ke kunci pribadi sertifikat AWS IoT perangkat Anda.

thingName  
Nama barang Anda (dalam hal ini,`RaspberryPi`).

clientId  
ID klien MQTT. Gunakan `RaspberryPi`.

Baris perintah akan terlihat seperti ini:

`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`

Coba sentuh sensor, letakkan di penanam, atau masukkan ke dalam segelas air untuk melihat bagaimana sensor merespons berbagai tingkat kelembapan. Jika diperlukan, Anda dapat mengubah nilai ambang batas di`MoistureSensorRule`. Saat pembacaan sensor kelembaban berada di bawah nilai yang ditentukan dalam pernyataan kueri SQL aturan Anda, AWS IoT menerbitkan pesan ke topik Amazon SNS. Anda harus menerima pesan email yang berisi data kelembaban dan suhu.

Setelah Anda memverifikasi penerimaan pesan email dari Amazon SNS, tekan **CTRL\$1C** untuk menghentikan program Python. Tidak mungkin program Python akan mengirim pesan yang cukup untuk dikenakan biaya, tetapi ini adalah praktik terbaik untuk menghentikan program ketika Anda selesai.