Seleccione sus preferencias de cookies

Usamos cookies esenciales y herramientas similares que son necesarias para proporcionar nuestro sitio y nuestros servicios. Usamos cookies de rendimiento para recopilar estadísticas anónimas para que podamos entender cómo los clientes usan nuestro sitio y hacer mejoras. Las cookies esenciales no se pueden desactivar, pero puede hacer clic en “Personalizar” o “Rechazar” para rechazar las cookies de rendimiento.

Si está de acuerdo, AWS y los terceros aprobados también utilizarán cookies para proporcionar características útiles del sitio, recordar sus preferencias y mostrar contenido relevante, incluida publicidad relevante. Para aceptar o rechazar todas las cookies no esenciales, haga clic en “Aceptar” o “Rechazar”. Para elegir opciones más detalladas, haga clic en “Personalizar”.

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

Modo de enfoque
Tutorial: Interactúe con dispositivos IoT locales a través de MQTT - AWS IoT Greengrass

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Puede completar este tutorial para configurar un dispositivo principal para que interactúe con los dispositivos IoT locales, denominados dispositivos cliente, que se conectan al dispositivo principal a través deMQTT. En este tutorial, configurará AWS IoT las cosas para usar la detección en la nube para conectarse al dispositivo principal como dispositivos cliente. Al configurar la detección en la nube, un dispositivo cliente puede enviar una solicitud al servicio AWS IoT Greengrass en la nube para descubrir los dispositivos principales. La respuesta de AWS IoT Greengrass incluye la información de conectividad y los certificados de los dispositivos principales que usted configura para que los detecte el dispositivo de cliente. Luego, el dispositivo cliente puede usar esta información para conectarse a un dispositivo principal disponible desde el que pueda comunicarseMQTT.

En este tutorial, aprenderá a hacer lo siguiente:

  1. Revise y actualice los permisos del dispositivo principal, si es necesario.

  2. Asocié los dispositivos de cliente al dispositivo principal para que puedan detectar el dispositivo principal mediante la detección en la nube.

  3. Implemente los componentes de Greengrass en el dispositivo principal para permitir la compatibilidad con el dispositivo de cliente.

  4. Conecte los dispositivos de cliente al dispositivo principal y pruebe la comunicación con el servicio en la nube de AWS IoT Core .

  5. Desarrolle un componente de Greengrass personalizado que se comunique con los dispositivos de cliente.

  6. Desarrolle un componente personalizado que interactúe con las sombras de dispositivos de cliente de AWS IoT.

Este tutorial usa un dispositivo principal único y un dispositivo de cliente único. También puede seguir el tutorial para conectar y probar varios dispositivos de cliente.

Calcule dedicar unos 30 a 60 minutos a este tutorial.

Requisitos previos

Necesitará lo siguiente para completar este tutorial:

  • Un Cuenta de AWS. Si no dispone de una, consulte Configura un Cuenta de AWS.

  • Un AWS Identity and Access Management (IAM) usuario con permisos de administrador.

  • Un dispositivo principal de Greengrass. Para obtener más información acerca de cómo configurar un dispositivo principal, consulte Configuración de los dispositivos AWS IoT Greengrass principales.

    • El dispositivo principal debe ejecutar la versión 2.6.0 o posterior del núcleo de Greengrass. Esta versión incluye compatibilidad con comodines en la comunicación local entre publicaciones/suscripciones y compatibilidad con sombras de dispositivo de cliente.

      nota

      La compatibilidad con dispositivos de cliente requiere el núcleo de Greengrass versión 2.2.0 o posterior. Sin embargo, en este tutorial se analizan las funciones más recientes, como la compatibilidad con los MQTT caracteres comodín en las publicaciones o suscripciones locales y la compatibilidad con los dispositivos cliente ocultos. Estas características requieren el núcleo de Greengrass versión 2.6.0 o posterior.

    • El dispositivo principal debe estar en la misma red que los dispositivos de cliente para conectarse.

    • (Opcional) Para completar los módulos en los que se desarrollan componentes personalizados de Greengrass, el dispositivo principal debe ejecutar Greengrass. CLI Para obtener más información, consulte Instala el Greengrass CLI.

  • En este tutorial, AWS IoT hay algo que conectar como dispositivo cliente. Para obtener más información, consulte Crear AWS IoT recursos en la Guía para AWS IoT Core desarrolladores.

    • La AWS IoT política del dispositivo cliente debe permitir el greengrass:Discover permiso. Para obtener más información, consulte Política mínima de AWS IoT para los dispositivos de cliente.

    • El dispositivo de cliente debe estar en la misma red que el dispositivo principal.

    • El dispositivo de cliente debe ejecutar Python 3.

    • El dispositivo de cliente debe ejecutar Git.

Paso 1: Revise y actualice la AWS IoT política principal de dispositivos

Para ser compatible con los dispositivos cliente, la AWS IoT política de un dispositivo principal debe permitir los siguientes permisos:

  • greengrass:PutCertificateAuthorities

  • greengrass:VerifyClientDeviceIdentity

  • greengrass:VerifyClientDeviceIoTCertificateAssociation

  • greengrass:GetConnectivityInfo

  • greengrass:UpdateConnectivityInfo— (Opcional) Este permiso es necesario para utilizar el componente de detección de IP, que envía la información de conectividad de red del dispositivo principal al servicio AWS IoT Greengrass en la nube.

Para obtener más información sobre estos permisos y AWS IoT políticas para los dispositivos principales, consulte Políticas de AWS IoT para operaciones de plano de datos yPolítica mínima de AWS IoT para otorgar compatibilidad con los dispositivos de cliente.

En esta sección, revisas las AWS IoT políticas de tu dispositivo principal y añades los permisos necesarios que falten. Si utilizaste el instalador del software AWS IoT Greengrass principal para aprovisionar recursos, tu dispositivo principal tiene una AWS IoT política que permite el acceso a todas AWS IoT Greengrass las acciones (greengrass:*). En este caso, solo debe actualizar la AWS IoT política si planea configurar el componente de administrador de sombras con el que sincronizar las sombras de los dispositivos AWS IoT Core. De lo contrario, puede omitir esta sección.

Para revisar y actualizar la AWS IoT política de un dispositivo principal
  1. En el menú de navegación de la consola de AWS IoT Greengrass, elija Dispositivos principales.

  2. En la página Dispositivos principales, elija el dispositivo principal que desea actualizar.

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

  4. En la página de detalles del objeto, elija Certificados.

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

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

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

    nota

    Si ha utilizado el instalador de software AWS IoT Greengrass principal para aprovisionar recursos, tiene dos AWS IoT políticas. Le recomendamos que elija la política denominada GreengrassV2IoTThingPolicy, si existe. Los dispositivos principales que cree con el instalador rápido usan este nombre de política de forma predeterminada. Si agrega permisos a esta política, también los otorga a otros dispositivos principales que usan esta política.

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

  9. Revise la política para ver los permisos necesarios y agregue los permisos necesarios que falten.

  10. 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.

  11. Seleccione Guardar como versión nueva.

Paso 2: Habilitar la compatibilidad del dispositivo de cliente

Para que un dispositivo de cliente use la detección en la nube para conectarse a un dispositivo principal, debe asociar los dispositivos. Cuando asocia un dispositivo de cliente a un dispositivo principal, permite que ese dispositivo de cliente recupere las direcciones IP y los certificados del dispositivo principal para usarlos en la conexión.

Para permitir que los dispositivos cliente se conecten de forma segura a un dispositivo principal y se comuniquen con los componentes de Greengrass AWS IoT Core, debe implementar los siguientes componentes de Greengrass en el dispositivo principal:

  • Autenticación del dispositivo de cliente (aws.greengrass.clientdevices.Auth)

    Implemente el componente de autenticación del dispositivo de cliente para autenticar los dispositivos de cliente y autorizar las acciones de los dispositivos de cliente. Este componente permite que sus AWS IoT cosas se conecten a un dispositivo principal.

    Este componente requiere alguna configuración para poder usarlo. Debe especificar los grupos de dispositivos cliente y las operaciones que cada grupo está autorizado a realizar, como conectarse y comunicarse a través de ellosMQTT. Para obtener más información, consulte configuración del componente de autenticación del dispositivo de cliente.

  • Agente MQTT 3.1.1 (Moquette) (aws.greengrass.clientdevices.mqtt.Moquette)

    Implemente el componente de intermediario Moquette para gestionar un MQTT bróker ligeroMQTT. El MQTT broker Moquette cumple con la norma MQTT 3.1.1 e incluye soporte local para QoS 0, QoS 1, QoS 2, mensajes retenidos, mensajes de última voluntad y suscripciones persistentes.

    No es necesario configurar este componente para usarlo. Sin embargo, puede configurar el puerto en el que este componente opera el broker. MQTT Usa el puerto 8883 de manera predeterminada.

  • Puente MQTT (aws.greengrass.clientdevices.mqtt.Bridge)

    (Opcional) Implemente el componente MQTT puente para retransmitir mensajes entre los dispositivos cliente (localesMQTT), los de publicación/suscripción locales y. AWS IoT Core MQTT Configure este componente para sincronizar los dispositivos cliente AWS IoT Core e interactuar con los dispositivos cliente de los componentes de Greengrass.

    Para poder usar este componente, es necesario configurarlo. Debe especificar las asignaciones de temas en las que este componente retransmite los mensajes. Para obtener más información, consulte la configuración de los componentes del MQTT puente.

  • Detector de IP (aws.greengrass.clientdevices.IPDetector)

    (Opcional) Implemente el componente detector de IP para informar automáticamente al servicio en la AWS IoT Greengrass nube de los puntos finales MQTT intermediarios del dispositivo principal. No puede usar este componente si tiene una configuración de red compleja, como una en la que un router reenvía el puerto MQTT intermediario al dispositivo principal.

    No es necesario configurar este componente para usarlo.

En esta sección, utilizará la AWS IoT Greengrass consola para asociar los dispositivos cliente e implementar los componentes del dispositivo cliente en un dispositivo principal.

Habilitación de la compatibilidad con el dispositivo de cliente
  1. En el panel de navegación de la izquierda, elija Dispositivos principales.

  2. En la página de Dispositivos principales, elija el dispositivo principal en el que desee habilitar la compatibilidad con el dispositivo de cliente.

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

  4. En la pestaña Dispositivos de 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 de cliente a un dispositivo principal e implementar los componentes del dispositivo de cliente. Esta página selecciona el dispositivo principal por usted en el Paso 1: Seleccionar los dispositivos principales de destino.

    nota

    Puede usar esta página para configurar la detección del dispositivo principal para un grupo de objetos. Si elige esta opción, puede implementar los componentes del dispositivo de cliente en todos los dispositivos principales de un grupo de objetos. Sin embargo, si elige esta opción, deberá asociar manualmente los dispositivos de cliente a cada dispositivo principal más adelante, después de crear la implementación. En este tutorial, configurará un dispositivo principal único.

  5. En el paso 2: Asociar los dispositivos cliente, asocie AWS IoT lo del dispositivo cliente al dispositivo principal. Esto permite que el dispositivo de cliente use 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 de cliente.

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

    3. Elija Add (Añadir).

    4. Elija Associate (Asociar).

  6. En el Paso 3: Configurar e implementar los componentes de Greengrass, implemente componentes para habilitar la compatibilidad con el dispositivo de 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 de cliente:

    1. El dispositivo principal debe ejecutar el núcleo de Greengrass versión 2.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. Elija 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 Actualización del software AWS IoT Greengrass Core (OTA).

    2. Para 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 MQTT agente en el dispositivo principal. Haga lo siguiente:

      1. En Configuración, en el bloque de códigos Configuración para combinar, introduzca la siguiente configuración, que contiene una política de autorización de dispositivos de cliente. Cada política de autorización de grupos de dispositivos especifica un conjunto de acciones y los recursos en los que un dispositivo de 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 MQTT temas». MyClientDevice MyClientDevice*Sustitúyalo 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 de cliente. El comodín * debe estar al final del nombre.

          Si tiene que conectar un segundo dispositivo cliente, sustitúyalo 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 de cliente con nombres MyOtherClientDevice* que coincidan 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 sobre todos los MQTT temas». MyOtherClientDevice Puede eliminar esta cláusula de la regla de selección o modificarla para que coincida con los dispositivos de cliente a los que se va a conectar.

        • Esta política permite a los dispositivos cliente publicar y suscribirse sobre todos los MQTT temas. Para seguir las prácticas recomendadas de seguridad, limite las operaciones mqtt:publish y mqtt:subscribe al conjunto mínimo de temas que usan los dispositivos de 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 de cliente.

      2. Elija 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 MQTT los mensajes de los dispositivos cliente a AWS IoT Core. Haga lo siguiente:

      1. En Configuración, en bloque de códigos Configuración para combinar, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de MQTT los mensajes 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 tema clients/MyClientDevice1/hello/world.

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

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

      2. Elija Confirmar.

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

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

  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 Objetivo en la Descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

Paso 3: Conectar los dispositivos de cliente

Los dispositivos cliente pueden usarlo SDK para dispositivos con AWS IoT para detectar, conectarse y comunicarse con un dispositivo principal. El dispositivo cliente debe ser una AWS IoT cosa. Para obtener más información, consulte Crear un objeto en la Guía para desarrolladores de AWS IoT Core .

En esta sección, instalará la versión 2 del SDK para dispositivos con AWS IoT para Python y ejecutará la aplicación de ejemplo de detección de Greengrass desde el SDK para dispositivos con AWS IoT.

nota

También SDK para dispositivos con AWS IoT está disponible en otros lenguajes de programación. Este tutorial usa la SDK para dispositivos con AWS IoT v2 para Python, pero puedes explorar la otra SDKs para tu caso de uso. Para obtener más información, consulte AWS IoT Dispositivo SDKs en la guía para AWS IoT Core desarrolladores.

Conexión de un dispositivo de cliente a un dispositivo principal
  1. Descargue e instale la SDK para dispositivos con AWS IoT versión 2 para Python en el AWS IoT dispositivo para conectarlo como dispositivo cliente.

    En el dispositivo de 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
  2. 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
  3. Ejecute la aplicación de ejemplo de detección de Greengrass. Esta aplicación espera argumentos que especifiquen el nombre del dispositivo cliente, el MQTT tema y el mensaje que se van a utilizar y los certificados que autentican y protegen la conexión. En el siguiente ejemplo, se envía el mensaje “Hello World” al tema clients/MyClientDevice1/hello/world.

    nota

    Este tema coincide con el tema en el que configuró AWS IoT Core anteriormente el MQTT puente para retransmitir los mensajes.

    • MyClientDevice1Sustitúyalo por el nombre del dispositivo cliente.

    • ~/certs/AmazonRootCA1.pemSustitúyalo por la ruta al certificado de CA raíz de Amazon en el dispositivo cliente.

    • ~/certs/device.pem.crtSustitúyalo por la ruta al certificado del dispositivo del dispositivo cliente.

    • ~/certs/private.pem.keySustitúyalo por la ruta al archivo de clave privada del dispositivo cliente.

    • us-east-1Sustitúyala por la AWS región en la que funcionan el dispositivo cliente y el 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

    La aplicación de ejemplo de detección 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ó MQTT mensajes 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 el comando 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 de cliente se conecta y envía mensajes correctamente. Para obtener más información, consulte Supervisión de los registros de AWS IoT Greengrass.

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

    1. Vaya a la consola de AWS IoT.

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

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

    4. Elija Suscribirse.

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

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

Paso 4: Desarrollar un componente que se comunique con los dispositivos de cliente

Puede desarrollar componentes de Greengrass que se comuniquen con los dispositivos de cliente. Los componentes utilizan la comunicación entre procesos (IPC) y la interfaz local de publicación/suscripción para comunicarse en un dispositivo principal. Para interactuar con los dispositivos cliente, configure el componente MQTT puente para retransmitir mensajes entre los dispositivos cliente y la interfaz local de publicación/suscripción.

En esta sección, se actualiza el componente de MQTT puente para retransmitir los mensajes desde los dispositivos cliente a la interfaz local de publicación/suscripción. A continuación, desarrolla un componente que se suscribe a estos mensajes y los imprime cuando los recibe.

Desarrollo de un componente que se comunique con los dispositivos de cliente
  1. Revise la implementación en el dispositivo principal y configure el componente de MQTT puente para retransmitir los mensajes desde los dispositivos cliente a los dispositivos de publicación o suscripción locales. Haga lo siguiente:

    1. En el panel de navegación de la izquierda, elija Dispositivos principales.

    2. En la página de Dispositivos principales, elija el dispositivo principal que va a usar para este tutorial.

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

    4. En la pestaña Dispositivos de 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 de cliente se implementan en el dispositivo principal.

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

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

      1. En Configuración, en bloque de códigos Configuración para combinar, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de MQTT mensajes 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 la configuración de los componentes MQTTdel puente.

      2. Elija Confirmar.

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

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

    9. 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 Objetivo en la Descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

  2. Desarrolle e implemente un componente de Greengrass que se suscriba a los mensajes de “Hello World” desde los dispositivos de 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
      mkdir recipes mkdir -p artifacts/com.example.clientdevices.MyHelloWorldSubscriber/1.0.0
      importante

      Debe usar 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. Use un editor de texto para crear una receta de componente 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. Use un editor de texto para crear un artefacto de script de Python denominado hello_world_subscriber.py con los siguientes contenidos. Esta aplicación utiliza el IPC servicio 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

      Copie 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 IPC cliente V2 en la SDK para dispositivos con AWS IoT v2 para Python para comunicarse con el software AWS IoT Greengrass Core. En comparación con el IPC cliente original, el IPC cliente V2 reduce la cantidad de código que hay que escribir para usarlo IPC en componentes personalizados.

    4. Utilice Greengrass CLI para desplegar 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"
      sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir recipes \ --artifactDir artifacts \ --merge "com.example.clientdevices.MyHelloWorldSubscriber=1.0.0"
  3. Vea los registros de los componentes para comprobar que el componente se ha instalado correctamente y que está suscrito al tema.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log

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

  4. En el dispositivo de cliente, vuelva a ejecutar la aplicación de ejemplo de detección de Greengrass 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
  5. Vuelva a ver los registros de los componentes para comprobar que el componente recibe e imprime los mensajes del dispositivo de cliente.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MyHelloWorldSubscriber.log

Paso 5: Desarrollar un componente que interactúe con las sombras de dispositivos de cliente

Puede desarrollar componentes de Greengrass que interactúen con las sombras de dispositivos de cliente de AWS IoT. Una sombra es un JSON documento que almacena la información del estado actual o deseado de una AWS IoT cosa, como un dispositivo cliente. Los componentes personalizados pueden acceder a las sombras de dispositivos de cliente para administrar su estado, incluso cuando el dispositivo de cliente no está conectado a AWS IoT. Cada AWS IoT elemento tiene una sombra sin nombre y también puede crear varias sombras con nombre para cada elemento.

En esta sección, implementará el componente administrador de sombras para administrar las sombras en el dispositivo principal. También se actualiza el componente MQTT bridge para retransmitir mensajes ocultos entre los dispositivos cliente y el componente de administrador de sombras. A continuación, desarrolle un componente que actualice las sombras de dispositivo de cliente y ejecute una aplicación de ejemplo en los dispositivos de cliente que responden a las actualizaciones de sombra del componente. Este componente representa una aplicación de administración de la iluminación inteligente, en la que el dispositivo principal administra el estado del color de las luces inteligentes que se conectan a él como dispositivos de cliente.

Desarrollo de un componente que interactúe con las sombras de dispositivos de cliente
  1. Revise la implementación en el dispositivo principal para implementar el componente de administrador oculto y configure el componente de MQTT puente 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. En el panel de navegación de la izquierda, elija Dispositivos principales.

    2. En la página de Dispositivos principales, elija el dispositivo principal que va a usar para este tutorial.

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

    4. En la pestaña Dispositivos de 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 de cliente se implementan en el dispositivo principal.

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

    6. En el modal Editar configuración del componente MQTT bridge, configure un mapeo de temas que retransmita MQTT mensajes sobre temas ocultos entre los dispositivos cliente y la interfaz local de publicación/suscripción. También confirmas que la implementación especifica una versión de bridge compatibleMQTT. La compatibilidad con la sombra de dispositivos cliente requiere MQTT Bridge v2.2.0 o posterior. Haga lo siguiente:

      1. Para la Versión de componentes, elija la versión 2.2.0 o posterior.

      2. En Configuración, en bloque de códigos Configuración para combinar, introduzca la siguiente configuración. Esta configuración especifica la retransmisión de MQTT mensajes sobre temas ocultos.

        { "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 la configuración de los componentes del MQTT puente.

      3. Elija Confirmar.

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

    8. Elija 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 Objetivo en la Descripción general de la implementación. Para obtener más información, consulte los siguientes temas:

  2. Desarrolle e implemente un componente de Greengrass que administre los dispositivos de cliente de iluminación inteligente. 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
      mkdir -p artifacts/com.example.clientdevices.MySmartLightManager/1.0.0
      importante

      Debe usar 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. Use un editor de texto para crear una receta de componente 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. Use un editor de texto para crear un artefacto de script de Python denominado smart_light_manager.py con los siguientes contenidos. Esta aplicación utiliza el IPC servicio paralelo para obtener y actualizar las sombras de los dispositivos cliente y el servicio local de publicación/suscripción para recibir las actualizaciones ocultas IPC 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

      Copie 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 de cliente de iluminación inteligente que hay que administrar.

      • 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 cada sombra de dispositivo de cliente de iluminación inteligente para obtener su estado de color inicial.

      • Establece el color de cada dispositivo de cliente de iluminación inteligente en un color asignado al azar cada 15 segundos. El componente actualiza la sombra del objeto del dispositivo de cliente para cambiar su color. Esta operación envía un evento delta oculto al dispositivo clienteMQTT.

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

    4. Utilice Greengrass CLI para desplegar el componente. Al implementar este componente, se especifica la lista de dispositivos de cliente, smartLightDeviceNames, cuyas sombras administra. MyClientDevice1Sustitúyalo 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" ] } } }'
      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" ] } } }'
  3. Vea los registros de los componentes para comprobar que el componente se instala y ejecuta correctamente.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log

    El componente envía solicitudes para cambiar el color del dispositivo de cliente de iluminación inteligente. El administrador de sombras recibe la solicitud y establece el estado de la sombra desired. Sin embargo, el dispositivo de cliente de iluminación inteligente aún no está funcionando, por lo que el estado reported 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 abierto el feed de registro abierto para ver cuándo imprime los mensajes el componente.

  4. Descargue y ejecute una aplicación de ejemplo que use la detección de Greengrass y se suscribe a las actualizaciones de la sombra de dispositivo. En el dispositivo de 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 usa 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. Use un editor de texto para crear un script de Python denominado basic_discovery_shadow.py con el siguiente contenido. Esta aplicación usa la detección y las sombras de Greengrass para mantener sincronizada una propiedad entre el dispositivo de cliente y el dispositivo principal.

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

      nano basic_discovery_shadow.py

      Copie 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:

      • Usa la detección de Greengrass para descubrir el dispositivo principal y conectarse a él.

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

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

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

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

      • MyClientDevice1Sustitúyalo por el nombre del dispositivo cliente.

      • ~/certs/AmazonRootCA1.pemSustitúyalo por la ruta al certificado de CA raíz de Amazon en el dispositivo cliente.

      • ~/certs/device.pem.crtSustitúyalo por la ruta al certificado del dispositivo del dispositivo cliente.

      • ~/certs/private.pem.keySustitúyalo por la ruta al archivo de clave privada del dispositivo cliente.

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

      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 de sombra y espera a recibir los eventos delta de sombra del dispositivo principal. Si el resultado indica que la aplicación recibe eventos delta de sombra y responde a ellos, el dispositivo de 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 el comando 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 de cliente se conecta y envía mensajes correctamente. Para obtener más información, consulte Supervisión de los registros de AWS IoT Greengrass.

  5. Vuelva a ver los registros de los componentes para comprobar que el componente recibe confirmaciones de actualización de sombra del dispositivo de cliente de iluminación inteligente.

    Linux or Unix
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log
    PowerShell
    gc C:\greengrass\v2/logs/com.example.clientdevices.MySmartLightManager.log -Tail 10 -Wait
    sudo tail -f /greengrass/v2/logs/com.example.clientdevices.MySmartLightManager.log

    El componente registra los mensajes para confirmar que el dispositivo de 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}
nota

La sombra de dispositivo de cliente está sincronizada entre el dispositivo principal y el dispositivo de cliente. Sin embargo, el dispositivo principal no sincroniza la sombra del dispositivo cliente con AWS IoT Core. Por ejemplo, puedes sincronizar una sombra AWS IoT Core para ver o modificar el estado de todos los dispositivos de tu flota. Para obtener más información sobre cómo configurar el componente de administrador de sombras con el que se sincronizan las sombras AWS IoT Core, consulteSincronización de las sombras de dispositivo locales con AWS IoT Core.

Completó este tutorial. El dispositivo cliente se conecta al dispositivo principal, envía MQTT mensajes a AWS IoT Core los componentes de Greengrass y recibe actualizaciones instantáneas del dispositivo principal. Para obtener más información sobre los temas abordados en este tutorial, consulte lo siguiente:

PrivacidadTérminos del sitioPreferencias de cookies
© 2025, Amazon Web Services, Inc o sus afiliados. Todos los derechos reservados.