Tutorial: Berinteraksi dengan perangkat IoT lokal melalui MQTT

Di menu navigasi konsol AWS IoT Greengrass tersebut, pilih Perangkat inti.

Pada halaman Perangkat inti, pilih perangkat inti yang akan diperbarui.

Pada halaman detail perangkat inti, pilih tautan ke Objek perangkat inti. Tautan ini membuka halaman rincian hal di AWS IoT konsol.

Pada halaman detail objek, pilih Sertifikat.

Di tab Sertifikat, pilih sertifikat aktif objek.

Pada halaman detail sertifikat, pilih Kebijakan.

Di tab Kebijakan, pilih kebijakan AWS IoT yang akan ditinjau dan diperbarui. Anda dapat menambahkan izin yang diperlukan untuk kebijakan yang dilampirkan ke sertifikat aktif perangkat inti.

Dalam ikhtisar kebijakan, pilih Edit versi aktif.

Tinjau kebijakan untuk izin yang diperlukan, dan tambahkan izin yang diperlukan yang hilang.

Untuk menetapkan versi kebijakan baru sebagai versi aktif, di bawah Status versi Kebijakan, pilih Setel versi yang diedit sebagai versi aktif untuk kebijakan ini.

Pilih Simpan sebagai versi baru.

Navigasikan ke konsol AWS IoT Greengrass tersebut.

Di menu navigasi kiri, pilih Perangkat inti.

Pada halaman Perangkat Inti, pilih perangkat inti tempat Anda ingin mengaktifkan dukungan perangkat klien.

Pada halaman detail perangkat inti, pilih tab Perangkat klien.

Pada tab Perangkat klien, pilih Konfigurasikan penemuan cloud.

Halaman Konfigurasikan penemuan perangkat inti terbuka. Di bagian ini, Anda mengaitkan perangkat klien ke perangkat inti dan men-deploy komponen perangkat klien. Halaman ini memilih perangkat inti untuk Anda di Langkah 1: Pilih perangkat inti target.

Di Langkah 2: Kaitkan perangkat klien, kaitkan objek AWS IoT ke perangkat inti. Hal ini memungkinkan perangkat klien untuk menggunakan penemuan cloud untuk mengambil informasi konektivitas perangkat inti dan sertifikat. Lakukan hal-hal berikut:

1. Pilih Kaitkan perangkat klien.

2. Di modal Kaitkan perangkat klien dengan perangkat inti, masukkan nama objek AWS IoT yang akan dikaitkan.

3. Pilih Tambahkan.

4. Pilih Kaitkan.

Di Langkah 3: Konfigurasi dan deploy komponen Greengrass, deploy komponen untuk mengaktifkan dukungan perangkat klien. Jika perangkat inti target memiliki deployment sebelumnya, halaman ini merevisi deployment tersebut. Jika tidak, halaman ini membuat deployment baru untuk perangkat inti. Lakukan hal berikut untuk mengonfigurasi dan men-deploy komponen perangkat klien:

1. Perangkat inti harus menjalankan Greengrass nucleus v2.6.0 atau yang lebih baru untuk menyelesaikan tutorial ini. Jika perangkat inti menjalankan versi sebelumnya, lakukan hal berikut:

   1. Pilih kotak untuk menyebarkan aws.greengrass.Nucleuskomponen.

   2. Untuk komponen aws.greengrass.Nucleus, pilih Edit konfigurasi.

   3. Untuk versi Komponen, pilih versi 2.6.0 atau yang lebih baru.

   4. Pilih Konfirmasi.

   catatan

   Jika Anda memutakhirkan inti Greengrass dari versi minor sebelumnya, dan perangkat inti AWSmenjalankan komponen yang disediakan yang bergantung pada nukleus, Anda juga harus memperbarui AWS komponen yang disediakan ke versi yang lebih baru. Anda dapat mengonfigurasi versi komponen ini ketika Anda meninjau deployment nanti dalam tutorial ini. Untuk informasi selengkapnya, lihat Perbarui perangkat lunak inti AWS IoT Greengrass (OTA).

2. Untuk komponen aws.greengrass.clientdevices.Auth, pilih Edit konfigurasi.

3. Di modal Edit konfigurasi untuk komponen auth perangkat klien, konfigurasi kebijakan otorisasi yang memungkinkan perangkat klien untuk mempublikasikan dan berlangganan broker MQTT pada perangkat inti. Lakukan hal-hal berikut:

   1. Di bawah Konfigurasi, di blok Konfigurasi untuk menggabungkan kode, masukkan konfigurasi berikut, yang berisi kebijakan otorisasi perangkat klien. Setiap perangkat grup otorisasi kebijakan menentukan serangkaian tindakan dan sumber daya di mana perangkat klien dapat melakukan tindakan tersebut.

      • Kebijakan ini memungkinkan perangkat klien yang namanya dimulai dengan MyClientDevice untuk menghubungkan dan berkomunikasi pada semua topik MQTT. MyClientDeviceGanti* dengan nama AWS IoT benda yang akan dihubungkan sebagai perangkat klien. Anda juga dapat menentukan nama dengan wldcard * yang cocok dengan nama perangkat klien. Wildcard * harus di akhir nama.

        Jika Anda memiliki perangkat klien kedua untuk disambungkan, MyOtherClientDeviceganti* dengan nama perangkat klien tersebut, atau pola wildcard yang cocok dengan nama perangkat klien tersebut. Jika tidak, Anda dapat menghapus atau menyimpan bagian ini dari aturan pemilihan yang memungkinkan perangkat klien dengan nama yang cocok dengan MyOtherClientDevice* untuk terhubung dan berkomunikasi.

      • Kebijakan ini menggunakan operator OR untuk juga memungkinkan perangkat klien yang namanya dimulai dengan MyOtherClientDevice untuk menghubungkan dan berkomunikasi pada semua topik MQTT. Anda dapat menghapus klausul ini dalam aturan seleksi atau memodifikasinya agar cocok dengan perangkat klien untuk terhubung.

      • Kebijakan ini memungkinkan perangkat klien untuk mempublikasikan dan berlangganan pada semua topik MQTT. Untuk mengikuti praktik keamanan terbaik, batasi operasi mqtt:publish dan mqtt:subscribe ke set minimal topik yang diagunakan oleh perangkat klien untuk berkomunikasi.

      {
        "deviceGroups": {
          "formatVersion": "2021-03-05",
          "definitions": {
            "MyDeviceGroup": {
              "selectionRule": "thingName: MyClientDevice* OR thingName: MyOtherClientDevice*",
              "policyName": "MyClientDevicePolicy"
            }
          },
          "policies": {
            "MyClientDevicePolicy": {
              "AllowConnect": {
                "statementDescription": "Allow client devices to connect.",
                "operations": [
                  "mqtt:connect"
                ],
                "resources": [
                  "*"
                ]
              },
              "AllowPublish": {
                "statementDescription": "Allow client devices to publish to all topics.",
                "operations": [
                  "mqtt:publish"
                ],
                "resources": [
                  "*"
                ]
              },
              "AllowSubscribe": {
                "statementDescription": "Allow client devices to subscribe to all topics.",
                "operations": [
                  "mqtt:subscribe"
                ],
                "resources": [
                  "*"
                ]
              }
            }
          }
        }
      }

      Untuk informasi lebih lanjut, lihat Konfigurasi komponen auth perangkat klien.

   2. Pilih Konfirmasi.

4. Untuk komponen aws.greengrass.clientdevices.mqtt.Bridge, pilih Edit konfigurasi.

5. Di modal Edit konfigurasi untuk komponen jembatan MQTT, konfigurasi pemetaan topik yang menyampaikan pesan MQTT dari perangkat klien ke AWS IoT Core. Lakukan hal-hal berikut:

   1. Di bawah Konfigurasi, di blok kode Konfigurasi yang akan digabungkan, masukkan konfigurasi berikut. Konfigurasi ini menentukan untuk merelai pesan MQTT pada topik filter clients/+/hello/world dari perangkat klien ke layanan cloud AWS IoT Core. Sebagai contoh, filter topik ini cocok dengan topik clients/MyClientDevice1/hello/world.

      {
        "mqttTopicMapping": {
          "HelloWorldIotCoreMapping": {
            "topic": "clients/+/hello/world",
            "source": "LocalMqtt",
            "target": "IotCore"
          }
        }
      }

      Untuk informasi lebih lanjut, lihat konfigurasi komponen jembatan MQTT.

   2. Pilih Konfirmasi.

Pilih Tinjau dan deploy untuk meninjau deployment yang dibuat oleh halaman ini untuk Anda.

Jika sebelumnya Anda belum mengatur Peran layanan Greengrass di Wilayah ini, konsol membuka modal untuk mengatur peran layanan untuk Anda. Komponen autentikasi perangkat klien menggunakan peran layanan ini untuk memverifikasi identitas perangkat klien, dan komponen detektor IP menggunakan peran layanan ini untuk mengelola informasi konektivitas perangkat inti. Pilih Berikan izin.

Pada halaman Tinjauan, pilih Deploy untuk memulai deployment ke perangkat inti.

Untuk memverifikasi bahwa deployment berhasil, periksa status deployment, dan periksa log pada perangkat inti. Untuk memeriksa status deployment pada perangkat inti, Anda dapat memilih Target pada Gambaran Umum deployment. Untuk informasi selengkapnya, lihat hal berikut:

Unduh dan instal v2 for Python AWS IoT Device SDK ke objek AWS IoT untuk terhubung sebagai perangkat klien.

Di perangkat klien, lakukan hal berikut:

1. Kloning v2 for Python repository AWS IoT Device SDK untuk mengunduhnya.

   git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git

2. Instal v2 for Python AWS IoT Device SDK.

   python3 -m pip install --user ./aws-iot-device-sdk-python-v2

Ubah ke folder contoh di v2 for Python AWS IoT Device SDK.

cd aws-iot-device-sdk-python-v2/samples

Jalankan sampel aplikasi penemuan Greengrass. Aplikasi ini mengharapkan argumen yang menentukan nama objek perangkat klien, topik MQTT dan pesan yang akan digunakan, dan sertifikat yang mengautentikasi dan mengamankan sambungan. Contoh berikut mengirimkan pesan Hello World ke topik clients/MyClientDevice1/hello/world.

python3 basic_discovery.py \\
  --thing_name MyClientDevice1 \\
  --topic 'clients/MyClientDevice1/hello/world' \\
  --message 'Hello World!' \\
  --ca_file ~/certs/AmazonRootCA1.pem \\
  --cert ~/certs/device.pem.crt \\
  --key ~/certs/private.pem.key \\
  --region us-east-1 \\
  --verbosity Warn

Aplikasi sampel penemuan mengirimkan pesan 10 kali dan terputus. Aplikasi ini juga berlangganan topik yang sama di mana ia menerbitkan pesan. Jika output menunjukkan bahwa aplikasi itu menerima pesan MQTT pada topik, perangkat klien dapat berhasil berkomunikasi dengan perangkat inti.

Performing greengrass discovery...
awsiot.greengrass_discovery.DiscoverResponse(gg_groups=[awsiot.greengrass_discovery.GGGroup(gg_group_id='greengrassV2-coreDevice-MyGreengrassCore', cores=[awsiot.greengrass_discovery.GGCore(thing_arn='arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore', connectivity=[awsiot.greengrass_discovery.ConnectivityInfo(id='203.0.113.0', host_address='203.0.113.0', metadata='', port=8883)])], certificate_authorities=['-----BEGIN CERTIFICATE-----\
MIICiT...EXAMPLE=\
-----END CERTIFICATE-----\
'])])
Trying core arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore at host 203.0.113.0 port 8883
Connected!
Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 0}

Publish received on topic clients/MyClientDevice1/hello/world
b'{"message": "Hello World!", "sequence": 0}'
Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 1}

Publish received on topic clients/MyClientDevice1/hello/world
b'{"message": "Hello World!", "sequence": 1}'

...

Published topic clients/MyClientDevice1/hello/world: {"message": "Hello World!", "sequence": 9}

Publish received on topic clients/MyClientDevice1/hello/world
b'{"message": "Hello World!", "sequence": 9}'

Jika aplikasi mengeluarkan kesalahan, lihat Pemecahan masalah penemuan Greengrass.

Anda juga dapat melihat log Greengrass pada perangkat inti untuk memverifikasi apakah perangkat klien berhasil menghubungkan dan mengirim pesan. Untuk informasi selengkapnya, lihat Memantau AWS IoT Greengrass log.

Verifikasi bahwa jembatan MQTT merelai pesan dari perangkat klien ke AWS IoT Core. Anda dapat menggunakan klien tes MQTT di konsol AWS IoT Core untuk berlangganan filter topik MQTT. Lakukan hal-hal berikut:

1. Navigasikan ke konsol AWS IoT tersebut.

2. Di menu navigasi sebelah kiri, di bawah Pengujian pilih klien uji MQTT.

3. Pada tab Berlangganan topik, untuk Filter topik, masukkan clients/+/hello/world untuk berlangganan pesan perangkat klien dari perangkat inti.

4. Pilih Langganan.

5. Jalankan aplikasi publish/subscribe pada perangkat klien lagi.

   Klien tes MQTT menampilkan pesan yang Anda kirim dari perangkat klien pada topik yang cocok dengan filter topik ini.

Revisi deployment ke perangkat inti dan konfigurasikan komponen jembatan MQTT untuk menyampaikan pesan dari perangkat klien ke antarmuka lokal. Lakukan hal-hal berikut:

1. Navigasikan ke konsol AWS IoT Greengrass tersebut.

2. Di menu navigasi kiri, pilih Perangkat inti.

3. Pada halaman Perangkat inti, pilih perangkat inti yang Anda gunakan untuk tutorial ini.

4. Pada halaman detail perangkat inti, pilih tab Perangkat klien.

5. Pada tab Perangkat klien, pilih Konfigurasikan penemuan cloud.

   Halaman Konfigurasikan penemuan perangkat inti terbuka. Pada halaman ini, Anda dapat mengubah atau mengonfigurasi komponen perangkat klien mana yang di-deploy ke perangkat inti.

6. Di Langkah 3, untuk komponen aws.greengrass.clientdevices.mqtt.Bridge, pilih Edit konfigurasi.

7. Di modal Edit konfigurasi untuk komponen jembatan MQTT, konfigurasikan pemetaan topik yang menyampaikan pesan MQTT dari perangkat klien ke antarmuka publish/subscribe lokal. Lakukan hal-hal berikut:

   1. Di bawah Konfigurasi, di blok kode Konfigurasi yang akan digabungkan, masukkan konfigurasi berikut. Konfigurasi ini menentukan untuk menyampaikan pesan MQTT pada topik yang cocok dengan topik filter clients/+/hello/world dari perangkat klien ke layanan cloud AWS IoT Core dan broker publish/subscribe Greengrass lokal.

      {
        "mqttTopicMapping": {
          "HelloWorldIotCoreMapping": {
            "topic": "clients/+/hello/world",
            "source": "LocalMqtt",
            "target": "IotCore"
          },
          "HelloWorldPubsubMapping": {
            "topic": "clients/+/hello/world",
            "source": "LocalMqtt",
            "target": "Pubsub"
          }
        }
      }

      Untuk informasi lebih lanjut, lihat konfigurasi komponen jembatan MQTT.

   2. Pilih Konfirmasi.

8. Pilih Tinjau dan deploy untuk meninjau deployment yang dibuat oleh halaman ini untuk Anda.

9. Pada halaman Tinjauan, pilih Deploy untuk memulai deployment ke perangkat inti.

10. Untuk memverifikasi bahwa deployment berhasil, periksa status deployment, dan periksa log pada perangkat inti. Untuk memeriksa status deployment pada perangkat inti, Anda dapat memilih Target pada Gambaran Umum deployment. Untuk informasi selengkapnya, lihat hal berikut:

    • Periksa status deployment

    • Memantau AWS IoT Greengrass log

Kembangkan dan deploy komponen Greengrass yang berlangganan pesan Hello World dari perangkat klien. Lakukan hal-hal berikut:

1. Buat folder untuk resep dan artefak pada perangkat inti.

   Linux or Unix

   mkdir recipes
   mkdir -p artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0

   Windows Command Prompt (CMD)

   mkdir recipes
   mkdir artifacts\com.example.clientdevices.MyHelloWorldSubscriber\1.0.0

   PowerShell

   mkdir recipes
   mkdir artifacts\com.example.clientdevices.MyHelloWorldSubscriber\1.0.0

   penting

   Anda harus menggunakan format berikut untuk jalur folder artifact. Sertakan nama dan versi komponen yang Anda tentukan dalam resep.

   artifacts/componentName/componentVersion/

2. Gunakan editor teks untuk membuat resep komponen dengan konten berikut. Resep ini menentukan untuk menginstal AWS IoT Device SDK v2 untuk Python dan menjalankan skrip yang berlangganan topik dan mencetak pesan.

   Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.

   nano recipes/com.example.clientdevices.MyHelloWorldSubscriber-1.0.0.json

   Salin resep berikut ke dalam file.

   {
     "RecipeFormatVersion": "2020-01-25",
     "ComponentName": "com.example.clientdevices.MyHelloWorldSubscriber",
     "ComponentVersion": "1.0.0",
     "ComponentDescription": "A component that subscribes to Hello World messages from client devices.",
     "ComponentPublisher": "Amazon",
     "ComponentConfiguration": {
       "DefaultConfiguration": {
         "accessControl": {
           "aws.greengrass.ipc.pubsub": {
             "com.example.clientdevices.MyHelloWorldSubscriber:pubsub:1": {
               "policyDescription": "Allows access to subscribe to all topics.",
               "operations": [
                 "aws.greengrass#SubscribeToTopic"
               ],
               "resources": [
                 "*"
               ]
             }
           }
         }
       }
     },
     "Manifests": [
       {
         "Platform": {
           "os": "linux"
         },
         "Lifecycle": {
           "install": "python3 -m pip install --user awsiotsdk",
           "run": "python3 -u {artifacts:path}/hello_world_subscriber.py"
         }
       },
       {
         "Platform": {
           "os": "windows"
         },
         "Lifecycle": {
           "install": "py -3 -m pip install --user awsiotsdk",
           "run": "py -3 -u {artifacts:path}/hello_world_subscriber.py"
         }
       }
     ]
   }

3. Gunakan editor teks untuk membuat artefak skrip Python bernama hello_world_subscriber.py dengan konten berikut. Aplikasi ini menggunakan layanan IPC publish/subscribe untuk berlangganan topik clients/+/hello/world dan pesan cetak yang diterimanya.

   Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.

   nano artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0/hello_world_subscriber.py

   Salin kode Python berikut ke dalam file.

   import sys
   import time
   import traceback
   
   from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
   
   CLIENT_DEVICE_HELLO_WORLD_TOPIC = 'clients/+/hello/world'
   TIMEOUT = 10
   
   
   def on_hello_world_message(event):
       try:
           message = str(event.binary_message.message, 'utf-8')
           print('Received new message: %s' % message)
       except:
           traceback.print_exc()
   
   
   try:
       ipc_client = GreengrassCoreIPCClientV2()
   
       # SubscribeToTopic returns a tuple with the response and the operation.
       _, operation = ipc_client.subscribe_to_topic(
           topic=CLIENT_DEVICE_HELLO_WORLD_TOPIC, on_stream_event=on_hello_world_message)
       print('Successfully subscribed to topic: %s' %
             CLIENT_DEVICE_HELLO_WORLD_TOPIC)
   
       # Keep the main thread alive, or the process will exit.
       try:
           while True:
               time.sleep(10)
       except InterruptedError:
           print('Subscribe interrupted.')
   
       operation.close()
   except Exception:
       print('Exception occurred when using IPC.', file=sys.stderr)
       traceback.print_exc()
       exit(1)
   

   catatan

   Komponen ini menggunakan klien IPC V2 di AWS IoT Device SDKv2 untuk Python untuk berkomunikasi dengan AWS IoT Greengrass perangkat lunak Core. Dibandingkan dengan klien IPC asli, klien IPC V2 mengurangi jumlah kode yang perlu Anda tulis untuk menggunakan IPC dalam komponen khusus.

4. Gunakn Greengrass CLI untuk men-deploy komponen.

   Linux or Unix

   sudo /greengrass/v2/bin/greengrass-cli deployment create \
     --recipeDir recipes \
     --artifactDir artifacts \
     --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"

   Windows Command Prompt (CMD)

   C:\greengrass\v2/bin/greengrass-cli deployment create ^
     --recipeDir recipes ^
     --artifactDir artifacts ^
     --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"

   PowerShell

   C:\greengrass\v2/bin/greengrass-cli deployment create `
     --recipeDir recipes `
     --artifactDir artifacts `
     --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"

Lihat log komponen untuk memverifikasi bahwa komponen berhasil menginstal dan berlangganan topik.

Anda dapat menjaga log feed tetap terbuka untuk memverifikasi bahwa inti perangkat menerima pesan.

Pada perangkat klien, jalankan sampel aplikasi penemuan Greengrass lagi untuk mengirim pesan ke perangkat inti.

python3 basic_discovery.py \\
  --thing_name MyClientDevice1 \\
  --topic 'clients/MyClientDevice1/hello/world' \\
  --message 'Hello World!' \\
  --ca_file ~/certs/AmazonRootCA1.pem \\
  --cert ~/certs/device.pem.crt \\
  --key ~/certs/private.pem.key \\
  --region us-east-1 \\
  --verbosity Warn

Lihat log komponen lagi untuk memverifikasi bahwa komponen menerima dan mencetak pesan dari perangkat klien.

Merevisi penerapan ke perangkat inti untuk menyebarkan komponen pengelola bayangan dan mengonfigurasi komponen jembatan MQTT untuk menyampaikan pesan bayangan antara perangkat klien dan penerbitan/langganan lokal, tempat manajer bayangan berkomunikasi. Lakukan hal-hal berikut:

1. Navigasikan ke konsol AWS IoT Greengrass tersebut.

2. Di menu navigasi kiri, pilih Perangkat inti.

3. Pada halaman Perangkat inti, pilih perangkat inti yang Anda gunakan untuk tutorial ini.

4. Pada halaman detail perangkat inti, pilih tab Perangkat klien.

5. Pada tab Perangkat klien, pilih Konfigurasikan penemuan cloud.

   Halaman Konfigurasikan penemuan perangkat inti terbuka. Pada halaman ini, Anda dapat mengubah atau mengonfigurasi komponen perangkat klien mana yang di-deploy ke perangkat inti.

6. Di Langkah 3, untuk komponen aws.greengrass.clientdevices.mqtt.Bridge, pilih Edit konfigurasi.

7. Dalam modal konfigurasi Edit untuk komponen jembatan MQTT, konfigurasikan pemetaan topik yang menyampaikan pesan MQTT pada topik bayangan perangkat antara perangkat klien dan antarmuka penerbitan/langganan lokal. Anda juga mengonfirmasi bahwa penerapan menentukan versi jembatan MQTT yang kompatibel. Dukungan bayangan perangkat klien memerlukan jembatan MQTT v2.2.0 atau yang lebih baru. Lakukan hal-hal berikut:

   1. Untuk versi Komponen, pilih versi 2.2.0 atau yang lebih baru.

   2. Di bawah Konfigurasi, di blok kode Konfigurasi yang akan digabungkan, masukkan konfigurasi berikut. Konfigurasi ini menentukan untuk menyampaikan pesan MQTT pada topik bayangan.

      {
        "mqttTopicMapping": {
          "HelloWorldIotCoreMapping": {
            "topic": "clients/+/hello/world",
            "source": "LocalMqtt",
            "target": "IotCore"
          },
          "HelloWorldPubsubMapping": {
            "topic": "clients/+/hello/world",
            "source": "LocalMqtt",
            "target": "Pubsub"
          },
          "ShadowsLocalMqttToPubsub": {
            "topic": "$aws/things/+/shadow/#",
            "source": "LocalMqtt",
            "target": "Pubsub"
          },
          "ShadowsPubsubToLocalMqtt": {
            "topic": "$aws/things/+/shadow/#",
            "source": "Pubsub",
            "target": "LocalMqtt"
          }
        }
      }

      Untuk informasi lebih lanjut, lihat konfigurasi komponen jembatan MQTT.

   3. Pilih Konfirmasi.

8. Pada Langkah 3, pilih aws.greengrass.ShadowManagerkomponen untuk menerapkannya.

9. Pilih Tinjau dan deploy untuk meninjau deployment yang dibuat oleh halaman ini untuk Anda.

10. Pada halaman Tinjauan, pilih Deploy untuk memulai deployment ke perangkat inti.

11. Untuk memverifikasi bahwa deployment berhasil, periksa status deployment, dan periksa log pada perangkat inti. Untuk memeriksa status deployment pada perangkat inti, Anda dapat memilih Target pada Gambaran Umum deployment. Untuk informasi selengkapnya, lihat hal berikut:

    • Periksa status deployment

    • Memantau AWS IoT Greengrass log

Kembangkan dan terapkan komponen Greengrass yang mengelola perangkat klien cahaya pintar. Lakukan hal-hal berikut:

1. Buat folder artefak komponen pada perangkat inti.

   Linux or Unix

   mkdir -p artifacts/com.example.clientdevices.MySmartLightManager/1.0.0

   Windows Command Prompt (CMD)

   mkdir artifacts\com.example.clientdevices.MySmartLightManager\1.0.0

   PowerShell

   mkdir artifacts\com.example.clientdevices.MySmartLightManager\1.0.0

   penting

   Anda harus menggunakan format berikut untuk jalur folder artifact. Sertakan nama dan versi komponen yang Anda tentukan dalam resep.

   artifacts/componentName/componentVersion/

2. Gunakan editor teks untuk membuat resep komponen dengan konten berikut. Resep ini menentukan untuk menginstal AWS IoT Device SDK v2 untuk Python dan menjalankan skrip yang berinteraksi dengan bayangan perangkat klien cahaya pintar untuk mengelola warnanya.

   Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.

   nano recipes/com.example.clientdevices.MySmartLightManager-1.0.0.json

   Salin resep berikut ke dalam file.

   {
     "RecipeFormatVersion": "2020-01-25",
     "ComponentName": "com.example.clientdevices.MySmartLightManager",
     "ComponentVersion": "1.0.0",
     "ComponentDescription": "A component that interacts with smart light client devices.",
     "ComponentPublisher": "Amazon",
     "ComponentDependencies": {
       "aws.greengrass.Nucleus": {
         "VersionRequirement": "^2.6.0"
       },
       "aws.greengrass.ShadowManager": {
         "VersionRequirement": "^2.2.0"
       },
       "aws.greengrass.clientdevices.mqtt.Bridge": {
         "VersionRequirement": "^2.2.0"
       }
     },
     "ComponentConfiguration": {
       "DefaultConfiguration": {
         "smartLightDeviceNames": [],
         "accessControl": {
           "aws.greengrass.ShadowManager": {
             "com.example.clientdevices.MySmartLightManager:shadow:1": {
               "policyDescription": "Allows access to client devices' unnamed shadows",
               "operations": [
                 "aws.greengrass#GetThingShadow",
                 "aws.greengrass#UpdateThingShadow"
               ],
               "resources": [
                 "$aws/things/MyClientDevice*/shadow"
               ]
             }
           },
           "aws.greengrass.ipc.pubsub": {
             "com.example.clientdevices.MySmartLightManager:pubsub:1": {
               "policyDescription": "Allows access to client devices' unnamed shadow updates",
               "operations": [
                 "aws.greengrass#SubscribeToTopic"
               ],
               "resources": [
                 "$aws/things/+/shadow/update/accepted"
               ]
             }
           }
         }
       }
     },
     "Manifests": [
       {
         "Platform": {
           "os": "linux"
         },
         "Lifecycle": {
           "install": "python3 -m pip install --user awsiotsdk",
           "run": "python3 -u {artifacts:path}/smart_light_manager.py"
         }
       },
       {
         "Platform": {
           "os": "windows"
         },
         "Lifecycle": {
           "install": "py -3 -m pip install --user awsiotsdk",
           "run": "py -3 -u {artifacts:path}/smart_light_manager.py"
         }
       }
     ]
   }

3. Gunakan editor teks untuk membuat artefak skrip Python bernama smart_light_manager.py dengan konten berikut. Aplikasi ini menggunakan layanan shadow IPC untuk mendapatkan dan memperbarui bayangan perangkat klien dan layanan IPC penerbitan/berlangganan lokal untuk menerima pembaruan bayangan yang dilaporkan.

   Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.

   nano artifacts/com.example.clientdevices.MySmartLightManager/1.0.0/smart_light_manager.py

   Salin kode Python berikut ke dalam file.

   import json
   import random
   import sys
   import time
   import traceback
   from uuid import uuid4
   
   from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
   from awsiot.greengrasscoreipc.model import ResourceNotFoundError
   
   SHADOW_COLOR_PROPERTY = 'color'
   CONFIGURATION_CLIENT_DEVICE_NAMES = 'smartLightDeviceNames'
   COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple']
   SHADOW_UPDATE_TOPIC = '$aws/things/+/shadow/update/accepted'
   SET_COLOR_INTERVAL = 15
   
   
   class SmartLightDevice():
       def __init__(self, client_device_name: str, reported_color: str = None):
           self.name = client_device_name
           self.reported_color = reported_color
           self.desired_color = None
   
   
   class SmartLightDeviceManager():
       def __init__(self, ipc_client: GreengrassCoreIPCClientV2):
           self.ipc_client = ipc_client
           self.devices = {}
           self.client_tokens = set()
           self.shadow_update_accepted_subscription_operation = None
           self.client_device_names_configuration_subscription_operation = None
           self.update_smart_light_device_list()
   
       def update_smart_light_device_list(self):
           # Update the device list from the component configuration.
           response = self.ipc_client.get_configuration(
               key_path=[CONFIGURATION_CLIENT_DEVICE_NAMES])
           # Identify the difference between the configuration and the currently tracked devices.
           current_device_names = self.devices.keys()
           updated_device_names = response.value[CONFIGURATION_CLIENT_DEVICE_NAMES]
           added_device_names = set(updated_device_names) - set(current_device_names)
           removed_device_names = set(current_device_names) - set(updated_device_names)
           # Stop tracking any smart light devices that are no longer in the configuration.
           for name in removed_device_names:
               print('Removing %s from smart light device manager' % name)
               self.devices.pop(name)
           # Start tracking any new smart light devices that are in the configuration.
           for name in added_device_names:
               print('Adding %s to smart light device manager' % name)
               device = SmartLightDevice(name)
               device.reported_color = self.get_device_reported_color(device)
               self.devices[name] = device
               print('Current color for %s is %s' % (name, device.reported_color))
   
       def get_device_reported_color(self, smart_light_device):
           try:
               response = self.ipc_client.get_thing_shadow(
                   thing_name=smart_light_device.name, shadow_name='')
               shadow = json.loads(str(response.payload, 'utf-8'))
               if 'reported' in shadow['state']:
                   return shadow['state']['reported'].get(SHADOW_COLOR_PROPERTY)
               return None
           except ResourceNotFoundError:
               return None
   
       def request_device_color_change(self, smart_light_device, color):
           # Generate and track a client token for the request.
           client_token = str(uuid4())
           self.client_tokens.add(client_token)
           # Create a shadow payload, which must be a blob.
           payload_json = {
               'state': {
                   'desired': {
                       SHADOW_COLOR_PROPERTY: color
                   }
               },
               'clientToken': client_token
           }
           payload = bytes(json.dumps(payload_json), 'utf-8')
           self.ipc_client.update_thing_shadow(
               thing_name=smart_light_device.name, shadow_name='', payload=payload)
           smart_light_device.desired_color = color
   
       def subscribe_to_shadow_update_accepted_events(self):
           if self.shadow_update_accepted_subscription_operation == None:
               # SubscribeToTopic returns a tuple with the response and the operation.
               _, self.shadow_update_accepted_subscription_operation = self.ipc_client.subscribe_to_topic(
                   topic=SHADOW_UPDATE_TOPIC, on_stream_event=self.on_shadow_update_accepted_event)
               print('Successfully subscribed to shadow update accepted topic')
   
       def close_shadow_update_accepted_subscription(self):
           if self.shadow_update_accepted_subscription_operation is not None:
               self.shadow_update_accepted_subscription_operation.close()
   
       def on_shadow_update_accepted_event(self, event):
           try:
               message = str(event.binary_message.message, 'utf-8')
               accepted_payload = json.loads(message)
               # Check for reported states from smart light devices and ignore desired states from components.
               if 'reported' in accepted_payload['state']:
                   # Process this update only if it uses a client token created by this component.
                   client_token = accepted_payload.get('clientToken')
                   if client_token is not None and client_token in self.client_tokens:
                       self.client_tokens.remove(client_token)
                       shadow_state = accepted_payload['state']['reported']
                       if SHADOW_COLOR_PROPERTY in shadow_state:
                           reported_color = shadow_state[SHADOW_COLOR_PROPERTY]
                           topic = event.binary_message.context.topic
                           client_device_name = topic.split('/')[2]
                           if client_device_name in self.devices:
                               # Set the reported color for the smart light device.
                               self.devices[client_device_name].reported_color = reported_color
                               print(
                                   'Received shadow update confirmation from client device: %s' % client_device_name)
                       else:
                           print("Shadow update doesn't specify color")
           except:
               traceback.print_exc()
   
       def subscribe_to_client_device_name_configuration_updates(self):
           if self.client_device_names_configuration_subscription_operation == None:
               # SubscribeToConfigurationUpdate returns a tuple with the response and the operation.
               _, self.client_device_names_configuration_subscription_operation = self.ipc_client.subscribe_to_configuration_update(
                   key_path=[CONFIGURATION_CLIENT_DEVICE_NAMES], on_stream_event=self.on_client_device_names_configuration_update_event)
               print(
                   'Successfully subscribed to configuration updates for smart light device names')
   
       def close_client_device_names_configuration_subscription(self):
           if self.client_device_names_configuration_subscription_operation is not None:
               self.client_device_names_configuration_subscription_operation.close()
   
       def on_client_device_names_configuration_update_event(self, event):
           try:
               if CONFIGURATION_CLIENT_DEVICE_NAMES in event.configuration_update_event.key_path:
                   print('Received configuration update for list of client devices')
                   self.update_smart_light_device_list()
           except:
               traceback.print_exc()
   
   
   def choose_random_color():
       return random.choice(COLORS)
   
   def main():
       try:
           # Create an IPC client and a smart light device manager.
           ipc_client = GreengrassCoreIPCClientV2()
           smart_light_manager = SmartLightDeviceManager(ipc_client)
           smart_light_manager.subscribe_to_shadow_update_accepted_events()
           smart_light_manager.subscribe_to_client_device_name_configuration_updates()
           try:
               # Keep the main thread alive, or the process will exit.
               while True:
                   # Set each smart light device to a random color at a regular interval.
                   for device_name in smart_light_manager.devices:
                       device = smart_light_manager.devices[device_name]
                       desired_color = choose_random_color()
                       print('Chose random color (%s) for %s' %
                             (desired_color, device_name))
                       if desired_color == device.desired_color:
                           print('Desired color for %s is already %s' %
                                 (device_name, desired_color))
                       elif desired_color == device.reported_color:
                           print('Reported color for %s is already %s' %
                                 (device_name, desired_color))
                       else:
                           smart_light_manager.request_device_color_change(
                               device, desired_color)
                           print('Requested color change for %s to %s' %
                                 (device_name, desired_color))
                   time.sleep(SET_COLOR_INTERVAL)
           except InterruptedError:
               print('Application interrupted')
           smart_light_manager.close_shadow_update_accepted_subscription()
           smart_light_manager.close_client_device_names_configuration_subscription()
       except Exception:
           print('Exception occurred', file=sys.stderr)
           traceback.print_exc()
           exit(1)
   
   
   if __name__ == '__main__':
       main()
   

   Aplikasi Python ini melakukan hal berikut:

   • Membaca konfigurasi komponen untuk mendapatkan daftar perangkat klien cahaya pintar untuk dikelola.

   • Berlangganan pemberitahuan pembaruan konfigurasi menggunakan operasi SubscribeToConfigurationUpdate IPC. Perangkat lunak AWS IoT Greengrass Core mengirimkan pemberitahuan setiap kali konfigurasi komponen berubah. Saat komponen menerima pemberitahuan pembaruan konfigurasi, komponen akan memperbarui daftar perangkat klien cahaya pintar yang dikelolanya.

   • Mendapat bayangan setiap perangkat klien cahaya pintar untuk mendapatkan status warna awalnya.

   • Mengatur warna setiap perangkat klien cahaya pintar ke warna acak setiap 15 detik. Komponen memperbarui bayangan benda perangkat klien untuk mengubah warnanya. Operasi ini mengirimkan peristiwa delta bayangan ke perangkat klien melalui MQTT.

   • Berlangganan pembaruan bayangan pesan yang diterima pada antarmuka penerbitan/berlangganan lokal menggunakan operasi IPC. SubscribeToTopic Komponen ini menerima pesan-pesan ini untuk melacak warna setiap perangkat klien cahaya pintar. Ketika perangkat klien cahaya pintar menerima pembaruan bayangan, ia mengirimkan pesan MQTT untuk mengonfirmasi bahwa ia menerima pembaruan. Jembatan MQTT menyampaikan pesan ini ke antarmuka penerbitan/berlangganan lokal.

4. Gunakn Greengrass CLI untuk men-deploy komponen. Saat menerapkan komponen ini, Anda menentukan daftar perangkat kliensmartLightDeviceNames, yang bayangannya dikelola. Ganti MyClientDevice1 dengan nama benda perangkat klien.

   Linux or Unix

   sudo /greengrass/v2/bin/greengrass-cli deployment create \
     --recipeDir recipes \
     --artifactDir artifacts \
     --merge "com.example.clientdevices.MySmartLightManager=1.0.0" \
     --update-config '{
       "com.example.clientdevices.MySmartLightManager": {
         "MERGE": {
           "smartLightDeviceNames": [
             "MyClientDevice1"
           ]
         }
       }
     }'

   Windows Command Prompt (CMD)

   C:\greengrass\v2/bin/greengrass-cli deployment create ^
     --recipeDir recipes ^
     --artifactDir artifacts ^
     --merge "com.example.clientdevices.MySmartLightManager=1.0.0" ^
     --update-config '{"com.example.clientdevices.MySmartLightManager":{"MERGE":{"smartLightDeviceNames":["MyClientDevice1"]}}}'

   PowerShell

   C:\greengrass\v2/bin/greengrass-cli deployment create `
     --recipeDir recipes `
     --artifactDir artifacts `
     --merge "com.example.clientdevices.MySmartLightManager=1.0.0" `
     --update-config '{
       "com.example.clientdevices.MySmartLightManager": {
         "MERGE": {
           "smartLightDeviceNames": [
             "MyClientDevice1"
           ]
         }
       }
     }'

Lihat log komponen untuk memverifikasi bahwa komponen menginstal dan berjalan dengan sukses.

Komponen mengirimkan permintaan untuk mengubah warna perangkat klien cahaya pintar. Manajer bayangan menerima permintaan dan menetapkan desired status bayangan. Namun, perangkat klien cahaya pintar belum berjalan, sehingga reported status bayangan tidak berubah. Log komponen menyertakan pesan-pesan berikut.

2022-07-07T03:49:24.908Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Chose random color (blue) for MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}
2022-07-07T03:49:24.912Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Requested color change for MyClientDevice1 to blue. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}

Anda dapat membiarkan umpan log tetap terbuka untuk melihat kapan komponen mencetak pesan.

Unduh dan jalankan contoh aplikasi yang menggunakan penemuan Greengrass dan berlangganan pembaruan bayangan perangkat. Di perangkat klien, lakukan hal berikut:

1. Ubah ke folder contoh di v2 for Python AWS IoT Device SDK. Aplikasi sampel ini menggunakan modul parsing baris perintah di folder sampel.

   cd aws-iot-device-sdk-python-v2/samples

2. Gunakan editor teks untuk membuat skrip Python bernama basic_discovery_shadow.py dengan konten berikut. Aplikasi ini menggunakan penemuan Greengrass dan bayangan untuk menjaga properti tetap sinkron antara perangkat klien dan perangkat inti.

   Misalnya, pada sistem berbasis Linux, Anda dapat menjalankan perintah berikut untuk menggunakan GNU nano untuk membuat file.

   nano basic_discovery_shadow.py

   Salin kode Python berikut ke dalam file.

   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier: Apache-2.0.
   
   from awscrt import io
   from awscrt import mqtt
   from awsiot import iotshadow
   from awsiot.greengrass_discovery import DiscoveryClient
   from awsiot import mqtt_connection_builder
   from concurrent.futures import Future
   import sys
   import threading
   import traceback
   from uuid import uuid4
   
   # Parse arguments
   import utils.command_line_utils;
   cmdUtils = utils.command_line_utils.CommandLineUtils("Basic Discovery - Greengrass discovery example with device shadows.")
   cmdUtils.add_common_mqtt_commands()
   cmdUtils.add_common_topic_message_commands()
   cmdUtils.add_common_logging_commands()
   cmdUtils.register_command("key", "<path>", "Path to your key in PEM format.", True, str)
   cmdUtils.register_command("cert", "<path>", "Path to your client certificate in PEM format.", True, str)
   cmdUtils.remove_command("endpoint")
   cmdUtils.register_command("thing_name", "<str>", "The name assigned to your IoT Thing", required=True)
   cmdUtils.register_command("region", "<str>", "The region to connect through.", required=True)
   cmdUtils.register_command("shadow_property", "<str>", "The name of the shadow property you want to change (optional, default='color'", default="color")
   # Needs to be called so the command utils parse the commands
   cmdUtils.get_args()
   
   # Using globals to simplify sample code
   is_sample_done = threading.Event()
   mqtt_connection = None
   shadow_thing_name = cmdUtils.get_command_required("thing_name")
   shadow_property = cmdUtils.get_command("shadow_property")
   
   SHADOW_VALUE_DEFAULT = "off"
   
   class LockedData:
       def __init__(self):
           self.lock = threading.Lock()
           self.shadow_value = None
           self.disconnect_called = False
           self.request_tokens = set()
   
   locked_data = LockedData()
   
   
   def on_connection_interupted(connection, error, **kwargs):
       print('connection interrupted with error {}'.format(error))
   
   
   def on_connection_resumed(connection, return_code, session_present, **kwargs):
       print('connection resumed with return code {}, session present {}'.format(return_code, session_present))
   
   # Try IoT endpoints until we find one that works
   def try_iot_endpoints():
       for gg_group in discover_response.gg_groups:
           for gg_core in gg_group.cores:
               for connectivity_info in gg_core.connectivity:
                   try:
                       print('Trying core {} at host {} port {}'.format(gg_core.thing_arn, connectivity_info.host_address, connectivity_info.port))
                       mqtt_connection = mqtt_connection_builder.mtls_from_path(
                           endpoint=connectivity_info.host_address,
                           port=connectivity_info.port,
                           cert_filepath=cmdUtils.get_command_required("cert"),
                           pri_key_filepath=cmdUtils.get_command_required("key"),
                           ca_bytes=gg_group.certificate_authorities[0].encode('utf-8'),
                           on_connection_interrupted=on_connection_interupted,
                           on_connection_resumed=on_connection_resumed,
                           client_id=cmdUtils.get_command_required("thing_name"),
                           clean_session=False,
                           keep_alive_secs=30)
   
                       connect_future = mqtt_connection.connect()
                       connect_future.result()
                       print('Connected!')
                       return mqtt_connection
   
                   except Exception as e:
                       print('Connection failed with exception {}'.format(e))
                       continue
   
       exit('All connection attempts failed')
   
   # Function for gracefully quitting this sample
   def exit(msg_or_exception):
       if isinstance(msg_or_exception, Exception):
           print("Exiting sample due to exception.")
           traceback.print_exception(msg_or_exception.__class__, msg_or_exception, sys.exc_info()[2])
       else:
           print("Exiting sample:", msg_or_exception)
   
       with locked_data.lock:
           if not locked_data.disconnect_called:
               print("Disconnecting...")
               locked_data.disconnect_called = True
               future = mqtt_connection.disconnect()
               future.add_done_callback(on_disconnected)
   
   def on_disconnected(disconnect_future):
       # type: (Future) -> None
       print("Disconnected.")
   
       # Signal that sample is finished
       is_sample_done.set()
   
   def on_get_shadow_accepted(response):
       # type: (iotshadow.GetShadowResponse) -> None
       try:
           with locked_data.lock:
               # check that this is a response to a request from this session
               try:
                   locked_data.request_tokens.remove(response.client_token)
               except KeyError:
                   return
   
               print("Finished getting initial shadow state.")
               if locked_data.shadow_value is not None:
                   print("  Ignoring initial query because a delta event has already been received.")
                   return
   
           if response.state:
               if response.state.delta:
                   value = response.state.delta.get(shadow_property)
                   if value:
                       print("  Shadow contains delta value '{}'.".format(value))
                       change_shadow_value(value)
                       return
   
               if response.state.reported:
                   value = response.state.reported.get(shadow_property)
                   if value:
                       print("  Shadow contains reported value '{}'.".format(value))
                       set_local_value_due_to_initial_query(response.state.reported[shadow_property])
                       return
   
           print("  Shadow document lacks '{}' property. Setting defaults...".format(shadow_property))
           change_shadow_value(SHADOW_VALUE_DEFAULT)
           return
   
       except Exception as e:
           exit(e)
   
   def on_get_shadow_rejected(error):
       # type: (iotshadow.ErrorResponse) -> None
       try:
           # check that this is a response to a request from this session
           with locked_data.lock:
               try:
                   locked_data.request_tokens.remove(error.client_token)
               except KeyError:
                   return
   
           if error.code == 404:
               print("Thing has no shadow document. Creating with defaults...")
               change_shadow_value(SHADOW_VALUE_DEFAULT)
           else:
               exit("Get request was rejected. code:{} message:'{}'".format(
                   error.code, error.message))
   
       except Exception as e:
           exit(e)
   
   def on_shadow_delta_updated(delta):
       # type: (iotshadow.ShadowDeltaUpdatedEvent) -> None
       try:
           print("Received shadow delta event.")
           if delta.state and (shadow_property in delta.state):
               value = delta.state[shadow_property]
               if value is None:
                   print("  Delta reports that '{}' was deleted. Resetting defaults...".format(shadow_property))
                   change_shadow_value(SHADOW_VALUE_DEFAULT)
                   return
               else:
                   print("  Delta reports that desired value is '{}'. Changing local value...".format(value))
                   if (delta.client_token is not None):
                       print ("  ClientToken is: " + delta.client_token)
                   change_shadow_value(value, delta.client_token)
           else:
               print("  Delta did not report a change in '{}'".format(shadow_property))
   
       except Exception as e:
           exit(e)
   
   def on_publish_update_shadow(future):
       #type: (Future) -> None
       try:
           future.result()
           print("Update request published.")
       except Exception as e:
           print("Failed to publish update request.")
           exit(e)
   
   def on_update_shadow_accepted(response):
       # type: (iotshadow.UpdateShadowResponse) -> None
       try:
           # check that this is a response to a request from this session
           with locked_data.lock:
               try:
                   locked_data.request_tokens.remove(response.client_token)
               except KeyError:
                   return
   
           try:
               if response.state.reported != None:
                   if shadow_property in response.state.reported:
                       print("Finished updating reported shadow value to '{}'.".format(response.state.reported[shadow_property])) # type: ignore
                   else:
                       print ("Could not find shadow property with name: '{}'.".format(shadow_property)) # type: ignore
               else:
                   print("Shadow states cleared.") # when the shadow states are cleared, reported and desired are set to None
           except:
               exit("Updated shadow is missing the target property")
   
       except Exception as e:
           exit(e)
   
   def on_update_shadow_rejected(error):
       # type: (iotshadow.ErrorResponse) -> None
       try:
           # check that this is a response to a request from this session
           with locked_data.lock:
               try:
                   locked_data.request_tokens.remove(error.client_token)
               except KeyError:
                   return
   
           exit("Update request was rejected. code:{} message:'{}'".format(
               error.code, error.message))
   
       except Exception as e:
           exit(e)
   
   def set_local_value_due_to_initial_query(reported_value):
       with locked_data.lock:
           locked_data.shadow_value = reported_value
   
   def change_shadow_value(value, token=None):
       with locked_data.lock:
           if locked_data.shadow_value == value:
               print("Local value is already '{}'.".format(value))
               return
   
           print("Changed local shadow value to '{}'.".format(value))
           locked_data.shadow_value = value
   
           print("Updating reported shadow value to '{}'...".format(value))
   
           reuse_token = token is not None
           # use a unique token so we can correlate this "request" message to
           # any "response" messages received on the /accepted and /rejected topics
           if not reuse_token:
               token = str(uuid4())
   
           # if the value is "clear shadow" then send a UpdateShadowRequest with None
           # for both reported and desired to clear the shadow document completely.
           if value == "clear_shadow":
               tmp_state = iotshadow.ShadowState(reported=None, desired=None, reported_is_nullable=True, desired_is_nullable=True)
               request = iotshadow.UpdateShadowRequest(
                   thing_name=shadow_thing_name,
                   state=tmp_state,
                   client_token=token,
               )
           # Otherwise, send a normal update request
           else:
               # if the value is "none" then set it to a Python none object to
               # clear the individual shadow property
               if value == "none":
                   value = None
   
               request = iotshadow.UpdateShadowRequest(
               thing_name=shadow_thing_name,
               state=iotshadow.ShadowState(
                   reported={ shadow_property: value }
                   ),
                   client_token=token,
               )
   
           future = shadow_client.publish_update_shadow(request, mqtt.QoS.AT_LEAST_ONCE)
   
           if not reuse_token:
               locked_data.request_tokens.add(token)
   
           future.add_done_callback(on_publish_update_shadow)
   
   
   if __name__ == '__main__':
       tls_options = io.TlsContextOptions.create_client_with_mtls_from_path(cmdUtils.get_command_required("cert"), cmdUtils.get_command_required("key"))
       if cmdUtils.get_command(cmdUtils.m_cmd_ca_file):
           tls_options.override_default_trust_store_from_path(None, cmdUtils.get_command(cmdUtils.m_cmd_ca_file))
       tls_context = io.ClientTlsContext(tls_options)
   
       socket_options = io.SocketOptions()
   
       print('Performing greengrass discovery...')
       discovery_client = DiscoveryClient(io.ClientBootstrap.get_or_create_static_default(), socket_options, tls_context, cmdUtils.get_command_required("region"))
       resp_future = discovery_client.discover(cmdUtils.get_command_required("thing_name"))
       discover_response = resp_future.result()
   
       print(discover_response)
       if cmdUtils.get_command("print_discover_resp_only"):
           exit(0)
   
       mqtt_connection = try_iot_endpoints()
       shadow_client = iotshadow.IotShadowClient(mqtt_connection)
   
       try:
           # Subscribe to necessary topics.
           # Note that is **is** important to wait for "accepted/rejected" subscriptions
           # to succeed before publishing the corresponding "request".
           print("Subscribing to Update responses...")
           update_accepted_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_accepted(
               request=iotshadow.UpdateShadowSubscriptionRequest(thing_name=shadow_thing_name),
               qos=mqtt.QoS.AT_LEAST_ONCE,
               callback=on_update_shadow_accepted)
   
           update_rejected_subscribed_future, _ = shadow_client.subscribe_to_update_shadow_rejected(
               request=iotshadow.UpdateShadowSubscriptionRequest(thing_name=shadow_thing_name),
               qos=mqtt.QoS.AT_LEAST_ONCE,
               callback=on_update_shadow_rejected)
   
           # Wait for subscriptions to succeed
           update_accepted_subscribed_future.result()
           update_rejected_subscribed_future.result()
   
           print("Subscribing to Get responses...")
           get_accepted_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_accepted(
               request=iotshadow.GetShadowSubscriptionRequest(thing_name=shadow_thing_name),
               qos=mqtt.QoS.AT_LEAST_ONCE,
               callback=on_get_shadow_accepted)
   
           get_rejected_subscribed_future, _ = shadow_client.subscribe_to_get_shadow_rejected(
               request=iotshadow.GetShadowSubscriptionRequest(thing_name=shadow_thing_name),
               qos=mqtt.QoS.AT_LEAST_ONCE,
               callback=on_get_shadow_rejected)
   
           # Wait for subscriptions to succeed
           get_accepted_subscribed_future.result()
           get_rejected_subscribed_future.result()
   
           print("Subscribing to Delta events...")
           delta_subscribed_future, _ = shadow_client.subscribe_to_shadow_delta_updated_events(
               request=iotshadow.ShadowDeltaUpdatedSubscriptionRequest(thing_name=shadow_thing_name),
               qos=mqtt.QoS.AT_LEAST_ONCE,
               callback=on_shadow_delta_updated)
   
           # Wait for subscription to succeed
           delta_subscribed_future.result()
   
           # The rest of the sample runs asynchronously.
   
           # Issue request for shadow's current state.
           # The response will be received by the on_get_accepted() callback
           print("Requesting current shadow state...")
   
           with locked_data.lock:
               # use a unique token so we can correlate this "request" message to
               # any "response" messages received on the /accepted and /rejected topics
               token = str(uuid4())
   
               publish_get_future = shadow_client.publish_get_shadow(
                   request=iotshadow.GetShadowRequest(thing_name=shadow_thing_name, client_token=token),
                   qos=mqtt.QoS.AT_LEAST_ONCE)
   
               locked_data.request_tokens.add(token)
   
           # Ensure that publish succeeds
           publish_get_future.result()
   
       except Exception as e:
           exit(e)
   
       # Wait for the sample to finish (user types 'quit', or an error occurs)
       is_sample_done.wait()
   

   Aplikasi Python ini melakukan hal berikut:

   • Menggunakan penemuan Greengrass untuk menemukan dan terhubung ke perangkat inti.

   • Meminta dokumen bayangan dari perangkat inti untuk mendapatkan status awal properti.

   • Berlangganan peristiwa delta bayangan, yang dikirim perangkat inti ketika desired nilai properti berbeda dari nilainyareported. Ketika aplikasi menerima peristiwa delta bayangan, itu mengubah nilai properti dan mengirimkan pembaruan ke perangkat inti untuk menetapkan nilai baru sebagai reported nilainya.

   Aplikasi ini menggabungkan penemuan Greengrass dan sampel bayangan dari v2. AWS IoT Device SDK

3. Jalankan aplikasi sampel. Aplikasi ini mengharapkan argumen yang menentukan nama benda perangkat klien, properti bayangan yang akan digunakan, dan sertifikat yang mengautentikasi dan mengamankan koneksi.

   • Ganti MyClientDevice1 dengan nama benda perangkat klien.

   • Ganti ~/certs/ AmazonRoot ca1.pem dengan jalur ke sertifikat CA root Amazon di perangkat klien.

   • Ganti ~/certs/device.pem.crt dengan jalur ke sertifikat perangkat pada perangkat klien.

   • Ganti ~/certs/private.pem.key dengan jalur menuju file kunci pribadi pada perangkat klien.

   • Ganti us-east-1 dengan Wilayah AWS di mana perangkat klien dan perangkat inti Anda beroperasi.

   python3 basic_discovery_shadow.py \
     --thing_name MyClientDevice1 \
     --shadow_property color \
     --ca_file ~/certs/AmazonRootCA1.pem \
     --cert ~/certs/device.pem.crt \
     --key ~/certs/private.pem.key \
     --region us-east-1 \
     --verbosity Warn

   Aplikasi sampel berlangganan topik bayangan dan menunggu untuk menerima peristiwa delta bayangan dari perangkat inti. Jika output menunjukkan bahwa aplikasi menerima dan merespons peristiwa delta bayangan, perangkat klien dapat berhasil berinteraksi dengan bayangannya pada perangkat inti.

   Performing greengrass discovery...
   awsiot.greengrass_discovery.DiscoverResponse(gg_groups=[awsiot.greengrass_discovery.GGGroup(gg_group_id='greengrassV2-coreDevice-MyGreengrassCore', cores=[awsiot.greengrass_discovery.GGCore(thing_arn='arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore', connectivity=[awsiot.greengrass_discovery.ConnectivityInfo(id='203.0.113.0', host_address='203.0.113.0', metadata='', port=8883)])], certificate_authorities=['-----BEGIN CERTIFICATE-----\nMIICiT...EXAMPLE=\n-----END CERTIFICATE-----\n'])])
   Trying core arn:aws:iot:us-east-1:123456789012:thing/MyGreengrassCore at host 203.0.113.0 port 8883
   Connected!
   Subscribing to Update responses...
   Subscribing to Get responses...
   Subscribing to Delta events...
   Requesting current shadow state...
   Received shadow delta event.
     Delta reports that desired value is 'purple'. Changing local value...
     ClientToken is: 3dce4d3f-e336-41ac-aa4f-7882725f0033
   Changed local shadow value to 'purple'.
   Updating reported shadow value to 'purple'...
   Update request published.

   Jika aplikasi mengeluarkan kesalahan, lihat Pemecahan masalah penemuan Greengrass.

   Anda juga dapat melihat log Greengrass pada perangkat inti untuk memverifikasi apakah perangkat klien berhasil menghubungkan dan mengirim pesan. Untuk informasi selengkapnya, lihat Memantau AWS IoT Greengrass log.

Lihat log komponen lagi untuk memverifikasi bahwa komponen menerima konfirmasi pembaruan bayangan dari perangkat klien cahaya pintar.

Komponen mencatat pesan untuk mengonfirmasi bahwa perangkat klien cahaya pintar berubah warnanya.

2022-07-07T03:49:24.908Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Chose random color (blue) for MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}
2022-07-07T03:49:24.912Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Requested color change for MyClientDevice1 to blue. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}
2022-07-07T03:49:24.959Z [INFO] (Copier) com.example.clientdevices.MySmartLightManager: stdout. Received shadow update confirmation from client device: MyClientDevice1. {scriptName=services.com.example.clientdevices.MySmartLightManager.lifecycle.Run, serviceName=com.example.clientdevices.MySmartLightManager, currentState=RUNNING}