Tutorial: Interaja com dispositivos locais de IoT por meio do MQTT

No menu de navegação AWS IoT Greengrassdo console, escolha Dispositivos principais.

Na página Dispositivos principais, escolha o dispositivo principal a ser atualizado.

Na página de detalhes do dispositivo principal, escolha o link para o item do dispositivo principal. Esse link abre a página de detalhes do item no AWS IoT console.

Na página de detalhes do item, escolha Certificados.

Na guia Certificados, escolha o certificado ativo do item.

Na página de detalhes do certificado, escolha Políticas.

Na guia Políticas, escolha a AWS IoT política a ser revisada e atualizada. Você pode adicionar as permissões necessárias a qualquer política anexada ao certificado ativo do dispositivo principal.

Na visão geral da política, escolha Editar versão ativa.

Revise a política para obter as permissões necessárias e adicione as permissões necessárias que estejam faltando.

Para definir uma nova versão da política como a versão ativa, em Status da versão da política, selecione Definir a versão editada como a versão ativa desta política.

Selecione Salvar como nova versão.

Navegue até o console do AWS IoT Greengrass.

No menu de navegação à esquerda, escolha Dispositivos principais.

Na página Dispositivos principais, escolha o dispositivo principal em que você deseja ativar o suporte ao dispositivo cliente.

Na página de detalhes do dispositivo principal, escolha a guia Dispositivos clientes.

Na guia Dispositivos do cliente, escolha Configurar descoberta na nuvem.

A página Configurar descoberta do dispositivo principal é aberta. Nesta página, você pode associar dispositivos cliente a um dispositivo principal e implantar componentes do dispositivo cliente. Esta página seleciona o dispositivo principal para você na Etapa 1: Selecione os dispositivos principais de destino.

Na Etapa 2: Associar dispositivos cliente, associe a AWS IoT coisa do dispositivo cliente ao dispositivo principal. Isso permite que o dispositivo cliente use a descoberta na nuvem para recuperar as informações e os certificados de conectividade do dispositivo principal. Faça o seguinte:

1. Escolha Associar dispositivos cliente.

2. No modal Associar dispositivos cliente ao dispositivo principal, insira o nome da AWS IoT coisa a ser associada.

3. Escolha Adicionar.

4. Selecione Associar.

Na Etapa 3: Configurar e implantar componentes do Greengrass, implante componentes para habilitar o suporte ao dispositivo cliente. Se o dispositivo principal de destino tiver uma implantação anterior, esta página revisará essa implantação. Caso contrário, essa página criará uma nova implantação para o dispositivo principal. Faça o seguinte para configurar e implantar os componentes do dispositivo cliente:

1. O dispositivo principal deve executar o Greengrass nucleus v2.6.0 ou posterior para concluir este tutorial. Se o dispositivo principal executar uma versão anterior, faça o seguinte:

   1. Selecione a caixa para implantar o aws.greengrass.Nucleuscomponente.

   2. Para o aws.greengrass.Nucleuscomponente, escolha Editar configuração.

   3. Para a versão do componente, escolha a versão 2.6.0 ou posterior.

   4. Selecione a opção Confirmar.

   nota

   Se você atualizar o núcleo do Greengrass de uma versão secundária anterior e o dispositivo principal executar componentes AWS fornecidos que dependem do núcleo, você também deverá atualizar os AWS componentes fornecidos para versões mais recentes. Você pode configurar a versão desses componentes ao analisar a implantação posteriormente neste tutorial. Para ter mais informações, consulte Atualize o software AWS IoT Greengrass principal (OTA).

2. Para o aws.greengrass.clientdevices.Authcomponente, escolha Editar configuração.

3. No modal Editar configuração para o componente de autenticação do dispositivo cliente, configure uma política de autorização que permita que os dispositivos cliente publiquem e assinem o agente MQTT no dispositivo principal. Faça o seguinte:

   1. Em Configuração, no bloco de código Configuração para mesclar, insira a configuração a seguir, que contém uma política de autorização de dispositivo cliente. Cada política de autorização de grupo de dispositivos especifica um conjunto de ações e os recursos nos quais um dispositivo cliente pode realizar essas ações.

      • Essa política permite que dispositivos clientes cujos nomes comecem com se conectem e MyClientDevice se comuniquem em todos os tópicos do MQTT. Substitua MyClientDevice* pelo nome da AWS IoT coisa a ser conectada como dispositivo cliente. Você também pode especificar um nome com o * caractere curinga que corresponda ao nome do dispositivo cliente. O * caractere curinga deve estar no final do nome.

        Se você tiver um segundo dispositivo cliente para se conectar, substitua MyOtherClientDevice* pelo nome desse dispositivo cliente ou por um padrão curinga que corresponda ao nome desse dispositivo cliente. Caso contrário, você pode remover ou manter essa seção da regra de seleção que permite que dispositivos clientes com nomes correspondentes MyOtherClientDevice* se conectem e se comuniquem.

      • Essa política usa um OR operador para também permitir que dispositivos clientes cujos nomes comecem com MyOtherClientDevice se conectem e se comuniquem em todos os tópicos do MQTT. Você pode remover essa cláusula na regra de seleção ou modificá-la para corresponder aos dispositivos cliente a serem conectados.

      • Essa política permite que os dispositivos do cliente publiquem e se inscrevam em todos os tópicos do MQTT. Para seguir as melhores práticas de segurança, restrinja as mqtt:subscribe operações mqtt:publish e ao conjunto mínimo de tópicos que os dispositivos cliente usam para se comunicar.

      {
        "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": [
                  "*"
                ]
              }
            }
          }
        }
      }

      Para obter mais informações, consulte Configuração do componente de autenticação do dispositivo cliente.

   2. Selecione a opção Confirmar.

4. Para o aws.greengrass.clientdevices.mqtt.Bridgecomponente, escolha Editar configuração.

5. No modal Editar configuração para o componente de ponte MQTT, configure um mapeamento de tópicos que retransmita mensagens MQTT dos dispositivos do cliente para o. AWS IoT Core Faça o seguinte:

   1. Em Configuração, no bloco Configuração para mesclar código, insira a configuração a seguir. Essa configuração especifica a retransmissão de mensagens MQTT no filtro de clients/+/hello/world tópicos dos dispositivos do cliente para o AWS IoT Core serviço de nuvem. Por exemplo, esse filtro de tópico corresponde ao clients/MyClientDevice1/hello/world tópico.

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

      Para obter mais informações, consulte Configuração do componente de ponte MQTT.

   2. Selecione a opção Confirmar.

Escolha Revisar e implantar para revisar a implantação que esta página cria para você.

Se você ainda não configurou a função de serviço do Greengrass nessa região, o console abre um modal para configurar a função de serviço para você. O componente de autenticação do dispositivo cliente usa essa função de serviço para verificar a identidade dos dispositivos cliente, e o componente detector de IP usa essa função de serviço para gerenciar as principais informações de conectividade do dispositivo. Escolha Grant permissions (Conceder permissões).

Na página Revisar, escolha Implantar para iniciar a implantação no dispositivo principal.

Para verificar se a implantação foi bem-sucedida, verifique o status da implantação e verifique os registros no dispositivo principal. Para verificar o status da implantação no dispositivo principal, você pode escolher Target na Visão geral da implantação. Para ver mais informações, consulte:

Baixe e instale a AWS IoT Device SDKv2 para Python AWS IoT na coisa para se conectar como um dispositivo cliente.

No dispositivo cliente, faça o seguinte:

1. Clone o repositório AWS IoT Device SDK v2 for Python para baixá-lo.

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

2. Instale a AWS IoT Device SDK v2 para Python.

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

Mude para a pasta de amostras na AWS IoT Device SDK v2 para Python.

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

Execute o aplicativo de descoberta Greengrass de amostra. Esse aplicativo espera argumentos que especifiquem o nome do dispositivo cliente, o tópico e a mensagem do MQTT a serem usados e os certificados que autenticam e protegem a conexão. O exemplo a seguir envia uma mensagem Hello World para o clients/MyClientDevice1/hello/world tópico.

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

O aplicativo de amostra de descoberta envia a mensagem 10 vezes e se desconecta. Ele também se inscreve no mesmo tópico em que publica mensagens. Se a saída indicar que o aplicativo recebeu mensagens MQTT sobre o tópico, o dispositivo cliente poderá se comunicar com êxito com o dispositivo principal.

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}'

Se, em vez disso, o aplicativo gerar um erro, consulte Solução de problemas de descoberta do Greengrass.

Você também pode ver os registros do Greengrass no dispositivo principal para verificar se o dispositivo cliente se conecta e envia mensagens com sucesso. Para ter mais informações, consulte Monitore AWS IoT Greengrass os registros.

Verifique se a ponte MQTT retransmite as mensagens do dispositivo cliente para o. AWS IoT Core Você pode usar o cliente de teste MQTT no AWS IoT Core console para assinar um filtro de tópicos do MQTT. Faça o seguinte:

1. Navegue até o console do AWS IoT.

2. No menu de navegação à esquerda, em Teste, escolha Cliente de teste MQTT.

3. Na guia Inscrever-se em um tópico, em Filtro de tópicos, insira clients/+/hello/world para assinar as mensagens do dispositivo cliente do dispositivo principal.

4. Escolha Assinar.

5. Execute novamente o aplicativo de publicação/assinatura no dispositivo cliente.

   O cliente de teste MQTT exibe as mensagens que você envia do dispositivo cliente em tópicos que correspondem a esse filtro de tópicos.

Revise a implantação no dispositivo principal e configure o componente de ponte MQTT para retransmitir mensagens dos dispositivos do cliente para a publicação/assinatura local. Faça o seguinte:

1. Navegue até o console do AWS IoT Greengrass.

2. No menu de navegação à esquerda, escolha Dispositivos principais.

3. Na página Dispositivos principais, escolha o dispositivo principal que você está usando para este tutorial.

4. Na página de detalhes do dispositivo principal, escolha a guia Dispositivos clientes.

5. Na guia Dispositivos do cliente, escolha Configurar descoberta na nuvem.

   A página Configurar descoberta do dispositivo principal é aberta. Nesta página, você pode alterar ou configurar quais componentes do dispositivo cliente são implantados no dispositivo principal.

6. Na Etapa 3, para o aws.greengrass.clientdevices.mqtt.Bridgecomponente, escolha Editar configuração.

7. No modal Editar configuração para o componente de ponte MQTT, configure um mapeamento de tópicos que retransmita mensagens MQTT dos dispositivos do cliente para a interface local de publicação/assinatura. Faça o seguinte:

   1. Em Configuração, no bloco Configuração para mesclar código, insira a configuração a seguir. Essa configuração especifica a retransmissão de mensagens MQTT em tópicos que correspondam ao filtro de tópicos dos clients/+/hello/world dispositivos do cliente para o serviço de AWS IoT Core nuvem e para o agente local de publicação/assinatura do Greengrass.

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

      Para obter mais informações, consulte Configuração do componente de ponte MQTT.

   2. Selecione a opção Confirmar.

8. Escolha Revisar e implantar para revisar a implantação que esta página cria para você.

9. Na página Revisar, escolha Implantar para iniciar a implantação no dispositivo principal.

10. Para verificar se a implantação foi bem-sucedida, verifique o status da implantação e verifique os registros no dispositivo principal. Para verificar o status da implantação no dispositivo principal, você pode escolher Target na Visão geral da implantação. Para ver mais informações, consulte:

    • Verificar status da implantação

    • Monitore AWS IoT Greengrass os registros

Desenvolva e implante um componente do Greengrass que assine mensagens do Hello World a partir de dispositivos clientes. Faça o seguinte:

1. Crie pastas para receitas e artefatos no dispositivo principal.

   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

   Importante

   Você deve usar o seguinte formato para o caminho da pasta de artefatos. Inclua o nome e a versão do componente que você especificar na receita.

   artifacts/componentName/componentVersion/

2. Use um editor de texto para criar uma receita de componente com o conteúdo a seguir. Esta receita especifica a instalação da AWS IoT Device SDK v2 para Python e a execução de um script que assina o tópico e imprime mensagens.

   Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.

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

   Copie a seguinte receita para o arquivo.

   {
     "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. Use um editor de texto para criar um artefato de script Python chamado hello_world_subscriber.py com o conteúdo a seguir. Esse aplicativo usa o serviço IPC de publicação/assinatura para assinar o clients/+/hello/world tópico e imprimir as mensagens recebidas.

   Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.

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

   Copie o código Python a seguir no arquivo.

   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)
   

   nota

   Esse componente usa o cliente IPC V2 na v2 AWS IoT Device SDKpara Python para se comunicar com o software Core. AWS IoT Greengrass Em comparação com o cliente IPC original, o cliente IPC V2 reduz a quantidade de código que você precisa escrever para usar o IPC em componentes personalizados.

4. Use a CLI do Greengrass para implantar o componente.

   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"

Visualize os registros do componente para verificar se o componente foi instalado com êxito e se inscreveu no tópico.

Você pode manter o feed de registro aberto para verificar se o dispositivo principal recebe mensagens.

No dispositivo cliente, execute novamente o aplicativo de descoberta Greengrass de amostra para enviar mensagens ao dispositivo principal.

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

Visualize os registros do componente novamente para verificar se o componente recebe e imprime as mensagens do dispositivo cliente.

Revise a implantação no dispositivo principal para implantar o componente shadow manager e configure o componente bridge MQTT para retransmitir mensagens paralelas entre os dispositivos do cliente e a publicação/assinatura local, onde o shadow manager se comunica. Faça o seguinte:

1. Navegue até o console do AWS IoT Greengrass.

2. No menu de navegação à esquerda, escolha Dispositivos principais.

3. Na página Dispositivos principais, escolha o dispositivo principal que você está usando para este tutorial.

4. Na página de detalhes do dispositivo principal, escolha a guia Dispositivos clientes.

5. Na guia Dispositivos do cliente, escolha Configurar descoberta na nuvem.

   A página Configurar descoberta do dispositivo principal é aberta. Nesta página, você pode alterar ou configurar quais componentes do dispositivo cliente são implantados no dispositivo principal.

6. Na Etapa 3, para o aws.greengrass.clientdevices.mqtt.Bridgecomponente, escolha Editar configuração.

7. No modal Editar configuração para o componente de ponte MQTT, configure um mapeamento de tópicos que retransmita mensagens MQTT em tópicos de sombra do dispositivo entre dispositivos cliente e a interface local de publicação/assinatura. Você também confirma que a implantação especifica uma versão compatível do MQTT bridge. O suporte à sombra do dispositivo cliente requer o MQTT bridge v2.2.0 ou posterior. Faça o seguinte:

   1. Para a versão do componente, escolha a versão 2.2.0 ou posterior.

   2. Em Configuração, no bloco Configuração para mesclar código, insira a configuração a seguir. Essa configuração especifica a retransmissão de mensagens MQTT em tópicos paralelos.

      {
        "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"
          }
        }
      }

      Para obter mais informações, consulte Configuração do componente de ponte MQTT.

   3. Selecione a opção Confirmar.

8. Na Etapa 3, selecione o aws.greengrass.ShadowManagercomponente para implantá-lo.

9. Escolha Revisar e implantar para revisar a implantação que esta página cria para você.

10. Na página Revisar, escolha Implantar para iniciar a implantação no dispositivo principal.

11. Para verificar se a implantação foi bem-sucedida, verifique o status da implantação e verifique os registros no dispositivo principal. Para verificar o status da implantação no dispositivo principal, você pode escolher Target na Visão geral da implantação. Para ver mais informações, consulte:

    • Verificar status da implantação

    • Monitore AWS IoT Greengrass os registros

Desenvolva e implante um componente do Greengrass que gerencia dispositivos cliente de iluminação inteligente. Faça o seguinte:

1. Crie uma pasta com os artefatos do componente no dispositivo principal.

   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

   Importante

   Você deve usar o seguinte formato para o caminho da pasta de artefatos. Inclua o nome e a versão do componente que você especificar na receita.

   artifacts/componentName/componentVersion/

2. Use um editor de texto para criar uma receita de componente com o conteúdo a seguir. Esta receita especifica a instalação da AWS IoT Device SDK v2 para Python e a execução de um script que interage com as sombras dos dispositivos cliente de luz inteligente para gerenciar suas cores.

   Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.

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

   Copie a seguinte receita para o arquivo.

   {
     "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. Use um editor de texto para criar um artefato de script Python chamado smart_light_manager.py com o conteúdo a seguir. Esse aplicativo usa o serviço IPC paralelo para obter e atualizar as sombras do dispositivo cliente e o serviço IPC local de publicação/assinatura para receber atualizações paralelas relatadas.

   Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.

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

   Copie o código Python a seguir no arquivo.

   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()
   

   Esse aplicativo Python faz o seguinte:

   • Lê a configuração do componente para obter a lista de dispositivos smart light client para gerenciar.

   • Assina as notificações de atualização de configuração usando a operação SubscribeToConfigurationUpdate IPC. O software AWS IoT Greengrass Core envia notificações sempre que a configuração do componente é alterada. Quando o componente recebe uma notificação de atualização de configuração, ele atualiza a lista de dispositivos cliente smart light que ele gerencia.

   • Obtém a sombra de cada dispositivo cliente de luz inteligente para obter seu estado inicial de cor.

   • Define a cor de cada dispositivo cliente de luz inteligente para uma cor aleatória a cada 15 segundos. O componente atualiza a sombra da coisa do dispositivo cliente para mudar sua cor. Essa operação envia um evento delta de sombra para o dispositivo cliente pelo MQTT.

   • Assina as mensagens aceitas de atualização paralela na interface local de publicação/assinatura usando a SubscribeToTopic operação IPC. Esse componente recebe essas mensagens para rastrear a cor de cada dispositivo cliente de luz inteligente. Quando um dispositivo cliente smart light recebe uma atualização paralela, ele envia uma mensagem MQTT para confirmar que recebeu a atualização. A ponte MQTT retransmite essa mensagem para a interface local de publicação/assinatura.

4. Use a CLI do Greengrass para implantar o componente. Ao implantar esse componente, você especifica a lista de dispositivos clientesmartLightDeviceNames, cujas sombras ele gerencia. Substitua MyClientDevice1 pelo nome do item do dispositivo cliente.

   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"
           ]
         }
       }
     }'

Visualize os registros do componente para verificar se o componente foi instalado e executado com êxito.

O componente envia solicitações para alterar a cor do dispositivo cliente de luz inteligente. O gerenciador de sombra recebe a solicitação e define o desired estado da sombra. No entanto, o dispositivo cliente de luz inteligente ainda não está funcionando, então o reported estado da sombra não muda. Os registros do componente incluem as seguintes mensagens.

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}

Você pode manter o feed de registro aberto para ver quando o componente imprime mensagens.

Baixe e execute um aplicativo de amostra que usa o Greengrass Discovery e assina as atualizações do Device Shadow. No dispositivo cliente, faça o seguinte:

1. Mude para a pasta de amostras na AWS IoT Device SDK v2 para Python. Esse aplicativo de amostra usa um módulo de análise de linha de comando na pasta de amostras.

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

2. Use um editor de texto para criar um script Python chamado basic_discovery_shadow.py com o conteúdo a seguir. Esse aplicativo usa a descoberta e as sombras do Greengrass para manter uma propriedade sincronizada entre o dispositivo cliente e o dispositivo principal.

   Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.

   nano basic_discovery_shadow.py

   Copie o código Python a seguir no arquivo.

   # 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()
   

   Esse aplicativo Python faz o seguinte:

   • Usa o Greengrass Discovery para descobrir e se conectar ao dispositivo principal.

   • Solicita o documento paralelo do dispositivo principal para obter o estado inicial da propriedade.

   • Assina eventos delta de sombra, que o dispositivo principal envia quando o desired valor da propriedade é diferente de seu reported valor. Quando o aplicativo recebe um evento delta paralelo, ele altera o valor da propriedade e envia uma atualização para o dispositivo principal para definir o novo valor como seu reported valor.

   Este aplicativo combina as amostras de descoberta e sombra do Greengrass da AWS IoT Device SDK v2.

3. Execute o aplicativo de amostra. Esse aplicativo espera argumentos que especifiquem o nome do dispositivo cliente, a propriedade shadow a ser usada e os certificados que autenticam e protegem a conexão.

   • Substitua MyClientDevice1 pelo nome do item do dispositivo cliente.

   • Substitua ~/certs/ AmazonRoot CA1.pem pelo caminho para o certificado CA raiz da Amazon no dispositivo cliente.

   • Substitua ~/certs/device.pem.crt pelo caminho para o certificado do dispositivo no dispositivo cliente.

   • Substitua ~/certs/private.pem.key pelo caminho para o arquivo de chave privada no dispositivo cliente.

   • Substitua us-east-1 pela AWS região em que seu dispositivo cliente e dispositivo principal operam.

   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

   O aplicativo de amostra se inscreve nos tópicos paralelos e espera receber eventos delta de sombra do dispositivo principal. Se a saída indicar que o aplicativo recebe e responde aos eventos delta de sombra, o dispositivo cliente pode interagir com sucesso com sua sombra no dispositivo principal.

   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.

   Se, em vez disso, o aplicativo gerar um erro, consulte Solução de problemas de descoberta do Greengrass.

   Você também pode ver os registros do Greengrass no dispositivo principal para verificar se o dispositivo cliente se conecta e envia mensagens com sucesso. Para ter mais informações, consulte Monitore AWS IoT Greengrass os registros.

Visualize os registros do componente novamente para verificar se o componente recebe confirmações de atualização de sombra do dispositivo cliente smart light.

O componente registra mensagens para confirmar que o dispositivo cliente Smart Light mudou de cor.

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}