As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tutorial: Desenvolver um componente do Greengrass que adia as atualizações de componentes
<a name="defer-component-updates-tutorial"></a>

Você pode concluir este tutorial para desenvolver um componente que adia as atualizações de over-the-air implantação. Ao implantar atualizações em seus dispositivos, talvez você queira atrasar as atualizações com base em condições, como as seguintes:
+ O dispositivo tem um nível de bateria baixo.
+ O dispositivo está executando um processo ou trabalho que não pode ser interrompido.
+ O dispositivo tem uma conexão de internet limitada ou cara.

**nota**  
Um *componente* é um módulo de software executado em dispositivos AWS IoT Greengrass principais. Os componentes permitem que você crie e gerencie aplicações complexas como componentes básicos que você pode reutilizar de um dispositivo principal do Greengrass para outro.

Neste tutorial, você faz o seguinte:

1. Instale a CLI do kit de desenvolvimento do Greengrass (CLI do GDK) em seu computador de desenvolvimento. A CLI do GDK fornece recursos que ajudam você a desenvolver componentes do Greengrass personalizados.

1. Desenvolva um componente Hello World que adie as atualizações de componentes quando o nível da bateria do dispositivo principal estiver abaixo de um limite. Esse componente se inscreve para atualizar as notificações usando a operação [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. Ao receber a notificação, ele verifica se o nível da bateria está abaixo de um limite personalizável. Se o nível da bateria estiver abaixo do limite, a atualização será adiada por 30 segundos usando a operação [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Você desenvolve esse componente em seu computador de desenvolvimento usando a CLI do GDK.
**nota**  
Esse componente lê o nível da bateria de um arquivo que você cria no dispositivo principal para imitar uma bateria real, para que você possa concluir este tutorial em um dispositivo principal sem bateria.

1. Publique esse componente no AWS IoT Greengrass serviço.

1. Implante esse componente do Nuvem AWS em um dispositivo principal do Greengrass para testá-lo. Em seguida, você modifica o nível da bateria virtual no dispositivo principal e cria implantações adicionais para ver como o dispositivo principal adia as atualizações quando o nível da bateria está baixo.

Você deve levar de 20 a 30 minutos neste tutorial.

# Pré-requisitos
<a name="defer-component-updates-tutorial-prerequisites"></a>

Para concluir este tutorial, você precisará do seguinte:
+ Um Conta da AWS. Se você não tiver uma, consulte [Configurar um Conta da AWS](setting-up.md#set-up-aws-account).
+ Um usuário do AWS Identity and Access Management (IAM) com permissões de administrador.
+ Um dispositivo principal do Greengrass com conexão à internet. Para obter informações sobre como configurar um dispositivo principal, consulte [Configurando dispositivos AWS IoT Greengrass principais](setting-up.md).
  + O [Python](https://www.python.org/downloads/) versão 3.6 ou posterior instalado para todos os usuários no dispositivo principal e adicionado à variável de ambiente `PATH`. No Windows, você também precisa ter o Python Launcher para Windows instalado para todos os usuários.
**Importante**  <a name="windows-core-device-python-installation"></a>
No Windows, por padrão, o Python não é instalado para todos os usuários. Ao instalar o Python, é preciso personalizar a instalação para configurá-la de modo que o software AWS IoT Greengrass Core execute scripts em Python. Por exemplo, se você usar o instalador gráfico do Python, é preciso fazer o seguinte:  
Selecione **Instalar inicializador para todos os usuários (recomendado)**.
Selecione **Customize installation**.
Selecione **Next**.
Selecione **Install for all users**.
Selecione **Add Python to environment variables**.
Escolha **Instalar**.
Para mais informações, consulte [Como usar o Python no Windows](https://docs.python.org/3/using/windows.html) na *documentação do Python 3*.
+ Um computador de desenvolvimento semelhante ao Windows, macOS ou Unix com conexão à Internet.
  + [Python](https://www.python.org/downloads/) 3.6 ou posterior instalado no seu computador de desenvolvimento.
  + O [Git](https://git-scm.com/) instalado no seu computador de desenvolvimento.
  + <a name="development-component-aws-cli-prerequisite"></a>A AWS Command Line Interface(AWS CLI) instalada e configurada com credenciais no computador de desenvolvimento. Para mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Configuração da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) no *Guia do usuário da AWS Command Line Interface*.
**nota**  
Se você usa um Raspberry Pi ou outro dispositivo ARM de 32 bits, instale a AWS CLI V1. AWS CLI A V2 não está disponível para dispositivos ARM de 32 bits. Para obter mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI versão 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html).

# Etapa 1: instalar o kit de desenvolvimento do kit de desenvolvimento do Greengrass Development Kit (CLI) da
<a name="install-gdk-cli-defer-updates"></a>

O [Greengrass Development Kit CLI (GDK CLI)](greengrass-development-kit-cli.md) fornece recursos que ajudam você a desenvolver componentes personalizados do Greengrass. É possível usar a CLI do GDK para criar, construir e publicar componentes personalizados.

Se você não instalou a CLI do GDK em seu computador de desenvolvimento, conclua as etapas a seguir para instalá-la.

**Para instalar a versão mais recente da CLI do GDK**

1. No seu computador de desenvolvimento, execute o comando a seguir para instalar a versão mais recente da CLI do GDK a partir do repositório do [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>Execute o comando a seguir para verificar se a instalação da CLI do GDK foi bem-sucedida.

   ```
   gdk --help
   ```

   Se o comando `gdk` não for encontrado, adicione sua pasta ao PATH.
   + Em dispositivos Linux, adicione `/home/MyUser/.local/bin` ao PATH e substitua *MyUser* pelo nome do seu usuário.
   + Em dispositivos Windows, adicione `PythonPath\\Scripts` ao PATH e substitua *PythonPath* pelo caminho para a pasta Python no seu dispositivo.

# Etapa 2: desenvolver um componente que adia as atualizações
<a name="develop-component-defer-updates"></a>

Nesta seção, você desenvolverá um componente Hello World em Python que adia atualizações de componentes quando o nível da bateria do dispositivo principal estiver abaixo de um limite configurado ao implantar o componente. Neste componente, você usa a [interface de comunicação entre processos (IPC)](interprocess-communication.md) na AWS IoT Device SDK v2 para Python. Você usa a operação [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC para receber notificações quando o dispositivo principal recebe uma implantação. Em seguida, você usa a operação [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC para adiar ou confirmar a atualização com base no nível da bateria do dispositivo.

**Para desenvolver um componente Hello World que adie atualizações**

1. No seu computador de desenvolvimento, crie uma pasta para o código-fonte do componente.

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

1. Use um editor de texto para criar um arquivo chamado `gdk-config.json`. A CLI do GDK lê o [arquivo de configuração da CLI do GDK](gdk-cli-configuration-file.md), chamado `gdk-config.json`, para criar e publicar componentes. Esse arquivo de configuração existe na raiz da pasta do componente.

   <a name="nano-command-intro"></a>Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

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

   Copie o seguinte JSON no arquivo.
   + *Amazon*Substitua pelo seu nome.
   + *us-west-2*Substitua pelo Região da AWS local em que seu dispositivo principal opera. A CLI do GDK publica este componente nessa Região da AWS.
   + *greengrass-component-artifacts*Substitua pelo prefixo do bucket do S3 a ser usado. Quando você usa a CLI do GDK para publicar o componente, a CLI do GDK carrega os artefatos do componente para o bucket do S3 cujo nome é formado por esse valor, o, e seu ID usando Região da AWS o seguinte formato:. Conta da AWS `bucketPrefix-region-accountId`

     Por exemplo, se você especificar **greengrass-component-artifacts** e**us-west-2**, e seu Conta da AWS ID for**123456789012**, a CLI do GDK usará o bucket do S3 chamado. `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"
   }
   ```

   O arquivo de configuração especifica o seguinte:
   + A versão a ser usada quando a CLI do GDK publica o componente Greengrass no serviço de nuvem. AWS IoT Greengrass `NEXT_PATCH`especifica a escolha da próxima versão do patch após a versão mais recente disponível no serviço de AWS IoT Greengrass nuvem. Se o componente ainda não tiver uma versão no serviço de AWS IoT Greengrass nuvem, a `1.0.0` CLI do GDK usará.
   + O sistema de compilação do componente. Quando você usa o sistema de compilação `zip`, a CLI do GDK empacota a fonte do componente em um arquivo ZIP que se torna o único artefato do componente.
   + O Região da AWS local onde a CLI do GDK publica o componente Greengrass.
   + O prefixo do bucket do S3 em que a CLI do GDK faz o upload dos artefatos do componente.

1. Use um editor de texto para criar o código-fonte do componente em um arquivo chamado `main.py`.

   <a name="nano-command-intro"></a>Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

   ```
   nano main.py
   ```

   Copie o código Python a seguir no arquivo.

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

   Essa aplicação Python faz o seguinte:
   + Lê o nível da bateria do dispositivo principal a partir de um arquivo virtual de nível de bateria que você criará posteriormente no dispositivo principal. Esse arquivo virtual de nível de bateria imita uma bateria real, então você pode concluir este tutorial em dispositivos principais que não têm bateria.
   + Lê os argumentos da linha de comando para o limite da bateria e o caminho para o arquivo virtual do nível da bateria. A fórmula do componente define esses argumentos de linha de comando com base nos parâmetros de configuração, para que você possa personalizar esses valores ao implantar o componente.
   + Usa o cliente IPC V2 na [AWS IoT Device SDK v2 para Python para](https://github.com/aws/aws-iot-device-sdk-python-v2) se comunicar com o software Core. AWS IoT Greengrass Em comparação com o cliente de IPC original, o cliente V2 de IPC reduz a quantidade de código que você precisa escrever para usar o IPC em componentes personalizados.
   + Se inscreve para atualizar as notificações usando a operação [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. O software AWS IoT Greengrass Core envia notificações antes e depois de cada implantação. O componente chama a função a seguir sempre que recebe uma notificação. Se a notificação for para uma implantação futura, o componente verificará se o nível da bateria está abaixo do limite. Se o nível da bateria estiver abaixo do limite, o componente adia a atualização por 30 segundos usando a operação [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Caso contrário, se o nível da bateria não estiver abaixo do limite, o componente confirma a atualização, para que ela possa 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**  
O software AWS IoT Greengrass Core não envia notificações de atualização para implantações locais, então você implanta esse componente usando o serviço de AWS IoT Greengrass nuvem para testá-lo.

1. Use um editor de texto para criar a fórmula do componente em um arquivo chamado `recipe.json` ou `recipe.yaml`. A *fórmula* do componente define os metadados do componente, os parâmetros de configuração padrão e os scripts de ciclo de vida específicos da plataforma.

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

   <a name="nano-command-intro"></a>Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

   ```
   nano recipe.json
   ```

   Copie o JSON a seguir no arquivo.

   ```
   {
     "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 exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

   ```
   nano recipe.yaml
   ```

   Copie o seguinte YAML no arquivo .

   ```
   ---
   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 fórmula especifica o seguinte:
   + Os parâmetros de configuração padrão para o limite da bateria, o caminho do arquivo da bateria virtual nos dispositivos principais do Linux e o caminho do arquivo da bateria virtual nos dispositivos principais do Windows.
   + Um ciclo de vida `install` que instala a versão mais recente do AWS IoT Device SDK v2 para Python.
   + Um ciclo de vida `run` que executa a aplicação Python em `main.py`.
   + Espaços reservados, como `COMPONENT_NAME` e `COMPONENT_VERSION`, em que a CLI do GDK substitui as informações ao criar a fórmula do componente.

   Para ter mais informações sobre fórmulas de componentes, consulte [AWS IoT Greengrass referência da receita do componente](component-recipe-reference.md).

# Etapa 3: publicar o componente no AWS IoT Greengrass serviço
<a name="publish-component-defer-updates"></a>

Nesta seção, você publica o componente Hello World no serviço de AWS IoT Greengrass nuvem. Depois que um componente estiver disponível no serviço de AWS IoT Greengrass nuvem, você poderá implantá-lo nos dispositivos principais. Você usa a CLI do GDK para publicar o componente do seu computador de desenvolvimento no serviço de nuvem AWS IoT Greengrass . A CLI do GDK carrega a fórmula e os artefatos do componente para você.

**Para publicar o componente Hello World no AWS IoT Greengrass serviço**

1. Execute o seguinte comando para compilar o componente usando a CLI do GDK. O [comando de construção do componente](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) cria uma fórmula e artefatos com base no arquivo de configuração da CLI do GDK. Nesse processo, a CLI do GDK cria um arquivo ZIP que contém o código-fonte do componente.

   ```
   gdk component build
   ```

   Você verá mensagens semelhantes ao exemplo a seguir.

   ```
   [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. Execute o comando a seguir para publicar o componente no serviço de AWS IoT Greengrass nuvem. O [comando de publicação do componente](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) carrega o artefato do arquivo ZIP do componente em um bucket do S3. Em seguida, ele atualiza o URI S3 do arquivo ZIP na fórmula do componente e carrega a fórmula no serviço do AWS IoT Greengrass . Nesse processo, a CLI do GDK verifica qual versão do componente Hello World já está disponível AWS IoT Greengrass no serviço de nuvem, para que possa escolher a próxima versão do patch após essa versão. Se o componente ainda não existir, a CLI do GDK usa a versão `1.0.0`.

   ```
   gdk component publish
   ```

   Você verá mensagens semelhantes ao exemplo a seguir. A saída informa a versão do componente que a CLI do GDK criou.

   ```
   [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 o nome do bucket do S3 da saída. Você usa o nome do bucket posteriormente para permitir que o dispositivo principal baixe artefatos de componentes desse bucket.

1. (Opcional) Visualize o componente no AWS IoT Greengrass console para verificar se ele foi carregado com êxito. Faça o seguinte:

   1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Componentes**.

   1. Na página **Componentes**, escolha a guia **Meus componentes** e, em seguida, escolha **com.example.BatteryAwareHelloWorld**.

      Nesta página, você pode ver a fórmula do componente e outras informações sobre o componente.

1. <a name="core-device-allow-s3-bucket-access-console-intro-1"></a>Permita que o dispositivo principal acesse os artefatos do componente no bucket do S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-2"></a>Cada dispositivo principal tem uma [função de IAM do dispositivo principal](device-service-role.md) que permite interagir AWS IoT e enviar registros para a AWS nuvem. Essa função de dispositivo não permite acesso aos buckets do S3 por padrão, então você deve criar e anexar uma política que permita que o dispositivo principal recupere artefatos do componente do bucket do S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-3"></a>Se a função do seu dispositivo já permitir o acesso ao bucket do S3, você pode ignorar essa etapa. Caso contrário, crie uma política do IAM que permita acesso e anexe-a à função, da seguinte forma:

   1. <a name="core-device-allow-s3-bucket-access-console-step-1"></a>No menu de navegação do [console do IAM](https://console.aws.amazon.com/iam), escolha **Políticas** e **Criar política**.

   1. Na guia **JSON**, substitua o conteúdo do espaço reservado pela política a seguir. *greengrass-component-artifacts-us-west-2-123456789012*Substitua pelo nome do bucket do S3 em que a CLI do GDK fez o upload dos artefatos do componente.

      Por exemplo, se você especificou **greengrass-component-artifacts** e **us-west-2** no arquivo de configuração da CLI do GDK e o Conta da AWS ID da sua é **123456789012**, a CLI do GDK usa o bucket do S3 chamado `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>Escolha **Próximo**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-4"></a>Na **seção Detalhes da política**, insira **MyGreengrassV2ComponentArtifactPolicy** em **Nome**.

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

   1. <a name="core-device-allow-s3-bucket-access-console-step-6"></a>No menu de navegação do [console do IAM](https://console.aws.amazon.com/iam), escolha **Role** e, em seguida, escolha o nome da função para o dispositivo principal. Você especificou esse nome de função ao instalar o software AWS IoT Greengrass Core. Se você não especificou um nome, o padrão é `GreengrassV2TokenExchangeRole`.

   1. <a name="core-device-allow-s3-bucket-access-console-step-7"></a>Em **Permissões**, escolha **Adicionar permissões** e **Anexar políticas**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-8"></a>Na página **Adicionar permissões**, marque a caixa de seleção ao lado da política `MyGreengrassV2ComponentArtifactPolicy` que você criou e escolha **Adicionar permissões**.

# Etapa 4: implantar e testar o componente em um dispositivo principal
<a name="deploy-component-defer-updates"></a>

Nesta seção, você implanta o componente no dispositivo principal para testar a funcionalidade dele. No dispositivo principal, você cria o arquivo virtual do nível da bateria para imitar uma bateria real. Em seguida, você cria implantações adicionais e observa os arquivos de log do componente no dispositivo principal para ver o componente adiar e confirmar as atualizações.

**Para implantar e testar o componente Hello World que adia as atualizações**

1. Use um editor de texto para criar um arquivo virtual do nível da bateria. Este arquivo imita uma bateria real.
   + Nos dispositivos principais do Linux, crie um arquivo chamado `/home/ggc_user/virtual_battery.json`. Execute o editor de texto com permissões `sudo`.
   + Nos dispositivos principais do Windows, crie um arquivo chamado `C:\Users\ggc_user\virtual_battery.json`. Execute o editor de texto como administrador.

   <a name="nano-command-intro"></a>Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

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

   Copie o JSON a seguir no arquivo.

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

1. Implante o componente Hello World no dispositivo principal. Faça o seguinte:

   1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Componentes**.

   1. Na página **Componentes**, escolha a guia **Meus componentes** e depois **com.example.BatteryAwareHelloWorld**.

   1. Na página **com.example.BatteryAwareHelloWorld**, escolha **Implantar**.

   1. <a name="deploy-component-choose-deployment-step"></a>Em **Adicionar à implantação**, escolha uma implantação existente para revisar ou opte por criar uma nova e, em seguida, escolha **Avançar**.

   1. <a name="deploy-component-choose-target-step"></a>Se você criar uma nova implantação, escolha o dispositivo principal ou grupo de objetos de destino para ela. Na página **Especificar destino**, em **Destino de implantação**, escolha um dispositivo principal ou grupo de objetos e, depois, **Avançar**.

   1. Na página **Selecionar componentes**, verifique se o componente **com.example.BatteryAwareHelloWorld** está selecionado e escolha **Avançar**.

   1. Na página **Configurar componentes**, selecione **com.example.BatteryAwareHelloWorld** e faça o seguinte:

      1. Escolha **Configurar componente**.

      1. No modal **Configurar com.example.BatteryAwareHelloWorld**, em **Atualização de configuração**, em **Configuração para mesclar**, insira a seguinte atualização de configuração.

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

      1. Selecione **Confirmar** para fechar o modal e, em seguida, **Avançar**.

   1. Na página **Confirmar configurações avançadas**, na seção **Políticas de implantação**, em **Política de atualização de componentes**, confirme se a opção **Notificar componentes** está selecionada. A opção **Notificar componentes** é selecionada por padrão quando você cria uma nova implantação.

   1. <a name="deploy-component-review-and-deploy-step"></a>Na página **Pré-visualizar**, escolha **Implantar**.

      A implantação pode levar até um minuto para ser concluída.

1. O software AWS IoT Greengrass Core salva o stdout dos processos dos componentes em arquivos de log na `logs` pasta. Execute o comando a seguir para verificar se o componente Hello World executa e imprime mensagens de status.

------
#### [ 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
   ```

------

   Você verá mensagens semelhantes ao exemplo a seguir.

   ```
   Hello, World! Battery level (50) is below threshold (70), so the component will defer updates.
   ```
**nota**  
Se o arquivo não existir, talvez a implantação ainda não esteja concluída. Se o arquivo não existir em 30 segundos, a implantação provavelmente falhou. Isso pode ocorrer se o dispositivo principal não tiver permissão para baixar os artefatos do componente do bucket do S3, por exemplo. Execute o comando a seguir para visualizar o arquivo de log do software AWS IoT Greengrass principal. Esse arquivo inclui logs do serviço de implantação do dispositivo principal do Greengrass.  

   ```
   sudo tail -f /greengrass/v2/logs/greengrass.log
   ```

   ```
   type C:\greengrass\v2\logs\greengrass.log
   ```
<a name="windows-cmd-type-observe-logs"></a>O comando `type` grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.

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

1. Crie uma nova implantação no dispositivo principal para verificar se o componente adia a atualização. Faça o seguinte:

   1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Implantações.**

   1. Escolha a implantação que você criou ou revisou anteriormente.

   1. Na página da implantação, escolha **Revisar**.

   1. No modal **Revisar implantação**, selecione **Revisar implantação**.

   1. Selecione **Avançar** em cada etapa e depois **Implantar**.

1. Execute o comando a seguir para visualizar os logs do componente novamente e verificar se ele adia a atualização.

------
#### [ 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
   ```

------

   Você verá mensagens semelhantes ao exemplo a seguir. O componente adia a atualização por 30 segundos, então o componente imprime essa mensagem repetidamente.

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

1. Use um editor de texto para editar o arquivo virtual do nível da bateria e alterar o nível da bateria para um valor acima do limite, para que a implantação possa continuar.
   + Nos dispositivos principais do Linux, edite o arquivo chamado `/home/ggc_user/virtual_battery.json`. Execute o editor de texto com permissões `sudo`.
   + Nos dispositivos principais do Windows, edite o arquivo chamado `C:\Users\ggc_user\virtual_battery.json`. Execute o editor de texto como administrador.

   <a name="nano-command-intro"></a>Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.

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

   Altere o nível da bateria para `80`.

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

1. Execute o seguinte comando para visualizar os logs do componente novamente e verificar se ele reconhece a atualização.

------
#### [ 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
   ```

------

   Você verá mensagens semelhantes aos exemplos a seguir.

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

Você concluiu este tutorial. O componente Hello World adia ou confirma as atualizações com base no nível da bateria do dispositivo principal. Para obter mais informações sobre os tópicos deste tutorial, consulte o seguinte:
+ [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)
+ [Use o AWS IoT Device SDK para se comunicar com o núcleo do Greengrass, outros componentes e AWS IoT CoreComunique-se com o núcleo do Greengrass, outros componentes e AWS IoT Core](interprocess-communication.md)
+ [Interface de linha de comando do kit de desenvolvimento do AWS IoT Greengrass](greengrass-development-kit-cli.md)