Tutorial: Interactúa con dispositivos IoT locales a través de MQTT

En el menú de navegación de la AWS IoT Greengrassconsola, selecciona Dispositivos principales.

En la página de dispositivos principales, selecciona el dispositivo principal que deseas actualizar.

En la página de detalles del dispositivo principal, selecciona el enlace al dispositivo principal. Este enlace abre la página de detalles del dispositivo en la AWS IoT consola.

En la página de detalles de la cosa, selecciona Certificados.

En la pestaña Certificados, selecciona el certificado activo del objeto.

En la página de detalles del certificado, selecciona Políticas.

En la pestaña Políticas, elija la AWS IoT política que desee revisar y actualizar. Puede añadir los permisos necesarios a cualquier política que esté asociada al certificado activo del dispositivo principal.

En la descripción general de la política, selecciona Editar la versión activa.

Revisa la política para ver los permisos necesarios y añade los permisos necesarios que falten.

Para establecer una nueva versión de la política como la versión activa, en Estado de la versión de la política, seleccione Establecer la versión editada como la versión activa de esta política.

Seleccione Guardar como versión nueva.

Vaya a la consola de AWS IoT Greengrass.

En el menú de navegación de la izquierda, selecciona Dispositivos principales.

En la página Dispositivos principales, selecciona el dispositivo principal en el que deseas habilitar la compatibilidad con los dispositivos cliente.

En la página de detalles del dispositivo principal, selecciona la pestaña Dispositivos cliente.

En la pestaña Dispositivos cliente, elija Configurar la detección en la nube.

Se abre la página Configurar la detección de dispositivos principales. En esta página, puede asociar los dispositivos cliente a un dispositivo principal e implementar los componentes del dispositivo cliente. En esta página, se selecciona el dispositivo principal en el paso 1: Seleccione los dispositivos principales de destino.

En el paso 2: Asociar los dispositivos cliente, asocie el AWS IoT dispositivo cliente al dispositivo principal. Esto permite que el dispositivo cliente utilice la detección en la nube para recuperar la información de conectividad y los certificados del dispositivo principal. Haga lo siguiente:

1. Elija Asociar dispositivos cliente.

2. En el modal Asociar dispositivos cliente al dispositivo principal, introduzca el nombre del elemento AWS IoT que desee asociar.

3. Elija Add (Añadir).

4. Elija Associate (Asociar).

En el paso 3: configurar e implementar los componentes de Greengrass, despliegue componentes para habilitar la compatibilidad con los dispositivos cliente. Si el dispositivo principal de destino tiene una implementación anterior, esta página revisa esa implementación. De lo contrario, esta página crea una nueva implementación para el dispositivo principal. Haga lo siguiente para configurar e implementar los componentes del dispositivo cliente:

1. El dispositivo principal debe ejecutar Greengrass nucleus v2.6.0 o posterior para completar este tutorial. Si el dispositivo principal ejecuta una versión anterior, haga lo siguiente:

   1. Seleccione la casilla para implementar el aws.greengrass.Nucleuscomponente.

   2. Para el aws.greengrass.Nucleuscomponente, elija Editar configuración.

   3. Para la versión del componente, elija la versión 2.6.0 o posterior.

   4. Seleccione Confirmar.

   nota

   Si actualiza el núcleo de Greengrass desde una versión secundaria anterior y el dispositivo principal ejecuta componentes AWS proporcionados que dependen del núcleo, también debe actualizar los componentes AWS proporcionados a versiones más recientes. Puede configurar la versión de estos componentes al revisar la implementación más adelante en este tutorial. Para obtener más información, consulte Actualice el software AWS IoT Greengrass principal (OTA).

2. Para el aws.greengrass.clientdevices.Authcomponente, elija Editar configuración.

3. En el modal de edición de configuración del componente de autenticación del dispositivo cliente, configure una política de autorización que permita a los dispositivos cliente publicar y suscribirse al agente MQTT en el dispositivo principal. Haga lo siguiente:

   1. En Configuración, en el bloque Configuración para fusionar códigos, introduzca la siguiente configuración, que contiene una política de autorización de dispositivos cliente. Cada política de autorización de grupos de dispositivos especifica un conjunto de acciones y los recursos en los que un dispositivo cliente puede realizar esas acciones.

      • Esta política permite que los dispositivos cliente cuyos nombres comiencen por se conecten y se comuniquen sobre todos los temas de MQTT. MyClientDevice Sustituya MyClientDevice* por el nombre del dispositivo AWS IoT que se va a conectar como dispositivo cliente. También puede especificar un nombre con un * comodín que coincida con el nombre del dispositivo cliente. El * comodín debe estar al final del nombre.

        Si tiene que conectar un segundo dispositivo cliente, sustituya MyOtherClientDevice* por el nombre de ese dispositivo cliente o por un patrón comodín que coincida con el nombre de ese dispositivo cliente. De lo contrario, puede eliminar o conservar esta sección de la regla de selección que permite que los dispositivos cliente con nombres que coincidan MyOtherClientDevice* se conecten y se comuniquen.

      • Esta política utiliza un OR operador para permitir también que los dispositivos cliente cuyos nombres comiencen por «se conecten y se comuniquen en todos los temas de MQTT». MyOtherClientDevice Puede eliminar esta cláusula de la regla de selección o modificarla para que coincida con los dispositivos cliente a los que se va a conectar.

      • Esta política permite a los dispositivos cliente publicar y suscribirse a todos los temas de MQTT. Para seguir las mejores prácticas de seguridad, mqtt:publish limite las mqtt:subscribe operaciones al conjunto mínimo de temas que utilizan los dispositivos cliente para comunicarse.

      {
        "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 obtener más información, consulte Configuración del componente de autenticación del dispositivo cliente.

   2. Seleccione Confirmar.

4. Para el aws.greengrass.clientdevices.mqtt.Bridgecomponente, elija Editar configuración.

5. En el modal Editar configuración del componente MQTT bridge, configure un mapeo de temas que transmita los mensajes MQTT de los dispositivos cliente a. AWS IoT Core Haga lo siguiente:

   1. En Configuración, en el bloque Configuración para fusionar códigos, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de los mensajes MQTT del filtro de clients/+/hello/world temas desde los dispositivos cliente al servicio AWS IoT Core en la nube. Por ejemplo, este filtro de temas coincide con el clients/MyClientDevice1/hello/world tema.

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

      Para obtener más información, consulte Configuración de los componentes del puente MQTT.

   2. Seleccione Confirmar.

Seleccione Revisar e implementar para revisar la implementación que esta página crea para usted.

Si no ha configurado previamente el rol de servicio de Greengrass en esta región, la consola abre un modal para configurar el rol de servicio por usted. El componente de autenticación del dispositivo cliente usa esta función de servicio para verificar la identidad de los dispositivos cliente, y el componente detector de IP usa esta función de servicio para administrar la información de conectividad principal de los dispositivos. Elija Grant permissions (Conceder permisos).

En la página de revisión, elija Implementar para iniciar la implementación en el dispositivo principal.

Para comprobar que la implementación se ha realizado correctamente, compruebe el estado de la implementación y compruebe los registros del dispositivo principal. Para comprobar el estado de la implementación en el dispositivo principal, puede elegir Target en la descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

Descargue e instale la SDK para dispositivos con AWS IoTversión 2 para Python en el AWS IoT dispositivo para conectarlo como dispositivo cliente.

En el dispositivo cliente, haga lo siguiente:

1. Clona el repositorio SDK para dispositivos con AWS IoT v2 para Python para descargarlo.

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

2. Instale la SDK para dispositivos con AWS IoT versión 2 para Python.

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

Cambie a la carpeta de muestras de la SDK para dispositivos con AWS IoT versión 2 para Python.

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

Ejecute la aplicación Greengrass Discovery de muestra. Esta aplicación espera argumentos que especifiquen el nombre del dispositivo cliente, el tema y el mensaje de MQTT que se van a utilizar y los certificados que autentican y protegen la conexión. En el siguiente ejemplo, se envía un mensaje de Hello World al clients/MyClientDevice1/hello/world tema.

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

La aplicación de ejemplo Discovery envía el mensaje 10 veces y se desconecta. También se suscribe al mismo tema en el que publica los mensajes. Si el resultado indica que la aplicación recibió mensajes MQTT sobre el tema, el dispositivo cliente puede comunicarse correctamente con el 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}'

Si, en cambio, la aplicación genera un error, consulte Solución de problemas de detección de Greengrass.

También puede ver los registros de Greengrass en el dispositivo principal para comprobar si el dispositivo cliente se conecta y envía mensajes correctamente. Para obtener más información, consulte Supervisar AWS IoT Greengrass registros.

Compruebe que el puente MQTT retransmita los mensajes del dispositivo cliente a. AWS IoT Core Puede utilizar el cliente de pruebas de MQTT de la AWS IoT Core consola para suscribirse a un filtro de temas de MQTT. Haga lo siguiente:

1. Vaya a la consola de AWS IoT.

2. En el menú de navegación de la izquierda, en Probar, elija el cliente de prueba MQTT.

3. En la pestaña Suscribirse a un tema, en Filtro por tema, escriba para suscribirse clients/+/hello/world a los mensajes del dispositivo cliente desde el dispositivo principal.

4. Elija Suscribirse.

5. Vuelva a ejecutar la aplicación de publicación/suscripción en el dispositivo cliente.

   El cliente de prueba de MQTT muestra los mensajes que se envían desde el dispositivo cliente sobre temas que coinciden con este filtro de temas.

Revise la implementación en el dispositivo principal y configure el componente de puente MQTT para retransmitir los mensajes desde los dispositivos cliente a la publicación o suscripción local. Haga lo siguiente:

1. Vaya a la consola de AWS IoT Greengrass.

2. En el menú de navegación de la izquierda, elija Dispositivos principales.

3. En la página Dispositivos principales, elige el dispositivo principal que vas a utilizar para este tutorial.

4. En la página de detalles del dispositivo principal, selecciona la pestaña Dispositivos cliente.

5. En la pestaña Dispositivos cliente, elija Configurar la detección en la nube.

   Se abre la página Configurar la detección de dispositivos principales. En esta página, puede cambiar o configurar qué componentes del dispositivo cliente se implementan en el dispositivo principal.

6. En el paso 3, para el aws.greengrass.clientdevices.mqtt.Bridgecomponente, elija Editar configuración.

7. En el modal de edición de configuración del componente MQTT bridge, configure un mapeo de temas que transmita los mensajes MQTT desde los dispositivos cliente a la interfaz local de publicación/suscripción. Haga lo siguiente:

   1. En Configuración, en el bloque Configuración para fusionar códigos, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de mensajes MQTT sobre temas que coincidan con el filtro de clients/+/hello/world temas desde los dispositivos cliente al servicio AWS IoT Core en la nube y al agente local de publicación/suscripción de Greengrass.

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

      Para obtener más información, consulte Configuración de los componentes del puente MQTT.

   2. Seleccione Confirmar.

8. Seleccione Revisar e implementar para revisar la implementación que esta página crea para usted.

9. En la página de revisión, elija Implementar para iniciar la implementación en el dispositivo principal.

10. Para comprobar que la implementación se ha realizado correctamente, compruebe el estado de la implementación y compruebe los registros del dispositivo principal. Para comprobar el estado de la implementación en el dispositivo principal, puede elegir Target en la descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

    • Verificar el estado de implementación

    • Supervisar AWS IoT Greengrass registros

Desarrolle e implemente un componente de Greengrass que se suscriba a los mensajes de Hello World desde los dispositivos cliente. Haga lo siguiente:

1. Cree carpetas para recetas y artefactos en el 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

   Debe utilizar el siguiente formato para la ruta de la carpeta de artefactos. Incluya el nombre y la versión del componente que especifique en la receta.

   artifacts/componentName/componentVersion/

2. Utilice un editor de texto para crear una receta de componentes con los siguientes contenidos. Esta receta especifica instalar la SDK para dispositivos con AWS IoT versión 2 para Python y ejecutar un script que se suscriba al tema e imprima los mensajes.

   Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crear el archivo.

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

   Copie la siguiente receta en el archivo.

   {
     "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. Utilice un editor de texto para crear un artefacto de script de Python denominado hello_world_subscriber.py con el siguiente contenido. Esta aplicación utiliza el servicio IPC de publicación/suscripción para suscribirse al clients/+/hello/world tema e imprimir los mensajes que recibe.

   Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crear el archivo.

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

   Copia el siguiente código de Python en el archivo.

   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

   Este componente usa el cliente IPC V2 en la SDK para dispositivos con AWS IoTv2 para Python para comunicarse con el software AWS IoT Greengrass Core. En comparación con el cliente IPC original, el cliente IPC V2 reduce la cantidad de código que hay que escribir para usar el IPC en componentes personalizados.

4. Utilice la CLI de Greengrass para implementar el 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"

Consulte los registros de los componentes para comprobar que el componente se ha instalado correctamente y que está suscrito al tema.

Puede mantener el feed de registro abierto para comprobar que el dispositivo principal recibe los mensajes.

En el dispositivo cliente, vuelva a ejecutar la aplicación Greengrass Discovery de muestra para enviar mensajes al 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

Vuelva a ver los registros de los componentes para comprobar que el componente recibe e imprime los mensajes del dispositivo cliente.

Revise la implementación en el dispositivo principal para implementar el componente de administrador de sombras y configurar el componente de puente MQTT para retransmitir mensajes instantáneos entre los dispositivos cliente y la publicación o suscripción local, donde se comunica el administrador de sombras. Haga lo siguiente:

1. Vaya a la consola de AWS IoT Greengrass.

2. En el menú de navegación de la izquierda, selecciona Dispositivos principales.

3. En la página Dispositivos principales, elige el dispositivo principal que vas a utilizar para este tutorial.

4. En la página de detalles del dispositivo principal, selecciona la pestaña Dispositivos cliente.

5. En la pestaña Dispositivos cliente, elija Configurar la detección en la nube.

   Se abre la página Configurar la detección de dispositivos principales. En esta página, puede cambiar o configurar qué componentes del dispositivo cliente se implementan en el dispositivo principal.

6. En el paso 3, para el aws.greengrass.clientdevices.mqtt.Bridgecomponente, elija Editar configuración.

7. En el modal de edición de configuración del componente MQTT bridge, configure un mapeo de temas que retransmita los mensajes MQTT en temas ocultos de los dispositivos entre los dispositivos cliente y la interfaz local de publicación/suscripción. También debe confirmar que la implementación especifica una versión de puente MQTT compatible. La compatibilidad con la sombra de dispositivos cliente requiere MQTT bridge v2.2.0 o posterior. Haga lo siguiente:

   1. Para la versión Component, elija la versión 2.2.0 o posterior.

   2. En Configuración, en el bloque de códigos Configuración para fusionar, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de mensajes MQTT sobre temas 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 obtener más información, consulte Configuración de los componentes del puente MQTT.

   3. Seleccione Confirmar.

8. En el paso 3, seleccione el aws.greengrass.ShadowManagercomponente para desplegarlo.

9. Seleccione Revisar e implementar para revisar la implementación que esta página crea para usted.

10. En la página de revisión, elija Implementar para iniciar la implementación en el dispositivo principal.

11. Para comprobar que la implementación se ha realizado correctamente, compruebe el estado de la implementación y compruebe los registros del dispositivo principal. Para comprobar el estado de la implementación en el dispositivo principal, puede elegir Target en la descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

    • Verificar el estado de implementación

    • Supervisar AWS IoT Greengrass registros

Desarrolle e implemente un componente de Greengrass que gestione los dispositivos cliente Smart Light. Haga lo siguiente:

1. Cree una carpeta con los artefactos del componente en el 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

   Debe utilizar el siguiente formato para la ruta de la carpeta del artefacto. Incluya el nombre y la versión del componente que especifique en la receta.

   artifacts/componentName/componentVersion/

2. Utilice un editor de texto para crear una receta de componentes con los siguientes contenidos. Esta receta especifica instalar la SDK para dispositivos con AWS IoT versión 2 para Python y ejecutar un script que interactúe con las sombras de los dispositivos cliente de iluminación inteligente para gestionar sus colores.

   Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crear el archivo.

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

   Copie la siguiente receta en el archivo.

   {
     "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. Utilice un editor de texto para crear un artefacto de script de Python denominado smart_light_manager.py con el siguiente contenido. Esta aplicación utiliza el servicio IPC oculto para obtener y actualizar las sombras de los dispositivos cliente y el servicio IPC local de publicación/suscripción para recibir las actualizaciones ocultas notificadas.

   Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crear el archivo.

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

   Copia el siguiente código de Python en el archivo.

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

   Esta aplicación de Python hace lo siguiente:

   • Lee la configuración del componente para obtener la lista de dispositivos cliente de Smart Light que hay que gestionar.

   • Se suscribe a las notificaciones de actualización de la configuración mediante la operación SubscribeToConfigurationUpdate IPC. El software AWS IoT Greengrass Core envía notificaciones cada vez que cambia la configuración del componente. Cuando el componente recibe una notificación de actualización de la configuración, actualiza la lista de dispositivos cliente de iluminación inteligente que administra.

   • Obtiene la sombra de cada dispositivo cliente de iluminación inteligente para obtener su estado de color inicial.

   • Establece el color de cada dispositivo cliente de iluminación inteligente en un color aleatorio cada 15 segundos. El componente actualiza la sombra del dispositivo cliente para cambiar su color. Esta operación envía un evento shadow delta al dispositivo cliente a través de MQTT.

   • Se suscribe a la actualización paralela de los mensajes aceptados en la interfaz local de publicación/suscripción mediante la operación IPC. SubscribeToTopic Este componente recibe estos mensajes para rastrear el color de cada dispositivo cliente de Smart Light. Cuando un dispositivo cliente Smart Light recibe una actualización oculta, envía un mensaje MQTT para confirmar que ha recibido la actualización. El puente MQTT transmite este mensaje a la interfaz local de publicación/suscripción.

4. Utilice la CLI de Greengrass para implementar el componente. Al implementar este componente, se especifica la lista de dispositivos clientesmartLightDeviceNames, cuyas sombras administra. Sustituya MyClientDevice1 por el nombre del 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"
           ]
         }
       }
     }'

Consulte los registros de los componentes para comprobar que el componente se instala y ejecuta correctamente.

El componente envía solicitudes para cambiar el color del dispositivo cliente de iluminación inteligente. El administrador de sombras recibe la solicitud y establece el desired estado de la sombra. Sin embargo, el dispositivo cliente de luz inteligente aún no está funcionando, por lo que el reported estado de la sombra no cambia. Los registros del componente incluyen los siguientes mensajes.

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}

Puede mantener el feed de registro abierto para ver cuándo imprime los mensajes el componente.

Descarga y ejecuta una aplicación de muestra que usa Greengrass Discovery y se suscribe a las actualizaciones ocultas de los dispositivos. En el dispositivo cliente, haga lo siguiente:

1. Cambie a la carpeta de muestras de la SDK para dispositivos con AWS IoT versión 2 para Python. Esta aplicación de ejemplo utiliza un módulo de análisis de línea de comandos en la carpeta de ejemplos.

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

2. Utilice un editor de texto para crear un script de Python denominado basic_discovery_shadow.py con el siguiente contenido. Esta aplicación utiliza el descubrimiento y las sombras de Greengrass para mantener sincronizada una propiedad entre el dispositivo cliente y el dispositivo principal.

   Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano para crear el archivo.

   nano basic_discovery_shadow.py

   Copia el siguiente código de Python en el archivo.

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

   Esta aplicación de Python hace lo siguiente:

   • Utiliza el descubrimiento de Greengrass para descubrir el dispositivo principal y conectarse a él.

   • Solicita el documento paralelo del dispositivo principal para obtener el estado inicial de la propiedad.

   • Se suscribe a los eventos delta ocultos, que el dispositivo principal envía cuando el desired valor de la propiedad difiere de su reported valor. Cuando la aplicación recibe un evento delta oculto, cambia el valor de la propiedad y envía una actualización al dispositivo principal para establecer el nuevo valor como su reported valor.

   Esta aplicación combina el descubrimiento de Greengrass y las muestras de sombras de la SDK para dispositivos con AWS IoT v2.

3. Ejecute la aplicación de muestra. Esta aplicación espera argumentos que especifiquen el nombre del dispositivo cliente, la propiedad oculta que se va a utilizar y los certificados que autentican y protegen la conexión.

   • Sustituya MyClientDevice1 por el nombre de la cosa del dispositivo cliente.

   • Sustituya ~/certs/ AmazonRoot CA1.pem por la ruta al certificado de CA raíz de Amazon en el dispositivo cliente.

   • Sustituya ~/certs/device.pem.crt por la ruta al certificado del dispositivo cliente.

   • Sustituya ~/certs/private.pem.key por la ruta al archivo de clave privada del dispositivo cliente.

   • Sustituya us-east-1 por la región en la que funcionan el dispositivo cliente y el dispositivo principal. AWS

   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

   La aplicación de ejemplo se suscribe a los temas ocultos y espera a recibir los eventos paralelos del dispositivo principal. Si el resultado indica que la aplicación recibe eventos delta ocultos y responde a ellos, el dispositivo cliente puede interactuar correctamente con su sombra en el 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.

   Si, en cambio, la aplicación genera un error, consulte Solución de problemas de detección de Greengrass.

   También puede ver los registros de Greengrass en el dispositivo principal para comprobar si el dispositivo cliente se conecta y envía mensajes correctamente. Para obtener más información, consulte Supervisar AWS IoT Greengrass registros.

Vuelva a ver los registros de los componentes para comprobar que el componente recibe confirmaciones de actualización clandestinas del dispositivo cliente de Smart Light.

El componente registra los mensajes para confirmar que el dispositivo cliente de iluminación inteligente ha cambiado de color.

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}