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. # Paso 4: Desarrollo y prueba de un componente en su dispositivo Un componente es un módulo de software que se ejecuta en los dispositivos AWS IoT Greengrass principales. Los componentes le permiten crear y administrar aplicaciones complejas como bloques de compilación discretos que puede reutilizar de un dispositivo principal de Greengrass a otro. Cada componente incluye una *receta* y *artefactos*. + **Recetas** Cada componente contiene un archivo de recetas que define sus metadatos. La receta también especifica los parámetros de configuración, dependencias del componente, ciclo de vida y compatibilidad de plataforma del componente. El ciclo de vida del componente define los comandos que instalan, ejecutan y apagan el componente. Para obtener más información, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md). Puede definir recetas en formato [JSON](https://en.wikipedia.org/wiki/JSON) o [YAML](https://en.wikipedia.org/wiki/YAML). + **Artefactos** Los componentes pueden tener cualquier número de artefactos, que son componentes binarios. Los artefactos pueden incluir scripts, código compilado, recursos estáticos y cualquier otro archivo que utilice un componente. Los componentes también pueden utilizar artefactos de las dependencias de los componentes. Con AWS IoT Greengrass, puede usar la CLI de Greengrass para desarrollar y probar componentes localmente en un dispositivo central de Greengrass sin interactuar con la nube. AWS Cuando complete su componente local, podrá usar la receta y los artefactos del componente para crear ese componente en el AWS IoT Greengrass servicio en la AWS nube y, a continuación, implementarlo en todos sus dispositivos principales de Greengrass. Para obtener más información sobre los componentes, consulte [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md). En esta sección, aprenderá a crear y ejecutar un componente básico de Hello World de forma local en su dispositivo principal. **Desarrollo de un componente de Hello World en su dispositivo** 1. Cree una carpeta para sus componentes con subcarpetas para recetas y artefactos. Ejecute los siguientes comandos en su dispositivo principal de Greengrass para crear estas carpetas y cambiarlas a la carpeta de componentes. Sustituya *\$1/greengrassv2* o *%USERPROFILE%\$1greengrassv2* por la ruta a la carpeta que desee utilizar para el desarrollo local. ------ #### [ Linux or Unix ] ``` mkdir -p ~/greengrassv2/{recipes,artifacts} cd ~/greengrassv2 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts cd %USERPROFILE%\greengrassv2 ``` ------ #### [ PowerShell ] ``` mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts cd ~/greengrassv2 ``` ------ 1. Use un editor de texto para crear un archivo de recetas que define los metadatos, parámetros, dependencias, ciclo de vida y capacidad de plataforma de su componente. Incluya la versión del componente en el nombre del archivo de recetas para poder identificar qué receta refleja qué versión del componente. Puede elegir el formato YAML o JSON para su receta. Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo. ------ #### [ JSON ] ``` nano recipes/com.example.HelloWorld-1.0.0.json ``` ------ #### [ YAML ] ``` nano recipes/com.example.HelloWorld-1.0.0.yaml ``` ------ **nota** AWS IoT Greengrass usa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de *principal*.*secundario*.*parche*. Por ejemplo, la versión `1.0.0` representa el primer lanzamiento principal de un componente. Para obtener más información, consulte la [especificación semántica de la versión](https://semver.org/). 1. Pegue la siguiente receta en el archivo. ------ #### [ JSON ] ``` { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.HelloWorld", "ComponentVersion": "1.0.0", "ComponentDescription": "My first AWS IoT Greengrass component.", "ComponentPublisher": "Amazon", "ComponentConfiguration": { "DefaultConfiguration": { "Message": "world" } }, "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } }, { "Platform": { "os": "windows" }, "Lifecycle": { "run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}" } } ] } ``` ------ #### [ YAML ] ``` --- RecipeFormatVersion: '2020-01-25' ComponentName: com.example.HelloWorld ComponentVersion: '1.0.0' ComponentDescription: My first AWS IoT Greengrass component. ComponentPublisher: Amazon ComponentConfiguration: DefaultConfiguration: Message: world Manifests: - Platform: os: linux Lifecycle: run: | python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" - Platform: os: windows Lifecycle: run: | py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}" ``` ------ La receta de la sección `ComponentConfiguration` define un parámetro, `Message`, cuyo valor predeterminado es `world`. La sección `Manifests` define un *manifiesto*, que es un conjunto de instrucciones y artefactos del ciclo de vida de una plataforma. Puede definir varios manifiestos para especificar diferentes instrucciones de instalación para distintas plataformas, por ejemplo. En el manifiesto, la sección `Lifecycle` indica al dispositivo principal de Greengrass que ejecute el script Hello World con el valor del parámetro `Message` como un argumento. 1. Ejecute el siguiente comando para crear una carpeta para los artefactos del componente. ------ #### [ Linux or Unix ] ``` mkdir -p artifacts/com.example.HelloWorld/1.0.0 ``` ------ #### [ Windows Command Prompt (CMD) ] ``` mkdir artifacts\com.example.HelloWorld\1.0.0 ``` ------ #### [ PowerShell ] ``` mkdir artifacts\com.example.HelloWorld\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/ ``` 1. Use un editor de texto para crear un archivo de artefactos de script de Python para su componente Hello World. Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo. ``` nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py ``` Copie y pegue el siguiente script de Python en el archivo. ``` import sys message = "Hello, %s!" % sys.argv[1] # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. Utilice la AWS IoT Greengrass CLI local para gestionar los componentes de su dispositivo principal de Greengrass. Ejecute el siguiente comando para implementar el componente en el AWS IoT Greengrass núcleo. Sustituya `/greengrass/v2` o *C:\$1greengrass\$1v2* por AWS IoT Greengrass V2 la carpeta raíz y sustituya *\$1/greengrassv2* o *%USERPROFILE%\$1greengrassv2* por la carpeta de desarrollo de componentes. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ Este comando agrega el componente que usa la receta en `recipes` y el script de Python en `artifacts`. La opción `--merge` agrega o actualiza el componente y la versión que especifique. 1. El software AWS IoT Greengrass Core guarda la salida estándar del proceso de los componentes en los archivos de registro de la `logs` carpeta. Ejecute el siguiente comando para comprobar que el componente Hello World ejecuta e imprime mensajes. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` El comando `type` escribe el contenido del archivo en la terminal. Ejecute este comando varias veces para observar los cambios en el archivo. ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ Debería ver mensajes similares al del siguiente ejemplo. ``` Hello, world! ``` **nota** Si el archivo no existe, es posible que la implementación local aún no esté completa. Si el archivo no existe en 15 segundos, es probable que la implementación haya fallado. Esto puede ocurrir si la receta no es válida, por ejemplo. Ejecute el siguiente comando para ver el archivo de registro AWS IoT Greengrass principal. Este archivo incluye registros del servicio de implementación del dispositivo principal de Greengrass. ``` sudo tail -f /greengrass/v2/logs/greengrass.log ``` ``` type C:\greengrass\v2\logs\greengrass.log ``` El comando `type` escribe el contenido del archivo en la terminal. Ejecute este comando varias veces para observar los cambios en el archivo. ``` gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait ``` 1. Modifique el componente local para iterar y probar el código. Ábrelo `hello_world.py` en un editor de texto y añade el siguiente código en la línea 4 para editar el mensaje que registra el AWS IoT Greengrass núcleo. ``` message += " Greetings from your first Greengrass component." ``` Ahora, el script `hello_world.py` debería tener los siguientes contenidos. ``` import sys message = "Hello, %s!" % sys.argv[1] message += " Greetings from your first Greengrass component." # Print the message to stdout, which Greengrass saves in a log file. print(message) ``` 1. Ejecute el siguiente comando para actualizar el componente con los cambios. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --recipeDir ~/greengrassv2/recipes \ --artifactDir ~/greengrassv2/artifacts \ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --recipeDir %USERPROFILE%\greengrassv2\recipes ^ --artifactDir %USERPROFILE%\greengrassv2\artifacts ^ --merge "com.example.HelloWorld=1.0.0" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --recipeDir ~/greengrassv2/recipes ` --artifactDir ~/greengrassv2/artifacts ` --merge "com.example.HelloWorld=1.0.0" ``` ------ Este comando actualiza el componente `com.example.HelloWorld` con el último artefacto de Hello World. 1. Ejecute el siguiente comando para reiniciar el componente. Al reiniciar un componente, el dispositivo principal usa los cambios más recientes. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component restart \ --names "com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ^ --names "com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component restart ` --names "com.example.HelloWorld" ``` ------ 1. Vuelva a comprobar el registro para verificar que el componente Hello World imprime el nuevo mensaje. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` El comando `type` escribe el contenido del archivo en la terminal. Ejecute este comando varias veces para observar los cambios en el archivo. ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ Debería ver mensajes similares al del siguiente ejemplo. ``` Hello, world! Greetings from your first Greengrass component. ``` 1. Puede actualizar los parámetros de configuración del componente para probar diferentes configuraciones. Al implementar un componente, puede especificar una *actualización de configuración*, que defina cómo modificar la configuración del componente en el dispositivo principal. Puede especificar qué valores de configuración desea restablecer a los valores predeterminados y los nuevos valores de configuración que se van a fusionar en el dispositivo principal. Para obtener más información, consulte [Actualización de las configuraciones de los componentes](update-component-configurations.md). Haga lo siguiente: 1. Use un editor de texto para crear un archivo llamado `hello-world-config-update.json` para contener la actualización de configuración Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo. ``` nano hello-world-config-update.json ``` 1. Copie y pegue el siguiente objeto JSON en el archivo. Este objeto JSON define una actualización de configuración que combina el valor `friend` con el parámetro `Message` para actualizar su valor. Esta actualización de configuración no especifica ningún valor que se vaya a restablecer. No es necesario restablecer el parámetro `Message` porque la actualización de la combinación reemplaza el valor existente. ``` { "com.example.HelloWorld": { "MERGE": { "Message": "friend" } } } ``` 1. Ejecute el siguiente comando para implementar la actualización de configuración en el componente Hello World. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ^ --merge "com.example.HelloWorld=1.0.0" ^ --update-config hello-world-config-update.json ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create ` --merge "com.example.HelloWorld=1.0.0" ` --update-config hello-world-config-update.json ``` ------ 1. Vuelva a comprobar el registro para comprobar que el componente Hello World genera el nuevo mensaje. ------ #### [ Linux or Unix ] ``` sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log ``` ------ #### [ Windows Command Prompt (CMD) ] ``` type C:\greengrass\v2\logs\com.example.HelloWorld.log ``` El comando `type` escribe el contenido del archivo en la terminal. Ejecute este comando varias veces para observar los cambios en el archivo. ------ #### [ PowerShell ] ``` gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait ``` ------ Debería ver mensajes similares al del siguiente ejemplo. ``` Hello, friend! Greetings from your first Greengrass component. ``` 1. Cuando termine de probar el componente, retírelo del dispositivo principal. Ejecute el comando siguiente. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld" ``` ------ **importante** Este paso es necesario para volver a implementar el componente en el dispositivo principal después de cargarlo en AWS IoT Greengrass. De lo contrario, se produce un error en la implementación y se produce un error de compatibilidad de versiones porque la implementación local especifica una versión diferente del componente. Ejecute el siguiente comando y compruebe que el componente `com.example.HelloWorld` no aparezca en la lista de componentes del dispositivo. ------ #### [ Linux or Unix ] ``` sudo /greengrass/v2/bin/greengrass-cli component list ``` ------ #### [ Windows Command Prompt (CMD) ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ #### [ PowerShell ] ``` C:\greengrass\v2\bin\greengrass-cli component list ``` ------ Su componente Hello World está completo y ahora puede subirlo al servicio AWS IoT Greengrass en la nube. A continuación, puede implementar el componente en los dispositivos principales de Greengrass.