Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Menghubungkan perangkat AWS IoT Core dengan menggunakan AWS IoT Device SDK
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
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
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
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
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
`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
`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
`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
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
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
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
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
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
`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
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
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
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
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
Berdasarkan latihan sebelumnya, modifikasi aplikasi `pubsub.py` sampel untuk mengevaluasi topik pesan dan memproses pesan berlangganan berdasarkan topik.
#### Prosedur latihan
**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
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
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
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
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
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
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
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
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
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)