Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial: Sviluppa un componente Greengrass che rinvii gli aggiornamenti dei componenti
<a name="defer-component-updates-tutorial"></a>

Puoi completare questo tutorial per sviluppare un componente che differisca gli aggiornamenti della over-the-air distribuzione. Quando distribuisci aggiornamenti sui tuoi dispositivi, potresti voler ritardare gli aggiornamenti in base a condizioni, come le seguenti:
+ Il dispositivo ha un livello di batteria basso.
+ Il dispositivo sta eseguendo un processo o un processo che non può essere interrotto.
+ Il dispositivo dispone di una connessione Internet limitata o costosa.

**Nota**  
Un *componente* è un modulo software che viene eseguito sui dispositivi AWS IoT Greengrass principali. I componenti consentono di creare e gestire applicazioni complesse come elementi costitutivi discreti che puoi riutilizzare da un dispositivo core Greengrass a un altro.

In questo tutorial, esegui quanto indicato di seguito:

1. Installa il Greengrass Development Kit CLI (GDK CLI) sul tuo computer di sviluppo. La CLI di GDK fornisce funzionalità che aiutano a sviluppare componenti Greengrass personalizzati.

1. Sviluppa un componente Hello World che rinvii gli aggiornamenti dei componenti quando il livello della batteria del dispositivo principale è inferiore a una soglia. Questo componente sottoscrive le notifiche di aggiornamento utilizzando l'operazione [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC. Quando riceve la notifica, verifica se il livello della batteria è inferiore a una soglia personalizzabile. Se il livello della batteria è inferiore alla soglia, posticipa l'aggiornamento di 30 secondi utilizzando l'operazione [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Sviluppi questo componente sul tuo computer di sviluppo utilizzando la CLI GDK.
**Nota**  
Questo componente legge il livello della batteria da un file creato sul dispositivo principale per imitare una batteria reale, quindi puoi completare questo tutorial su un dispositivo principale senza batteria.

1. Pubblica quel componente nel AWS IoT Greengrass servizio.

1. Distribuisci quel componente Cloud AWS da un dispositivo principale Greengrass per testarlo. Quindi, modifichi il livello virtuale della batteria sul dispositivo principale e crei implementazioni aggiuntive per vedere in che modo il dispositivo principale posticipa gli aggiornamenti quando il livello della batteria è basso.

Puoi aspettarti di dedicare 20-30 minuti a questo tutorial.

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

Per completare questo tutorial, è necessario quanto segue:
+ Un Account AWS. Se non lo hai, consultare [Configura un Account AWS](setting-up.md#set-up-aws-account).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore.
+ Un dispositivo core Greengrass con una connessione Internet. Per ulteriori informazioni su come configurare un dispositivo principale, vedere[Configurazione dei dispositivi AWS IoT Greengrass principali](setting-up.md).
  + [Python](https://www.python.org/downloads/) 3.6 o successivo installato per tutti gli utenti sul dispositivo principale e aggiunto alla `PATH` variabile di ambiente. Su Windows, è inoltre necessario che Python Launcher per Windows sia installato per tutti gli utenti.
**Importante**  <a name="windows-core-device-python-installation"></a>
In Windows, Python non viene installato per tutti gli utenti per impostazione predefinita. Quando installi Python, devi personalizzare l'installazione per configurarla affinché il software AWS IoT Greengrass Core esegua gli script Python. Ad esempio, se usi il programma di installazione grafico di Python, procedi come segue:  
Seleziona **Installa il programma di avvio per tutti gli utenti** (consigliato).
Scegliere **Customize installation**.
Scegliere **Next**.
Selezionare **Install for all users**.
Selezionare **Add Python to environment variables**.
Scegli **Installa**.
Per ulteriori informazioni, consulta [Usare Python su Windows nella documentazione](https://docs.python.org/3/using/windows.html) di *Python* 3.
+ Un computer di sviluppo simile a Windows, macOS o UNIX con una connessione Internet.
  + [Python](https://www.python.org/downloads/) 3.6 o versione successiva installato sul computer di sviluppo.
  + [Git](https://git-scm.com/) installato sul tuo computer di sviluppo.
  + <a name="development-component-aws-cli-prerequisite"></a>AWS Command Line Interface (AWS CLI) installato e configurato con credenziali sul computer di sviluppo. *Per ulteriori informazioni, vedere [Installazione, aggiornamento e disinstallazione AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione di AWS CLI nella Guida per l'](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)utente.AWS Command Line Interface *
**Nota**  
Se utilizzi un Raspberry Pi o un altro dispositivo ARM a 32 bit, installa V1. AWS CLI AWS CLI La V2 non è disponibile per i dispositivi ARM a 32 bit. Per ulteriori informazioni, vedere [Installazione, aggiornamento e disinstallazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html) versione 1.

# Fase 1: Installazione della CLI del Greengrass Development Kit
<a name="install-gdk-cli-defer-updates"></a>

Il [Greengrass Development Kit CLI (GDK CLI)](greengrass-development-kit-cli.md) fornisce funzionalità che aiutano a sviluppare componenti Greengrass personalizzati. Puoi usare la CLI GDK per creare, creare e pubblicare componenti personalizzati.

Se non hai installato la CLI GDK sul tuo computer di sviluppo, completa i seguenti passaggi per installarla.

**Per installare l'ultima versione della CLI GDK**

1. [Sul tuo computer di sviluppo, esegui il comando seguente per installare l'ultima versione della CLI GDK dal GitHub suo repository.](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>Esegui il comando seguente per verificare che la CLI GDK sia stata installata correttamente.

   ```
   gdk --help
   ```

   Se il `gdk` comando non viene trovato, aggiungi la sua cartella a PATH.
   + Sui dispositivi Linux, aggiungilo `/home/MyUser/.local/bin` a PATH e sostituiscilo *MyUser* con il nome dell'utente.
   + Sui dispositivi Windows, aggiungi `PythonPath\\Scripts` a PATH e sostituisci *PythonPath* con il percorso della cartella Python sul tuo dispositivo.

# Fase 2: Sviluppare un componente che differisca gli aggiornamenti
<a name="develop-component-defer-updates"></a>

In questa sezione, sviluppi un componente Hello World in Python che posticipa gli aggiornamenti dei componenti quando il livello della batteria del dispositivo principale è inferiore a una soglia configurata quando distribuisci il componente. In questo componente, si utilizza l'[interfaccia di comunicazione tra processi (IPC) nella versione](interprocess-communication.md) 2 SDK per dispositivi AWS IoT per Python. Si utilizza l'operazione [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates)IPC per ricevere notifiche quando il dispositivo principale riceve una distribuzione. Quindi, si utilizza l'operazione [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC per posticipare o confermare l'aggiornamento in base al livello della batteria del dispositivo.

**Sviluppare un componente Hello World che posticipi gli aggiornamenti**

1. Sul tuo computer di sviluppo, crea una cartella per il codice sorgente del componente.

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

1. Utilizzate un editor di testo per creare un file denominato`gdk-config.json`. La CLI GDK legge dal file di [configurazione GDK CLI](gdk-cli-configuration-file.md), `gdk-config.json` denominato, per creare e pubblicare componenti. Questo file di configurazione esiste nella radice della cartella del componente.

   <a name="nano-command-intro"></a>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Copiate il seguente codice JSON nel file.
   + *Amazon*Sostituiscilo con il tuo nome.
   + *us-west-2*Sostituiscilo con il Regione AWS luogo in cui funziona il tuo dispositivo principale. La CLI GDK pubblica il componente in questo. Regione AWS
   + *greengrass-component-artifacts*Sostituiscilo con il prefisso del bucket S3 da usare. Quando usi la CLI di GDK per pubblicare il componente, la CLI di GDK carica gli artefatti del componente nel bucket S3 il cui nome è formato da questo valore, Regione AWS dal e dal tuo ID utilizzando il seguente formato:. Account AWS `bucketPrefix-region-accountId`

     Ad esempio, se specifichi **greengrass-component-artifacts** and e **us-west-2** il tuo Account AWS ID è**123456789012**, la CLI di GDK utilizza il bucket S3 denominato. `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"
   }
   ```

   Il file di configurazione specifica quanto segue:
   + La versione da utilizzare quando la CLI di GDK pubblica il componente Greengrass nel servizio cloud. AWS IoT Greengrass `NEXT_PATCH`specifica di scegliere la versione della patch successiva all'ultima versione disponibile nel servizio cloud. AWS IoT Greengrass Se il componente non ha ancora una versione nel servizio AWS IoT Greengrass cloud, utilizza la `1.0.0` CLI di GDK.
   + Il sistema di compilazione del componente. Quando si utilizza il sistema di `zip` compilazione, la CLI GDK impacchetta il codice sorgente del componente in un file ZIP che diventa il singolo artefatto del componente.
   + Il Regione AWS punto in cui la CLI di GDK pubblica il componente Greengrass.
   + Il prefisso per il bucket S3 in cui la CLI di GDK carica gli artefatti del componente.

1. Utilizzate un editor di testo per creare il codice sorgente del componente in un file denominato. `main.py`

   <a name="nano-command-intro"></a>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

   ```
   nano main.py
   ```

   Copia il seguente codice Python nel file.

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

   Questa applicazione Python esegue le seguenti operazioni:
   + Legge il livello della batteria del dispositivo principale da un file virtuale del livello di batteria che creerai successivamente sul dispositivo principale. Questo file virtuale del livello della batteria imita una batteria reale, quindi puoi completare questo tutorial sui dispositivi principali che non dispongono di batteria.
   + Legge gli argomenti della riga di comando per la soglia della batteria e il percorso del file virtuale del livello della batteria. La ricetta del componente imposta questi argomenti della riga di comando in base ai parametri di configurazione, in modo da poter personalizzare questi valori quando si distribuisce il componente.
   + Utilizza il client IPC V2 nella versione 2 [SDK per dispositivi AWS IoT per Python per](https://github.com/aws/aws-iot-device-sdk-python-v2) comunicare con il software Core. AWS IoT Greengrass Rispetto al client IPC originale, il client IPC V2 riduce la quantità di codice da scrivere per utilizzare IPC nei componenti personalizzati.
   + Si iscrive alle notifiche di aggiornamento utilizzando l'operazione IPC. [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates) Il software AWS IoT Greengrass Core invia notifiche prima e dopo ogni implementazione. Il componente richiama la seguente funzione ogni volta che riceve una notifica. Se la notifica riguarda una distribuzione imminente, il componente verifica se il livello della batteria è inferiore a una soglia. Se il livello della batteria è inferiore alla soglia, il componente posticipa l'aggiornamento di 30 secondi utilizzando l'operazione [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate)IPC. Altrimenti, se il livello della batteria non è inferiore alla soglia, il componente riconosce l'aggiornamento, quindi l'aggiornamento può procedere.

     ```
     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**  
Il software AWS IoT Greengrass Core non invia notifiche di aggiornamento per le distribuzioni locali, quindi distribuisci questo componente utilizzando il servizio AWS IoT Greengrass cloud per testarlo.

1. Utilizza un editor di testo per creare la ricetta del componente in un file denominato o. `recipe.json` `recipe.yaml` La *ricetta* del componente definisce i metadati del componente, i parametri di configurazione predefiniti e gli script del ciclo di vita specifici della piattaforma.

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

   <a name="nano-command-intro"></a>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

   ```
   nano recipe.json
   ```

   Copiate il seguente codice JSON nel file.

   ```
   {
     "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>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

   ```
   nano recipe.yaml
   ```

   Copiate il seguente codice YAML nel file.

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

------

   Questa ricetta specifica quanto segue:
   + Parametri di configurazione predefiniti per la soglia della batteria, il percorso del file della batteria virtuale sui dispositivi core Linux e il percorso del file della batteria virtuale sui dispositivi core Windows.
   + Un `install` ciclo di vita che installa l'ultima versione della SDK per dispositivi AWS IoT v2 per Python.
   + Un `run` ciclo di vita in cui viene eseguita l'applicazione Python. `main.py`
   + Segnaposti, come `COMPONENT_NAME` e`COMPONENT_VERSION`, dove la CLI GDK sostituisce le informazioni quando crea la ricetta del componente.

   Per ulteriori informazioni sulle ricette dei componenti, consulta. [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md)

# Fase 3: Pubblicare il componente nel AWS IoT Greengrass servizio
<a name="publish-component-defer-updates"></a>

In questa sezione, pubblichi il componente Hello World nel servizio AWS IoT Greengrass cloud. Dopo che un componente è disponibile nel servizio AWS IoT Greengrass cloud, puoi distribuirlo sui dispositivi principali. Utilizzi la CLI GDK per pubblicare il componente dal tuo computer di sviluppo AWS IoT Greengrass al servizio cloud. La CLI di GDK carica la ricetta e gli artefatti del componente per te.

**Per pubblicare il componente Hello World nel servizio AWS IoT Greengrass**

1. Esegui il comando seguente per creare il componente utilizzando la CLI GDK. Il [comando component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) crea una ricetta e artefatti basati sul file di configurazione GDK CLI. In questo processo, la CLI GDK crea un file ZIP che contiene il codice sorgente del componente.

   ```
   gdk component build
   ```

   Dovreste vedere messaggi simili a quelli dell'esempio seguente.

   ```
   [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. Esegui il comando seguente per pubblicare il componente nel servizio AWS IoT Greengrass cloud. Il [comando component publish](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) carica l'elemento del file ZIP del componente in un bucket S3. Quindi, aggiorna l'URI S3 del file ZIP nella ricetta del componente e carica la ricetta sul servizio. AWS IoT Greengrass In questo processo, la CLI di GDK verifica quale versione del componente Hello World è già disponibile nel servizio cloud, in AWS IoT Greengrass modo da poter scegliere la versione della patch successiva a quella versione. Se il componente non esiste ancora, la CLI di GDK utilizza la versione. `1.0.0`

   ```
   gdk component publish
   ```

   Dovreste vedere messaggi simili all'esempio seguente. L'output indica la versione del componente creata dalla CLI 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. Copia il nome del bucket S3 dall'output. Utilizzerai il nome del bucket in un secondo momento per consentire al dispositivo principale di scaricare gli artefatti dei componenti da questo bucket.

1. (Facoltativo) Visualizza il componente nella AWS IoT Greengrass console per verificare che sia stato caricato correttamente. Esegui questa operazione:

   1. Nel menu di navigazione della [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), scegli **Componenti**.

   1. Nella pagina **Componenti**, scegli la scheda **I miei componenti**, quindi scegli **com.example.BatteryAwareHelloWorld**.

      In questa pagina, puoi vedere la ricetta del componente e altre informazioni sul componente.

1. <a name="core-device-allow-s3-bucket-access-console-intro-1"></a>Consenti al dispositivo principale di accedere agli artefatti dei componenti nel bucket S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-2"></a>Ogni dispositivo principale ha un [ruolo IAM del dispositivo principale](device-service-role.md) che gli consente di interagire AWS IoT e inviare log al cloud. AWS Per impostazione predefinita, questo ruolo del dispositivo non consente l'accesso ai bucket S3, quindi è necessario creare e allegare una policy che consenta al dispositivo principale di recuperare gli artefatti dei componenti dal bucket S3.

   <a name="core-device-allow-s3-bucket-access-console-intro-3"></a>Se il ruolo del tuo dispositivo consente già l'accesso al bucket S3, puoi saltare questo passaggio. Altrimenti, crea una policy IAM che consenta l'accesso e collegala al ruolo, come segue:

   1. <a name="core-device-allow-s3-bucket-access-console-step-1"></a>**Nel menu di navigazione [della console IAM](https://console.aws.amazon.com/iam), scegli Policies, quindi scegli **Crea policy**.**

   1. Nella scheda **JSON**, sostituire il contenuto del segnaposto con la seguente policy. Sostituisci *greengrass-component-artifacts-us-west-2-123456789012* con il nome del bucket S3 in cui la CLI di GDK ha caricato gli artefatti del componente.

      Ad esempio, se hai specificato **greengrass-component-artifacts** and **us-west-2** nel file di configurazione della CLI di GDK e Account AWS il tuo ID **123456789012** è, la CLI di GDK utilizza il bucket S3 denominato. `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>Scegli **Next (Successivo)**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-4"></a>**Nella **sezione Dettagli della politica**, per Nome, inserisci.** **MyGreengrassV2ComponentArtifactPolicy**

   1. <a name="core-device-allow-s3-bucket-access-console-step-5"></a>Scegli **Crea policy**.

   1. <a name="core-device-allow-s3-bucket-access-console-step-6"></a>Nel menu di navigazione della [console IAM](https://console.aws.amazon.com/iam), scegli **Ruolo**, quindi scegli il nome del ruolo per il dispositivo principale. Hai specificato questo nome di ruolo quando hai installato il software AWS IoT Greengrass Core. Se non hai specificato un nome, l'impostazione predefinita è`GreengrassV2TokenExchangeRole`.

   1. <a name="core-device-allow-s3-bucket-access-console-step-7"></a>In **Autorizzazioni**, scegli **Aggiungi autorizzazioni**, quindi scegli **Allega** politiche.

   1. <a name="core-device-allow-s3-bucket-access-console-step-8"></a>**Nella pagina **Aggiungi autorizzazioni**, seleziona la casella di controllo accanto alla `MyGreengrassV2ComponentArtifactPolicy` politica che hai creato, quindi scegli Aggiungi autorizzazioni.**

# Fase 4: Implementazione e test del componente su un dispositivo principale
<a name="deploy-component-defer-updates"></a>

In questa sezione, distribuisci il componente sul dispositivo principale per testarne la funzionalità. Sul dispositivo principale, crei il file virtuale del livello della batteria per imitare una batteria reale. Quindi, crei distribuzioni aggiuntive e osservi i file di registro dei componenti sul dispositivo principale per verificare che il componente rinvii e confermi gli aggiornamenti.

**Per distribuire e testare il componente Hello World che posticipa gli aggiornamenti**

1. Usa un editor di testo per creare un file virtuale del livello della batteria. Questo file imita una batteria reale.
   + Sui dispositivi principali Linux, crea un file denominato`/home/ggc_user/virtual_battery.json`. Esegui l'editor di testo con `sudo` autorizzazioni.
   + Sui dispositivi Windows principali, crea un file denominato`C:\Users\ggc_user\virtual_battery.json`. Esegui l'editor di testo come amministratore.

   <a name="nano-command-intro"></a>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Copiate il seguente codice JSON nel file.

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

1. Distribuisci il componente Hello World sul dispositivo principale. Esegui questa operazione:

   1. Nel menu di navigazione [AWS IoT Greengrass della console](https://console.aws.amazon.com/greengrass), scegli **Componenti**.

   1. Nella pagina **Componenti**, scegli la scheda **I miei componenti**, quindi scegli **com.example.BatteryAwareHelloWorld**.

   1. Nella pagina **com.example.BatteryAwareHelloWorld**, scegli **(Distribuisci)**.

   1. <a name="deploy-component-choose-deployment-step"></a>Da **Aggiungi alla distribuzione**, scegli una distribuzione esistente da modificare oppure scegli di creare una nuova distribuzione, quindi scegli **Avanti**.

   1. <a name="deploy-component-choose-target-step"></a>Se hai scelto di creare una nuova distribuzione, scegli il dispositivo principale o il gruppo di oggetti di destinazione per la distribuzione. Nella pagina **Specificare la destinazione**, in **Obiettivo di distribuzione**, scegli un dispositivo principale o un gruppo di oggetti, quindi scegli **Avanti**.

   1. Nella pagina **Seleziona componenti**, verifica che il **com.example.BatteryAwareHelloWorld**componente sia selezionato, scegli **Avanti**.

   1. Nella pagina **Configura componenti **com.example.BatteryAwareHelloWorld****, selezionate e quindi effettuate le seguenti operazioni:

      1. Scegli **Configura componente**.

      1. Nella com.example.BatteryAwareHelloWorld modalità **Configura**, in **Aggiornamento della configurazione**, in **Configurazione da unire**, inserisci il seguente aggiornamento di configurazione.

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

      1. **Scegli **Conferma** per chiudere la modalità, quindi scegli Avanti.**

   1. Nella pagina **Conferma impostazioni avanzate**, nella sezione **Criteri di distribuzione**, in **Politica di aggiornamento dei componenti**, conferma che sia selezionata l'opzione **Notifica componenti**. L'opzione **Notifica componenti** è selezionata per impostazione predefinita quando si crea una nuova distribuzione.

   1. <a name="deploy-component-review-and-deploy-step"></a>Nella pagina **Review (Verifica)**, scegli **Deploy (Distribuisci)**.

      Il completamento della distribuzione può richiedere fino a un minuto.

1. Il software AWS IoT Greengrass Core salva lo stdout dai processi dei componenti nei file di registro nella `logs` cartella. Eseguite il comando seguente per verificare che il componente Hello World venga eseguito e stampi i messaggi di stato.

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

------

   Dovreste vedere messaggi simili a quelli dell'esempio seguente.

   ```
   Hello, World! Battery level (50) is below threshold (70), so the component will defer updates.
   ```
**Nota**  
Se il file non esiste, la distribuzione potrebbe non essere ancora completa. Se il file non esiste entro 30 secondi, è probabile che la distribuzione non sia riuscita. Ciò può verificarsi, ad esempio, se il dispositivo principale non è autorizzato a scaricare gli elementi del componente dal bucket S3. Esegui il comando seguente per visualizzare il file di registro del software AWS IoT Greengrass Core. Questo file include i log del servizio di distribuzione del dispositivo principale Greengrass.  

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

   ```
   type C:\greengrass\v2\logs\greengrass.log
   ```
<a name="windows-cmd-type-observe-logs"></a>Il `type` comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.

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

1. Crea una nuova distribuzione sul dispositivo principale per verificare che il componente rinvii l'aggiornamento. Esegui questa operazione:

   1. Nel menu di navigazione [AWS IoT Greengrass della console](https://console.aws.amazon.com/greengrass), scegli **Distribuzioni**.

   1. Scegli la distribuzione che hai creato o modificato in precedenza.

   1. Nella pagina di distribuzione, scegli **Rivedi**.

   1. **Nella modalità **Revise deployment**, scegli Revise deployment.**

   1. **Scegli **Avanti** in ogni passaggio, quindi scegli Distribuisci.**

1. Esegui il comando seguente per visualizzare nuovamente i log del componente e verifica che posticipi l'aggiornamento.

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

------

   Dovrebbero comparire messaggi simili a quelli dell'esempio seguente. Il componente posticipa l'aggiornamento di 30 secondi, quindi stampa ripetutamente questo messaggio.

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

1. Utilizza un editor di testo per modificare il file virtuale del livello della batteria e imposta il livello della batteria a un valore superiore alla soglia, in modo che l'installazione possa procedere.
   + Sui dispositivi principali Linux, modifica il file denominato`/home/ggc_user/virtual_battery.json`. Esegui l'editor di testo con `sudo` le autorizzazioni.
   + Sui dispositivi Windows Core, modifica il file denominato`C:\Users\ggc_user\virtual_battery.json`. Esegui l'editor di testo come amministratore.

   <a name="nano-command-intro"></a>Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.

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

   Cambia il livello della batteria in. `80`

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

1. Esegui il comando seguente per visualizzare nuovamente i log del componente e verifica che riconosca l'aggiornamento.

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

------

   Dovreste vedere messaggi simili ai seguenti esempi.

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

Hai completato questo tutorial. Il componente Hello World differisce o riconosce gli aggiornamenti in base al livello della batteria del dispositivo principale. Per ulteriori informazioni sugli argomenti trattati in questo tutorial, consulta quanto segue:
+ [Sviluppa AWS IoT Greengrass componenti](develop-greengrass-components.md)
+ [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md)
+ [Usa il SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti e AWS IoT CoreComunica con il nucleo Greengrass, altri componenti e AWS IoT Core](interprocess-communication.md)
+ [AWS IoT Greengrass Interfaccia a riga di comando del Development Kit](greengrass-development-kit-cli.md)