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.

# Tutorial: Desarrollo de un componente de Greengrass que aplace las actualizaciones de los componentes
<a name="defer-component-updates-tutorial"></a>

Puede completar este tutorial para desarrollar un componente que aplaza las actualizaciones de over-the-air implementación. Al implementar actualizaciones en sus dispositivos, es posible que desee aplazar las actualizaciones en función de ciertas condiciones, como las siguientes:
+ El nivel de batería del dispositivo es bajo.
+ El dispositivo está ejecutando un proceso o un trabajo que no se puede interrumpir.
+ El dispositivo tiene una conexión a Internet limitada o cara.

**nota**  
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.

En este tutorial, aprenderá a hacer lo siguiente:

1. Instale la CLI del kit de desarrollo de Greengrass (CLI del GDK) en su computadora de desarrollo. La CLI del GDK proporciona características que lo ayudan a desarrollar componentes personalizados de Greengrass.

1. Desarrolle un componente Hello World que aplace las actualizaciones de los componentes cuando el nivel de batería del dispositivo principal esté por debajo de un umbral. Este componente se suscribe a las notificaciones de actualización mediante la operación [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. Cuando recibe la notificación, comprueba si el nivel de la batería es inferior a un umbral personalizable. Si el nivel de la batería está por debajo del umbral, aplaza la actualización durante 30 segundos mediante la [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)operación IPC. Este componente se desarrolla en la computadora de desarrollo mediante la CLI del GDK.
**nota**  
Este componente lee el nivel de la batería a partir de un archivo que usted crea en el dispositivo principal para imitar una batería real, por lo que puede completar este tutorial en un dispositivo principal sin batería.

1. Publique ese componente en el AWS IoT Greengrass servicio.

1. Despliegue ese componente desde Nube de AWS el dispositivo principal de Greengrass para probarlo. A continuación, se modifica el nivel de batería virtual del dispositivo principal y se crean implementaciones adicionales para comprobar cómo el dispositivo principal aplaza las actualizaciones cuando el nivel de batería es bajo.

Calcule dedicar unos 20-30 minutos a este tutorial.

# Requisitos previos
<a name="defer-component-updates-tutorial-prerequisites"></a>

Necesitará lo siguiente para completar este tutorial:
+ Un Cuenta de AWS. Si no dispone de una, consulte [Configura un Cuenta de AWS](setting-up.md#set-up-aws-account).
+ Un usuario de AWS Identity and Access Management (IAM) con permisos de administrador.
+ Un dispositivo principal de Greengrass con conexión a Internet. Para obtener más información acerca de cómo configurar un dispositivo principal, consulte [Configuración de los dispositivos AWS IoT Greengrass principales](setting-up.md).
  + Se necesita tener la versión 3.6 o posterior de [Python](https://www.python.org/downloads/) instalada en el dispositivo principal y agregada a la variable de entorno `PATH`. En Windows, también debe tener instalado el lanzador de Python para Windows para todos los usuarios.
**importante**  <a name="windows-core-device-python-installation"></a>
En Windows, Python no se instala para todos los usuarios de forma predeterminada. Al instalar Python, debe personalizar la instalación para configurarla para que el software AWS IoT Greengrass Core ejecute scripts de Python. Por ejemplo, si usa el instalador gráfico de Python, haga lo siguiente:  
Elija **Instalar el lanzador para todos los usuarios (recomendado)**.
Elija **Customize installation**.
Elija **Next**.
Seleccione **Install for all users**.
Seleccione **Add Python to environment variables**.
Elija **Instalar**.
Para obtener más información, consulte [Uso de Python en Windows](https://docs.python.org/3/using/windows.html) en la *documentación de Python 3*.
+ Una computadora de desarrollo similar a Windows, macOS o Unix con conexión a Internet.
  + Versión 3.6 o posterior de [Python](https://www.python.org/downloads/) instalada en su computadora de desarrollo.
  + [Git](https://git-scm.com/) instalado en su computadora de desarrollo.
  + <a name="development-component-aws-cli-prerequisite"></a>AWS Command Line Interface (AWS CLI) instalado y configurado con credenciales en su computadora de desarrollo. Para obtener más información, consulte [Instalar, actualizar y desinstalar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) y [Configurar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) en la *Guía del usuario de AWS Command Line Interface*.
**nota**  
Si usa una Raspberry Pi u otro dispositivo ARM de 32 bits, instale la versión 1 de AWS CLI. AWS CLI La versión 2 no está disponible para dispositivos ARM de 32 bits. Para obtener más información, consulte [Instalar, actualizar y desinstalar la versión 1 de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html).

# Paso 1: Instalar la CLI del kit de desarrollo de Greengrass
<a name="install-gdk-cli-defer-updates"></a>

La [CLI del kit de desarrollo de Greengrass (CLI del GDK)](greengrass-development-kit-cli.md) proporciona características que lo ayudan a desarrollar componentes personalizados de Greengrass. Puede usar la CLI del GDK para crear, compilar y publicar componentes personalizados.

Si no ha instalado la CLI del GDK en su equipo de desarrollo, complete los siguientes pasos para instalarla.

**Cómo instalar la última versión de la CLI del GDK**

1. En su computadora de desarrollo, ejecute el siguiente comando para instalar la versión más reciente de la CLI de GDK desde su [repositorio de GitHub](https://github.com/aws-greengrass/aws-greengrass-gdk-cli).

   ```
   python3 -m pip install -U git+https://github.com/aws-greengrass/aws-greengrass-gdk-cli.git@v1.6.2
   ```

1. <a name="gdk-cli-verify-installation"></a>Ejecute los siguientes comandos para verificar que la CLI del GDK se instaló correctamente.

   ```
   gdk --help
   ```

   Si no se encuentra el comando `gdk`, agregue su carpeta a PATH.
   + En dispositivos Linux, agregue `/home/MyUser/.local/bin` a PATH y sustituya *MyUser* por el nombre de su usuario.
   + En dispositivos Windows, agregue `PythonPath\\Scripts` a PATH y sustituya *PythonPath* por la ruta a la carpeta Python de su dispositivo.

# Paso 2: Desarrollar un componente que aplace las actualizaciones
<a name="develop-component-defer-updates"></a>

En esta sección, desarrollará un componente Hello World en Python que aplaza las actualizaciones de los componentes cuando el nivel de batería del dispositivo principal esté por debajo del umbral que usted configuró al implementar el componente. En este componente, se utiliza la [interfaz de comunicación entre procesos (IPC)](interprocess-communication.md) de la SDK para dispositivos con AWS IoT versión 2 para Python. La operación [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC se utiliza para recibir notificaciones cuando el dispositivo principal recibe una implementación. A continuación, se utiliza la operación [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC para aplazar o confirmar la actualización en función del nivel de batería del dispositivo.

**Desarrollo de un componente Hello World que aplace las actualizaciones**

1. En su computadora de desarrollo, cree una carpeta para el código de origen del componente.

   ```
   mkdir com.example.BatteryAwareHelloWorld
   cd com.example.BatteryAwareHelloWorld
   ```

1. Utilice un editor de texto para crear un archivo llamado `gdk-config.json`. La CLI de GDK lee el [archivo de configuración de la CLI de GDK](gdk-cli-configuration-file.md), denominado `gdk-config.json`, para crear y publicar componentes. Este archivo de configuración existe en la raíz de la carpeta del componente.

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   nano gdk-config.json
   ```

   Copie el siguiente JSON en el archivo.
   + *Amazon*Sustitúyalo por tu nombre.
   + *us-west-2*Reemplácelo por el Región de AWS lugar donde funciona su dispositivo principal. La CLI del GDK publica el componente en esta Región de AWS.
   + *greengrass-component-artifacts*Sustitúyalo por el prefijo de bucket S3 que desee utilizar. Cuando utiliza la CLI de GDK para publicar el componente, la CLI de GDK carga los artefactos del componente en el bucket de S3 cuyo nombre se forma a partir de este valor Región de AWS, el y su Cuenta de AWS ID con el siguiente formato:. `bucketPrefix-region-accountId`

     Por ejemplo, si especificas **greengrass-component-artifacts** y**us-west-2**, y tu Cuenta de AWS ID es**123456789012**, la CLI de GDK usa el bucket de S3 denominado`greengrass-component-artifacts-us-west-2-123456789012`.

   ```
   {
     "component": {
       "com.example.BatteryAwareHelloWorld": {
         "author": "Amazon",
         "version": "NEXT_PATCH",
         "build": {
           "build_system" : "zip"
         },
         "publish": {
           "region": "us-west-2",
           "bucket": "greengrass-component-artifacts"
         }
       }
     },
     "gdk_version": "1.0.0"
   }
   ```

   El archivo de configuración especifica lo siguiente:
   + La versión que se utilizará cuando la CLI de GDK publique el componente Greengrass en el servicio en AWS IoT Greengrass la nube. `NEXT_PATCH`especifica que se debe elegir la siguiente versión del parche después de la última versión disponible en el servicio en la AWS IoT Greengrass nube. Si el componente aún no tiene una versión en el servicio en la AWS IoT Greengrass nube, la CLI de GDK la utiliza`1.0.0`.
   + El sistema de compilación del componente. Cuando se utiliza el sistema de compilación `zip`, la CLI del GDK empaqueta el código de origen del componente en un archivo ZIP que se convierte en el único artefacto del componente.
   + Allí Región de AWS donde la CLI de GDK publica el componente Greengrass.
   + El prefijo del bucket de S3 donde la CLI del GDK carga los artefactos del componente.

1. Utilice un editor de texto para crear el código de origen del componente en un archivo denominado `main.py`.

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   nano main.py
   ```

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

   ```
   import json
   import os
   import sys
   import time
   import traceback
   
   from pathlib import Path
   
   from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
   
   HELLO_WORLD_PRINT_INTERVAL = 15  # Seconds
   DEFER_COMPONENT_UPDATE_INTERVAL = 30 * 1000  # Milliseconds
   
   
   class BatteryAwareHelloWorldPrinter():
       def __init__(self, ipc_client: GreengrassCoreIPCClientV2, battery_file_path: Path, battery_threshold: float):
           self.battery_file_path = battery_file_path
           self.battery_threshold = battery_threshold
           self.ipc_client = ipc_client
           self.subscription_operation = None
   
       def on_component_update_event(self, event):
           try:
               if event.pre_update_event is not None:
                   if self.is_battery_below_threshold():
                       self.defer_update(event.pre_update_event.deployment_id)
                       print('Deferred update for deployment %s' %
                             event.pre_update_event.deployment_id)
                   else:
                       self.acknowledge_update(
                           event.pre_update_event.deployment_id)
                       print('Acknowledged update for deployment %s' %
                             event.pre_update_event.deployment_id)
               elif event.post_update_event is not None:
                   print('Applied update for deployment')
           except:
               traceback.print_exc()
   
       def subscribe_to_component_updates(self):
           if self.subscription_operation == None:
               # SubscribeToComponentUpdates returns a tuple with the response and the operation.
               _, self.subscription_operation = self.ipc_client.subscribe_to_component_updates(
                   on_stream_event=self.on_component_update_event)
   
       def close_subscription(self):
           if self.subscription_operation is not None:
               self.subscription_operation.close()
               self.subscription_operation = None
   
       def defer_update(self, deployment_id):
           self.ipc_client.defer_component_update(
               deployment_id=deployment_id, recheck_after_ms=DEFER_COMPONENT_UPDATE_INTERVAL)
   
       def acknowledge_update(self, deployment_id):
           # Specify recheck_after_ms=0 to acknowledge a component update.
           self.ipc_client.defer_component_update(
               deployment_id=deployment_id, recheck_after_ms=0)
   
       def is_battery_below_threshold(self):
           return self.get_battery_level() < self.battery_threshold
   
       def get_battery_level(self):
           # Read the battery level from the virtual battery level file.
           with self.battery_file_path.open('r') as f:
               data = json.load(f)
               return float(data['battery_level'])
   
       def print_message(self):
           message = 'Hello, World!'
           if self.is_battery_below_threshold():
               message += ' Battery level (%d) is below threshold (%d), so the component will defer updates' % (
                   self.get_battery_level(), self.battery_threshold)
           else:
               message += ' Battery level (%d) is above threshold (%d), so the component will acknowledge updates' % (
                   self.get_battery_level(), self.battery_threshold)
           print(message)
   
   
   def main():
       # Read the battery threshold and virtual battery file path from command-line args.
       args = sys.argv[1:]
       battery_threshold = float(args[0])
       battery_file_path = Path(args[1])
       print('Reading battery level from %s and deferring updates when below %d' % (
           str(battery_file_path), battery_threshold))
   
       try:
           # Create an IPC client and a Hello World printer that defers component updates.
           ipc_client = GreengrassCoreIPCClientV2()
           hello_world_printer = BatteryAwareHelloWorldPrinter(
               ipc_client, battery_file_path, battery_threshold)
           hello_world_printer.subscribe_to_component_updates()
           try:
               # Keep the main thread alive, or the process will exit.
               while True:
                   hello_world_printer.print_message()
                   time.sleep(HELLO_WORLD_PRINT_INTERVAL)
           except InterruptedError:
               print('Subscription interrupted')
           hello_world_printer.close_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 el nivel de batería del dispositivo principal a partir de un archivo de nivel de batería virtual que creará en el dispositivo principal más adelante. Este archivo de nivel de batería virtual imita una batería real, por lo que puede completar este tutorial en los dispositivos principales que no tienen batería.
   + Lee los argumentos de la línea de comandos para el umbral de batería y la ruta al archivo de nivel de batería virtual. La receta del componente establece estos argumentos de la línea de comandos en función de los parámetros de configuración, por lo que puede personalizar estos valores al implementar el componente.
   + Utiliza el cliente IPC V2 en la [SDK para dispositivos con AWS IoT versión 2 para Python para](https://github.com/aws/aws-iot-device-sdk-python-v2) comunicarse con el software AWS IoT Greengrass Core. En comparación con el cliente IPC original, la versión 2 del cliente IPC reduce la cantidad de código que hay que escribir para usar el IPC en componentes personalizados.
   + Se suscribe para actualizar las notificaciones mediante la operación [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. El software AWS IoT Greengrass principal envía notificaciones antes y después de cada implementación. El componente llama a la siguiente función cada vez que recibe una notificación. Si la notificación es para una próxima implementación, el componente comprueba si el nivel de la batería es inferior a un umbral. Si el nivel de la batería está por debajo del umbral, el componente aplaza la actualización durante 30 segundos mediante la operación [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. De lo contrario, si el nivel de la batería no está por debajo del umbral, el componente confirma la actualización para que esta pueda continuar.

     ```
     def on_component_update_event(self, event):
         try:
             if event.pre_update_event is not None:
                 if self.is_battery_below_threshold():
                     self.defer_update(event.pre_update_event.deployment_id)
                     print('Deferred update for deployment %s' %
                           event.pre_update_event.deployment_id)
                 else:
                     self.acknowledge_update(
                         event.pre_update_event.deployment_id)
                     print('Acknowledged update for deployment %s' %
                           event.pre_update_event.deployment_id)
             elif event.post_update_event is not None:
                 print('Applied update for deployment')
         except:
             traceback.print_exc()
     ```
**nota**  
El software AWS IoT Greengrass principal no envía notificaciones de actualización para las implementaciones locales, por lo que debe implementar este componente mediante el servicio AWS IoT Greengrass en la nube para probarlo.

1. Utilice un editor de texto para crear la receta del componente en un archivo denominado `recipe.json` o `recipe.yaml`. La *receta* del componente define los metadatos del componente, parámetros de configuración predeterminados y scripts de ciclo de vida específicos de la plataforma.

------
#### [ JSON ]

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   nano recipe.json
   ```

   Copie el siguiente JSON en el archivo.

   ```
   {
     "RecipeFormatVersion": "2020-01-25",
     "ComponentName": "COMPONENT_NAME",
     "ComponentVersion": "COMPONENT_VERSION",
     "ComponentDescription": "This Hello World component defers updates when the battery level is below a threshold.",
     "ComponentPublisher": "COMPONENT_AUTHOR",
     "ComponentConfiguration": {
       "DefaultConfiguration": {
         "BatteryThreshold": 50,
         "LinuxBatteryFilePath": "/home/ggc_user/virtual_battery.json",
         "WindowsBatteryFilePath": "C:\\Users\\ggc_user\\virtual_battery.json"
       }
     },
     "Manifests": [
       {
         "Platform": {
           "os": "linux"
         },
         "Lifecycle": {
           "install": "python3 -m pip install --user awsiotsdk --upgrade",
           "Run": "python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/LinuxBatteryFilePath}\""
         },
         "Artifacts": [
           {
             "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip",
             "Unarchive": "ZIP"
           }
         ]
       },
       {
         "Platform": {
           "os": "windows"
         },
         "Lifecycle": {
           "install": "py -3 -m pip install --user awsiotsdk --upgrade",
           "Run": "py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py \"{configuration:/BatteryThreshold}\" \"{configuration:/WindowsBatteryFilePath}\""
         },
         "Artifacts": [
           {
             "Uri": "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip",
             "Unarchive": "ZIP"
           }
         ]
       }
     ]
   }
   ```

------
#### [ YAML ]

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   nano recipe.yaml
   ```

   Copie el siguiente YAML en el archivo.

   ```
   ---
   RecipeFormatVersion: "2020-01-25"
   ComponentName: "COMPONENT_NAME"
   ComponentVersion: "COMPONENT_VERSION"
   ComponentDescription: "This Hello World component defers updates when the battery level is below a threshold."
   ComponentPublisher: "COMPONENT_AUTHOR"
   ComponentConfiguration:
     DefaultConfiguration:
       BatteryThreshold: 50
       LinuxBatteryFilePath: "/home/ggc_user/virtual_battery.json"
       WindowsBatteryFilePath: "C:\\Users\\ggc_user\\virtual_battery.json"
   Manifests:
     - Platform:
         os: linux
       Lifecycle:
         install: python3 -m pip install --user awsiotsdk --upgrade
         Run: python3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/LinuxBatteryFilePath}"
       Artifacts:
         - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip"
           Unarchive: ZIP
     - Platform:
         os: windows
       Lifecycle:
         install: py -3 -m pip install --user awsiotsdk --upgrade
         Run: py -3 -u {artifacts:decompressedPath}/com.example.BatteryAwareHelloWorld/main.py "{configuration:/BatteryThreshold}" "{configuration:/WindowsBatteryFilePath}"
       Artifacts:
         - Uri: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/com.example.BatteryAwareHelloWorld.zip"
           Unarchive: ZIP
   ```

------

   Esta receta especifica lo siguiente:
   + Parámetros de configuración predeterminados para el umbral de batería, la ruta del archivo de batería virtual en los dispositivos principales de Linux y la ruta del archivo de batería virtual en los dispositivos principales de Windows.
   + Un ciclo de vida `install` que instala la última versión de la versión 2 de SDK para dispositivos con AWS IoT para Python.
   + Un ciclo de vida `run` que ejecuta la aplicación Python en `main.py`.
   + Marcadores de posición, como `COMPONENT_NAME` y `COMPONENT_VERSION`, donde la CLI del GDK reemplaza la información al crear la receta del componente.

   Para obtener más información sobre las recetas de componentes, consulte [AWS IoT Greengrass referencia de recetas de componentes](component-recipe-reference.md).

# Paso 3: Publicar el componente en el AWS IoT Greengrass servicio
<a name="publish-component-defer-updates"></a>

En esta sección, publica el componente Hello World en el servicio AWS IoT Greengrass en la nube. Una vez que un componente esté disponible en el servicio en la AWS IoT Greengrass nube, puede implementarlo en los dispositivos principales. Utilice la CLI de GDK para publicar el componente desde su ordenador de desarrollo en el servicio AWS IoT Greengrass en la nube. La CLI del GDK carga la receta y los artefactos del componente por usted.

**Para publicar el componente Hello World en el servicio AWS IoT Greengrass**

1. Ejecute el siguiente comando para compilar el componente mediante la CLI del GDK. El [comando component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) crea una receta y artefactos basados en el archivo de configuración CLI de GDK. En este proceso, la CLI de GDK crea un archivo ZIP que contiene el código de origen del componente.

   ```
   gdk component build
   ```

   Debería ver mensajes similares al del siguiente ejemplo.

   ```
   [2022-04-28 11:20:16] INFO - Getting project configuration from gdk-config.json
   [2022-04-28 11:20:16] INFO - Found component recipe file 'recipe.yaml' in the  project directory.
   [2022-04-28 11:20:16] INFO - Building the component 'com.example.BatteryAwareHelloWorld' with the given project configuration.
   [2022-04-28 11:20:16] INFO - Using 'zip' build system to build the component.
   [2022-04-28 11:20:16] WARNING - This component is identified as using 'zip' build system. If this is incorrect, please exit and specify custom build command in the 'gdk-config.json'.
   [2022-04-28 11:20:16] INFO - Zipping source code files of the component.
   [2022-04-28 11:20:16] INFO - Copying over the build artifacts to the greengrass component artifacts build folder.
   [2022-04-28 11:20:16] INFO - Updating artifact URIs in the recipe.
   [2022-04-28 11:20:16] INFO - Creating component recipe in 'C:\Users\finthomp\greengrassv2\com.example.BatteryAwareHelloWorld\greengrass-build\recipes'.
   ```

1. Ejecute el siguiente comando para publicar el componente en el servicio AWS IoT Greengrass en la nube. El [comando component publish](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) carga el artefacto del archivo ZIP del componente en un bucket de S3. A continuación, actualiza el URI de S3 del archivo ZIP en la receta del componente y carga la receta en el servicio de AWS IoT Greengrass . En este proceso, la CLI de GDK comprueba qué versión del componente Hello World ya está disponible en el servicio en la AWS IoT Greengrass nube para poder elegir la siguiente versión del parche después de esa versión. Si el componente aún no existe, la CLI de GDK usa la versión `1.0.0`.

   ```
   gdk component publish
   ```

   Debería ver mensajes similares al del siguiente ejemplo. El resultado indica la versión del componente que creó la CLI de GDK.

   ```
   [2022-04-28 11:20:29] INFO - Getting project configuration from gdk-config.json
   [2022-04-28 11:20:29] INFO - Found component recipe file 'recipe.yaml' in the  project directory.
   [2022-04-28 11:20:29] INFO - Found credentials in shared credentials file: ~/.aws/credentials
   [2022-04-28 11:20:30] INFO - No private version of the component 'com.example.BatteryAwareHelloWorld' exist in the account. Using '1.0.0' as the next version to create.
   [2022-04-28 11:20:30] INFO - Publishing the component 'com.example.BatteryAwareHelloWorld' with the given project configuration.
   [2022-04-28 11:20:30] INFO - Uploading the component built artifacts to s3 bucket.
   [2022-04-28 11:20:30] INFO - Uploading component artifacts to S3 bucket: greengrass-component-artifacts-us-west-2-123456789012. If this is your first time using this bucket, add the 's3:GetObject' permission to each core device's token exchange role to allow it to download the component artifacts. For more information, see https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html.
   [2022-04-28 11:20:30] INFO - Not creating an artifacts bucket as it already exists.
   [2022-04-28 11:20:30] INFO - Updating the component recipe com.example.BatteryAwareHelloWorld-1.0.0.
   [2022-04-28 11:20:31] INFO - Creating a new greengrass component com.example.BatteryAwareHelloWorld-1.0.0
   [2022-04-28 11:20:31] INFO - Created private version '1.0.0' of the component in the account.'com.example.BatteryAwareHelloWorld'.
   ```

1. Copie el nombre del bucket de S3 de la salida. El nombre del bucket se utiliza más adelante para permitir que el dispositivo principal descargue los artefactos componentes de este bucket.

1. (Opcional) Vea el componente en la AWS IoT Greengrass consola para comprobar que se ha cargado correctamente. Haga lo siguiente:

   1. En el menú de navegación de la [consola de AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), elija **Componentes**.

   1. En la página **Componentes**, elija la pestaña **Mis componentes** y, a continuación, elija **com.example.BatteryAwareHelloWorld**.

      En esta página, puede ver la receta del componente y otra información sobre el componente.

1. <a name="core-device-allow-s3-bucket-access-console-intro-1"></a>Permita que el dispositivo principal acceda a los artefactos de los componentes del bucket de S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-2"></a>Cada dispositivo principal tiene una [función de IAM del dispositivo principal](device-service-role.md) que le permite interactuar con los registros AWS IoT y enviarlos a la AWS nube. Este rol de dispositivo no permite el acceso a los bucket de S3 de forma predeterminada, por lo que debe crear y adjuntar una política que permita que el dispositivo principal recupere artefactos de componentes del bucket de S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-3"></a>Puede omitir este paso si el rol de su dispositivo ya permite acceder al bucket de S3. De lo contrario, cree una política de IAM que permita el acceso y adjúntela al rol, de la siguiente manera:

   1. <a name="core-device-allow-s3-bucket-access-console-step-1"></a>En el panel de navegación de [la consola de IAM](https://console.aws.amazon.com/iam), elija **Políticas**, seguido de **Crear política**.

   1. En la pestaña **JSON**, reemplace el contenido del marcador de posición por la política siguiente. *greengrass-component-artifacts-us-west-2-123456789012*Sustitúyalo por el nombre del depósito de S3 en el que la CLI de GDK cargó los artefactos del componente.

      Por ejemplo, si especificó **greengrass-component-artifacts** y **us-west-2** en el archivo de configuración de la CLI de GDK y su ID de Cuenta de AWS es **123456789012**, la CLI de GDK usa el bucket de S3 llamado `greengrass-component-artifacts-us-west-2-123456789012`.

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Action": [
              "s3:GetObject"
            ],
            "Resource": "arn:aws:s3:::greengrass-component-artifacts-us-west-2-123456789012/*"
          }
        ]
      }
      ```

------

   1. <a name="core-device-allow-s3-bucket-access-console-step-3"></a>Elija **Siguiente**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-4"></a>En la sección **Detalles de política**, en **Nombre**, introduzca **MyGreengrassV2ComponentArtifactPolicy**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-5"></a>Elija **Crear política**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-6"></a>En el menú de navegación de la [consola de IAM](https://console.aws.amazon.com/iam), seleccione **Rol** y, a continuación, elija el nombre del rol para el dispositivo principal. Especificó este nombre de función al instalar el software AWS IoT Greengrass Core. Si no especifica un nombre, el nombre predeterminado es `GreengrassV2TokenExchangeRole`.

   1. <a name="core-device-allow-s3-bucket-access-console-step-7"></a>En la pestaña **Permisos**, elija **Agregar permisos** y, a continuación, **Asociar políticas**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-8"></a>En la sección **Otras políticas de permisos**, seleccione la casilla de verificación junto a la política `MyGreengrassV2ComponentArtifactPolicy` que creó, a continuación, elija **Agregar permisos**.

# Paso 4: Implementación y prueba del componente en un dispositivo principal
<a name="deploy-component-defer-updates"></a>

En esta sección, implementará el componente en el dispositivo principal para probar su funcionalidad. En el dispositivo principal, se crea el archivo de nivel de batería virtual para imitar una batería real. A continuación, debe crear implementaciones adicionales y observar los archivos de registro de los componentes del dispositivo principal para comprobar si el componente se aplaza y confirma las actualizaciones.

**Implementación y prueba del componente Hello World que aplaza las actualizaciones**

1. Use un editor de texto para crear un archivo sobre la batería virtual. Este archivo imita una batería real.
   + En los dispositivos principales de Linux, cree un archivo con el nombre `/home/ggc_user/virtual_battery.json`. Ejecute el editor de texto con permisos `sudo`.
   + En los dispositivos principales de Windows, cree un archivo con el nombre `C:\Users\ggc_user\virtual_battery.json`. Ejecute el editor de texto como administrador.

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   sudo nano /home/ggc_user/virtual_battery.json
   ```

   Copie el siguiente JSON en el archivo.

   ```
   {
     "battery_level": 50
   }
   ```

1. Implemente el componente Hello World en el dispositivo principal. Haga lo siguiente:

   1. En el menú de navegación de la [consola de AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), elija **Componentes**.

   1. En la página **Componentes**, elija la pestaña **Mis componentes** y, a continuación, elija **com.example.BatteryAwareHelloWorld**.

   1. En la página **com.example.BatteryAwareHelloWorld**, elija **Implementar**.

   1. <a name="deploy-component-choose-deployment-step"></a>En **Agregar a la implementación**, elija una implementación existente para revisarla o cree una nueva y, a continuación, elija **Siguiente**.

   1. <a name="deploy-component-choose-target-step"></a>Si opta por crear una nueva implementación, elija el dispositivo principal o el grupo de objetos de destino para la implementación. En la página **Especificar el destino**, en **Destino de la implementación**, elija un dispositivo principal o un grupo de objetos y, a continuación, elija **Siguiente**.

   1. En la página **Seleccionar componentes**, compruebe que el componente **com.example.BatteryAwareHelloWorld** esté seleccionado y elija **Siguiente**.

   1. En la página **Configurar componentes**, seleccione **com.example.BatteryAwareHelloWorld** y haga lo siguiente:

      1. Seleccione **Configurar componente**.

      1. En el cuadro **Configurar com.example.BatteryAwareHelloWorld**, en **Actualización de configuración**, en **Configuración para combinar**, ingrese la siguiente actualización de configuración.

         ```
         {
           "BatteryThreshold": 70
         }
         ```

      1. Elija **Confirmar** para cerrar el cuadro y, a continuación, elija **Siguiente**.

   1. En la página **Confirmar la configuración avanzada**, en la sección **Políticas de implementación**, en **Política de actualización de componentes**, confirme que está seleccionada la opción **Notificar componentes**. La opción **Notificar componentes** está seleccionada de forma predeterminada al crear una nueva implementación.

   1. <a name="deploy-component-review-and-deploy-step"></a>En la página **Revisar**, elija **Implementar**.

      La implementación puede tardar hasta un minuto para completarse.

1. El software AWS IoT Greengrass Core guarda la salida estándar de los procesos de los componentes en los archivos de registro de la `logs` carpeta. Ejecute el siguiente comando para verificar que el componente Hello World ejecuta e imprime los mensajes de estado.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Debería ver mensajes similares al del siguiente ejemplo.

   ```
   Hello, World! Battery level (50) is below threshold (70), so the component will defer updates.
   ```
**nota**  
Si el archivo no existe, es posible que la implementación aún no esté completa. Si el archivo no existe en 30 segundos, es probable que la implementación haya fallado. Esto puede ocurrir si el dispositivo principal no tiene permiso para descargar los artefactos del componente desde el bucket de S3, por ejemplo. Ejecute el siguiente comando para ver el archivo de registro del software 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
   ```
<a name="windows-cmd-type-observe-logs"></a>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. Cree una nueva implementación en el dispositivo principal para comprobar que el componente aplaza la actualización. Haga lo siguiente:

   1. En el menú de navegación de la [consola de AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), elija **Implementaciones**.

   1. Elija la implementación que creó o revisó anteriormente.

   1. En la página de implementación, elija **Revisar**.

   1. En el cuadro **Revisar implementación**, elija **Revisar implementación**.

   1. Elija **Siguiente** en cada paso y, a continuación, elija **Implementar**.

1. Ejecute el siguiente comando para ver de nuevo los registros del componente y comprobar que aplaza la actualización.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Debería ver mensajes similares al del siguiente ejemplo. El componente aplaza la actualización durante 30 segundos, por lo que imprime este mensaje repetidamente.

   ```
   Deferred update for deployment 50722a95-a05f-4e2a-9414-da80103269aa.
   ```

1. Use un editor de texto para editar el archivo de la batería virtual y cambie el nivel de batería a un valor superior al umbral, de modo que la implementación pueda continuar.
   + En los dispositivos principales de Linux, edite el archivo denominado `/home/ggc_user/virtual_battery.json`. Ejecute el editor de texto con permisos `sudo`.
   + En los dispositivos principales de Windows, edite el archivo denominado `C:\Users\ggc_user\virtual_battery.json`. Ejecute el editor de texto como administrador.

   <a name="nano-command-intro"></a>Por ejemplo, en un sistema basado en Linux, puede ejecutar el siguiente comando para usar GNU nano a fin de crear el archivo.

   ```
   sudo nano /home/ggc_user/virtual_battery.json
   ```

   Cambie el nivel de la batería a `80`.

   ```
   {
     "battery_level": 80
   }
   ```

1. Ejecute el siguiente comando para ver de nuevo los registros del componente y comprobar que reconoce la actualización.

------
#### [ Linux or Unix ]

   ```
   sudo tail -f /greengrass/v2/logs/com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ Windows Command Prompt (CMD) ]

   ```
   type C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log
   ```

------
#### [ PowerShell ]

   ```
   gc C:\greengrass\v2\logs\com.example.BatteryAwareHelloWorld.log -Tail 10 -Wait
   ```

------

   Debería ver mensajes similares a los de los siguientes ejemplos.

   ```
   Hello, World! Battery level (80) is above threshold (70), so the component will acknowledge updates.
   Acknowledged update for deployment f9499eb2-4a40-40a7-86c1-c89887d859f1.
   ```

Completó este tutorial. El componente Hello World aplaza o confirma las actualizaciones en función del nivel de batería del dispositivo principal. Para obtener más información sobre lo que se incluye en este tutorial, consulte lo siguiente:
+ [Desarrollo de componentes de AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes en los dispositivos](manage-deployments.md)
+ [Úselo SDK para dispositivos con AWS IoT para comunicarse con el núcleo de Greengrass, otros componentes y AWS IoT CoreComuníquese con el núcleo de Greengrass, otros componentes y AWS IoT Core](interprocess-communication.md)
+ [Interfaz de línea de comandos del kit de desarrollo de AWS IoT Greengrass](greengrass-development-kit-cli.md)