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à.
# Implementazione AWS IoT Greengrass dei componenti sui dispositivi
Puoi utilizzarli AWS IoT Greengrass per distribuire componenti su dispositivi o gruppi di dispositivi. *Le distribuzioni* vengono utilizzate per definire i componenti e le configurazioni che vengono inviati ai dispositivi. AWS IoT Greengrass viene distribuito su *obiettivi, oggetti* o gruppi di AWS IoT oggetti che rappresentano i dispositivi principali di Greengrass. AWS IoT Greengrass utilizza i [AWS IoT Core job](https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html) per l'implementazione sui dispositivi principali. Puoi configurare la modalità di distribuzione del lavoro sui tuoi dispositivi.
## Implementazioni principali dei dispositivi
Ogni dispositivo principale esegue i componenti delle distribuzioni per quel dispositivo. Una nuova distribuzione sulla stessa destinazione sovrascrive la distribuzione precedente sulla destinazione. Quando si crea una distribuzione, si definiscono i componenti e le configurazioni da applicare al software esistente del dispositivo principale.
Quando si modifica una distribuzione per una destinazione, si sostituiscono i componenti della revisione precedente con i componenti della nuova revisione. Ad esempio, si distribuiscono i [Gestore segreto](secret-manager-component.md) componenti [Gestore dei registri](log-manager-component.md) and nel gruppo di oggetti. `TestGroup` Quindi si crea un'altra distribuzione `TestGroup` che specifica solo il componente secret manager. Di conseguenza, i dispositivi principali di quel gruppo non eseguono più il gestore dei registri.
## Risoluzione delle dipendenze dalla piattaforma
Quando un dispositivo principale riceve una distribuzione, verifica che i componenti siano compatibili con il dispositivo principale. Ad esempio, se si distribuisce il [Firehose](kinesis-firehose-component.md) su una destinazione Windows, la distribuzione avrà esito negativo.
## Risoluzione delle dipendenze dei componenti
Durante la distribuzione di un componente, il dispositivo principale verifica la compatibilità delle dipendenze e dei requisiti di versione di tutti i componenti in un gruppo di oggetti. Questa verifica garantisce che i vincoli di versione siano soddisfatti per tutti i componenti e le relative dipendenze prima di procedere con la distribuzione.
Il processo di risoluzione delle dipendenze inizia con l'identificazione dei componenti di destinazione che non hanno dipendenze nelle loro ricette. Quindi, il sistema costruisce un albero delle dipendenze utilizzando breadth-first search (BFS) che esplora sistematicamente ogni nodo di destinazione e trova le relative dipendenze prima di passare al nodo successivo. Ogni nodo include il componente di destinazione come chiave e i requisiti di versione come valore.
I requisiti di versione combinano tre serie di vincoli:
+ I requisiti di versione già stabiliti nel gruppo di oggetti esistente.
+ La versione del componente richiesta dalla distribuzione. È necessario selezionare la versione di un componente quando si effettua o si aggiorna una distribuzione.
+ Qualsiasi vincolo di versione del componente definito nella sezione sulle dipendenze della ricetta.
### Risolvi le dipendenze dei componenti
Durante un'implementazione, il nucleo Greengrass tenta innanzitutto di trovare il candidato locale attualmente in esecuzione sul dispositivo che soddisfa i requisiti. Se il componente in esecuzione soddisfa i requisiti, il nucleo ottiene il percorso della ricetta memorizzato dalla cartella delle ricette e trova l'ultima versione locale nell'archivio locale.
[Per le Cloud AWS implementazioni, il nucleo chiamerà quindi l'API. ResolveComponentCandidates ](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_ResolveComponentCandidates.html) Questa API inizierà con l'ultima versione disponibile e verificherà se soddisfa le dipendenze e i requisiti. Quando il nucleo riceve la risposta dall'API, seleziona l'ultima versione. Se non viene trovata alcuna versione Cloud AWS che soddisfi i requisiti, la distribuzione non riesce. Se il dispositivo è offline, torna al candidato locale originale trovato. Se non viene trovato alcun candidato locale che soddisfi i requisiti, l'implementazione fallisce.
Per le implementazioni locali, il nucleo utilizza esclusivamente candidati locali, se esistono e soddisfano i requisiti senza negoziare. Cloud AWS Se non esiste un candidato di questo tipo, l'implementazione fallisce.
**Nota**
Tutte le ricette risolte vengono archiviate localmente per riferimenti futuri.
Per ulteriori informazioni, vedere la sezione sulla [risoluzione delle dipendenze](https://github.com/aws-greengrass/aws-greengrass-nucleus/wiki/Deployment#dependency-resolution) in GitHub.
Se il nucleo di Greengrass è in grado di risolvere con successo tutti i componenti, il registro del nucleo conterrà la riga seguente.
```
resolve-all-group-dependencies-finish. Finish resolving all groups dependencies.
```
**Example**
Di seguito è riportato un esempio di come il nucleo risolverà i requisiti dei componenti.
+ Si distribuisce ComponentA che dipende dalle versioni ComponentC 1.0.0-1.9.0.
+ Si distribuisce anche ComponentB che dipende dalle versioni ComponentC 1.4.0-1.9.5.
Con la risoluzione delle dipendenze dei componenti, il nucleo implementerà la versione più recente della versione ComponentC per soddisfare i requisiti di ComponentA e ComponentB. L'ultima versione di ComponentC è la versione 1.9.0.
#### Errori comuni di risoluzione delle dipendenze dei componenti
La risoluzione delle dipendenze dei componenti può avere esito negativo per due motivi principali: conflitto tra requisiti relativi alla versione di destinazione o conflitto tra requisiti di dipendenza dei componenti.
##### Scenario 1: conflitto tra i requisiti della versione di destinazione
+ Un oggetto esiste in un gruppo di oggetti e si desidera aggiungerlo anche a un nuovo gruppo di oggetti. La distribuzione avrà esito negativo se il nuovo gruppo di oggetti richiede una versione di cosa diversa.
+ Una distribuzione può inoltre fallire se un oggetto appartiene a un gruppo di oggetti e desidera aggiornare la versione del componente tramite la distribuzione di un oggetto.
![\[Dipendenze tra componenti che determinano una distribuzione non riuscita.\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/images/dependency-4.png)
*Esempio di registro degli errori:*
```
2025-04-11T06:16:03.315Z [ERROR] (pool-3-thread-27) com.aws.greengrass.componentmanager.ComponentManager: Failed to negotiate version with cloud and no local version to fall back to. {componentName=ComponentC, versionRequirement={thing/ABC==2.0.0, thinggroup/ThingGroupA==1.0.0}}
2025-04-11T06:16:03.316Z [ERROR] (pool-3-thread-26) com.aws.greengrass.deployment.DeploymentService: Error occurred while processing deployment. {deploymentId=fbac24de-4ef9-44b0-a685-fdc63b0f02b8, serviceName=DeploymentService, currentState=RUNNING}
java.util.concurrent.ExecutionException: com.aws.greengrass.componentmanager.exceptions.NoAvailableComponentVersionException: No local or cloud component version satisfies the requirements Check whether the version constraints conflict and that the component exists in your AWS account with a version that matches the version constraints. If the version constraints conflict, revise deployments to resolve the conflict. Component ComponentC version constraints: thing/ABC requires =2.0.0, thinggroup/ThingGroupA requires =1.0.0.
at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:122)
at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191)
at com.aws.greengrass.deployment.DefaultDeploymentTask.call(DefaultDeploymentTask.java:127)
at com.aws.greengrass.deployment.DefaultDeploymentTask.call(DefaultDeploymentTask.java:50)
at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
at java.base/java.lang.Thread.run(Thread.java:829)
Caused by: com.aws.greengrass.componentmanager.exceptions.NoAvailableComponentVersionException: No local or cloud component version satisfies the requirements Check whether the version constraints conflict and that the component exists in your AWS account with a version that matches the version constraints. If the version constraints conflict, revise deployments to resolve the conflict. Component ComponentC version constraints: thing/ABC requires =2.0.0, thinggroup/ThingGroupA requires =1.0.0.
at com.aws.greengrass.componentmanager.ComponentManager.negotiateVersionWithCloud(ComponentManager.java:232)
at com.aws.greengrass.componentmanager.ComponentManager.resolveComponentVersion(ComponentManager.java:167)
at com.aws.greengrass.componentmanager.DependencyResolver.lambda$resolveDependencies$0(DependencyResolver.java:134)
at com.aws.greengrass.componentmanager.DependencyResolver.resolveComponentDependencies(DependencyResolver.java:231)
at com.aws.greengrass.componentmanager.DependencyResolver.resolveDependencies(DependencyResolver.java:131)
at com.aws.greengrass.deployment.DefaultDeploymentTask.lambda$call$2(DefaultDeploymentTask.java:125)
... 4 more
```
I log indicano un errore di conflitto di versione perché il nucleo non riesce a trovare una versione del componente che soddisfi contemporaneamente due requisiti in conflitto.
##### Come risolverlo
+ Se si desidera mantenere il componente in ogni gruppo di oggetti, selezionare la stessa versione di quel componente in ogni gruppo di oggetti.
+ Seleziona una versione del componente che soddisfi i requisiti di distribuzione.
+ Se si desidera utilizzare una versione del componente che non soddisfa entrambi i requisiti del gruppo di oggetti, selezionare la versione del componente che soddisfa i requisiti della versione del gruppo di oggetti e utilizzare quel componente solo in quel gruppo di oggetti.
##### Scenario 2: conflitto tra requisiti di dipendenza e versione dei componenti
Se un componente dipende da diversi componenti e i componenti richiedono versioni diverse o intervalli di versioni diversi di quel componente, è possibile che non vi siano versioni disponibili per soddisfare tutti i requisiti di versione. In questo scenario, la distribuzione avrà esito negativo.
**Example**
Distribuzione di ComponentA (v2.5.0), ComponentB (v1.3.0) e ComponentC (v1.0.0)
+ ComponentA richiede la versione ComponentB >=1.0.0.
```
---
...
ComponentName: ComponentA
ComponentVersion: "2.5.0"
ComponentDependencies:
ComponentB:
VersionRequirement: ">=1.0.0"
DependencyType: "HARD"
...
```
+ ComponentC richiede la versione ComponentA <2.0.0.
```
---
...
ComponentName: ComponentC
ComponentVersion: "1.0.0"
ComponentDependencies:
ComponentA:
VersionRequirement: "<2.0.0"
DependencyType: "HARD"
...
```
Esiste un conflitto di versione tra due requisiti per ComponentA:
+ Componenta richiede la versione 2.5.0 in questa distribuzione
+ ComponentC richiede versioni di ComponentA precedenti alla 2.0.0
Questi due requisiti si contraddicono a vicenda, rendendo impossibile per il nucleo trovare una versione di ComponentA che soddisfi entrambi i requisiti. Pertanto, la risoluzione delle dipendenze fallisce.
![\[Dipendenze tra componenti che determinano una distribuzione non riuscita.\]](http://docs.aws.amazon.com/it_it/greengrass/v2/developerguide/images/dependency-3.png)
*Esempio di registro degli errori:*
```
2025-04-11T06:07:18.291Z [ERROR] (pool-3-thread-25) com.aws.greengrass.componentmanager.ComponentManager: Failed to negotiate version with cloud and no local version to fall back to. {componentName=ComponentA, versionRequirement={ComponentC=<2.0.0, thinggroup/ThingGroupA==2.5.0}}
2025-04-11T06:07:18.292Z [ERROR] (pool-3-thread-24) com.aws.greengrass.deployment.DeploymentService: Error occurred while processing deployment. {deploymentId=2ffac4df-1ac9-405c-8c11-28494a1b4382, serviceName=DeploymentService, currentState=RUNNING}
java.util.concurrent.ExecutionException: com.aws.greengrass.componentmanager.exceptions.NoAvailableComponentVersionException: No local or cloud component version satisfies the requirements Check whether the version constraints conflict and that the component exists in your AWS account with a version that matches the version constraints. If the version constraints conflict, revise deployments to resolve the conflict. Component ComponentA version constraints: ComponentC requires <2.0.0, thinggroup/ThingGroupA requires =2.5.0.
at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:122)
at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191)
at com.aws.greengrass.deployment.DefaultDeploymentTask.call(DefaultDeploymentTask.java:127)
at com.aws.greengrass.deployment.DefaultDeploymentTask.call(DefaultDeploymentTask.java:50)
at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
at java.base/java.lang.Thread.run(Thread.java:829)
Caused by: com.aws.greengrass.componentmanager.exceptions.NoAvailableComponentVersionException: No local or cloud component version satisfies the requirements Check whether the version constraints conflict and that the component exists in your AWS account with a version that matches the version constraints. If the version constraints conflict, revise deployments to resolve the conflict. Component ComponentA version constraints: ComponentC requires <2.0.0, thinggroup/ThingGroupA requires =2.5.0.
at com.aws.greengrass.componentmanager.ComponentManager.negotiateVersionWithCloud(ComponentManager.java:232)
at com.aws.greengrass.componentmanager.ComponentManager.resolveComponentVersion(ComponentManager.java:167)
at com.aws.greengrass.componentmanager.DependencyResolver.lambda$resolveDependencies$0(DependencyResolver.java:134)
at com.aws.greengrass.componentmanager.DependencyResolver.resolveComponentDependencies(DependencyResolver.java:231)
at com.aws.greengrass.componentmanager.DependencyResolver.resolveDependencies(DependencyResolver.java:131)
at com.aws.greengrass.deployment.DefaultDeploymentTask.lambda$call$2(DefaultDeploymentTask.java:125)
... 4 more
```
I log indicano che il nucleo non riesce a trovare una versione di ComponentA che soddisfi i seguenti requisiti.
+ I requisiti per Componenta devono essere esattamente la versione 2.5.0 (da A). ThingGroup
+ Il requisito per funzionare con versioni ComponentC precedenti alla 2.0.0.
##### Come risolverlo
+ Se si desidera mantenere il componente in ogni gruppo di oggetti, selezionare la stessa versione di quel componente in ogni gruppo di oggetti.
+ Seleziona una versione del componente che soddisfi i requisiti di distribuzione.
+ Se si desidera utilizzare una versione del componente che non soddisfa entrambi i requisiti del gruppo di oggetti, selezionare la versione del componente che soddisfa i requisiti della versione del gruppo di oggetti e utilizzare quel componente solo in quel gruppo di oggetti.
**Suggerimento**
Se viene visualizzato questo errore su un componente AWS fornito, è possibile risolverlo aggiornando i componenti in conflitto alla versione più recente.
## Rimuovere un dispositivo da un gruppo di oggetti
Quando si rimuove un dispositivo principale da un gruppo di oggetti, il comportamento di distribuzione dei componenti dipende dalla versione del [nucleo Greengrass utilizzata](greengrass-nucleus-component.md) dal dispositivo principale.
------
#### [ 2.5.1 and later ]
Quando si rimuove un dispositivo principale da un gruppo di oggetti, il comportamento dipende dal fatto che la AWS IoT policy conceda o meno l'autorizzazione. `greengrass:ListThingGroupsForCoreDevice` Per ulteriori informazioni su questa autorizzazione e sulle AWS IoT politiche per i dispositivi principali, consulta[Autenticazione e autorizzazione del dispositivo per AWS IoT Greengrass](device-auth.md).
+ **Se la AWS IoT politica concede questa autorizzazione**
Quando rimuovi un dispositivo principale da un gruppo di oggetti, AWS IoT Greengrass rimuove i componenti del gruppo di oggetti la prossima volta che viene effettuata una distribuzione sul dispositivo. Se un componente del dispositivo è incluso nella distribuzione successiva, tale componente non viene rimosso dal dispositivo.
+ **Se la AWS IoT politica non concede questa autorizzazione**
Quando rimuovi un dispositivo principale da un gruppo di oggetti, AWS IoT Greengrass non elimina i componenti di quel gruppo di oggetti dal dispositivo.
Per rimuovere un componente da un dispositivo, utilizzate il comando [deployment create](gg-cli-deployment.md#deployment-create) della CLI di Greengrass. Specificate il componente da rimuovere con l'`--remove`argomento e specificate il gruppo di cose con l'`--groupId`argomento.
------
#### [ 2.5.0 ]
Quando rimuovete un dispositivo principale da un gruppo di oggetti, AWS IoT Greengrass rimuove i componenti del gruppo di oggetti la prossima volta che viene effettuata una distribuzione sul dispositivo. Se un componente del dispositivo è incluso nella distribuzione successiva, tale componente non viene rimosso dal dispositivo.
Questo comportamento richiede che la AWS IoT politica del dispositivo principale conceda l'`greengrass:ListThingGroupsForCoreDevice`autorizzazione. Se un dispositivo principale non dispone di questa autorizzazione, il dispositivo principale non riesce ad applicare le distribuzioni. Per ulteriori informazioni, consulta [Autenticazione e autorizzazione del dispositivo per AWS IoT Greengrass](device-auth.md).
------
#### [ 2.0.x - 2.4.x ]
Quando rimuovi un dispositivo principale da un gruppo di oggetti, AWS IoT Greengrass non elimina i componenti di quel gruppo di oggetti dal dispositivo.
Per rimuovere un componente da un dispositivo, utilizzate il comando [deployment create](gg-cli-deployment.md#deployment-create) della CLI di Greengrass. Specificate il componente da rimuovere con l'`--remove`argomento e specificate il gruppo di cose con l'`--groupId`argomento.
------
## Distribuzioni
Le distribuzioni sono continue. Quando crei una distribuzione, AWS IoT Greengrass distribuisci la distribuzione sui dispositivi di destinazione che sono online. Se un dispositivo di destinazione non è online, riceve la distribuzione la volta successiva a cui si connette AWS IoT Greengrass. Quando aggiungi un dispositivo principale a un gruppo di oggetti di destinazione, AWS IoT Greengrass invia al dispositivo la distribuzione più recente per quel gruppo di oggetti.
Prima che un dispositivo principale distribuisca un componente, per impostazione predefinita invia una notifica a ciascun componente del dispositivo. I componenti Greengrass possono rispondere alla notifica per posticipare l'implementazione. Potresti voler posticipare l'installazione se il dispositivo ha un livello di batteria basso o sta eseguendo un processo che non può essere interrotto. Per ulteriori informazioni, consulta [Tutorial: Sviluppa un componente Greengrass che rinvii gli aggiornamenti dei componenti](defer-component-updates-tutorial.md). Quando si crea una distribuzione, è possibile configurarla per la distribuzione senza notificare i componenti.
Ogni oggetto o gruppo di oggetti di destinazione può avere una distribuzione alla volta. Ciò significa che quando si crea una distribuzione per una destinazione, AWS IoT Greengrass non viene più distribuita la revisione precedente della distribuzione di quella destinazione.
## Opzioni di implementazione
Le distribuzioni offrono diverse opzioni che consentono di controllare quali dispositivi ricevono un aggiornamento e come viene distribuito l'aggiornamento. Quando si crea una distribuzione, è possibile configurare le seguenti opzioni:
+ **AWS IoT Greengrass componenti**
Definire i componenti da installare ed eseguire sui dispositivi di destinazione. AWS IoT Greengrass i componenti sono moduli software distribuiti ed eseguiti sui dispositivi core Greengrass. I dispositivi ricevono componenti solo se il componente supporta la piattaforma del dispositivo. Ciò consente di eseguire la distribuzione su gruppi di dispositivi anche se i dispositivi di destinazione funzionano su più piattaforme. Se un componente non supporta la piattaforma del dispositivo, il componente non viene distribuito sul dispositivo.
Puoi distribuire componenti personalizzati e componenti AWS forniti sui tuoi dispositivi. Quando distribuisci un componente, AWS IoT Greengrass identifica tutte le dipendenze tra i componenti e distribuisce anche queste. Per ulteriori informazioni, consultare [Sviluppa AWS IoT Greengrass componenti](develop-greengrass-components.md) e [AWS-componenti forniti](public-components.md).
L'utente definisce la versione e l'aggiornamento della configurazione da distribuire per ogni componente. L'*aggiornamento della configurazione* specifica come modificare la configurazione esistente del componente sul dispositivo principale o la configurazione predefinita del componente se il componente non esiste sul dispositivo principale. È possibile specificare quali valori di configurazione ripristinare ai valori predefiniti e i nuovi valori di configurazione da unire al dispositivo principale. Quando un dispositivo principale riceve distribuzioni per destinazioni diverse e ogni distribuzione specifica versioni dei componenti compatibili, il dispositivo principale applica gli aggiornamenti di configurazione in base al timestamp di quando si crea la distribuzione. Per ulteriori informazioni, consulta [Aggiornamento delle configurazioni dei componenti](update-component-configurations.md).
**Importante**
Quando distribuisci un componente, AWS IoT Greengrass installa le ultime versioni supportate di tutte le dipendenze di quel componente. Per questo motivo, le nuove versioni patch dei componenti pubblici AWS forniti potrebbero essere distribuite automaticamente sui dispositivi principali se si aggiungono nuovi dispositivi a un gruppo di oggetti o si aggiorna la distribuzione destinata a tali dispositivi. Alcuni aggiornamenti automatici, come un aggiornamento Nucleus, possono causare il riavvio imprevisto dei dispositivi.
[Per evitare aggiornamenti involontari per un componente in esecuzione sul tuo dispositivo, ti consigliamo di includere direttamente la versione preferita di quel componente quando crei una distribuzione.](create-deployments.md) Per ulteriori informazioni sul comportamento di aggiornamento per il software AWS IoT Greengrass Core, consulta[Aggiornamento del software AWS IoT Greengrass Core (OTA)](update-greengrass-core-v2.md).
+ **Politiche di distribuzione**
Definisci quando è sicuro implementare una configurazione e cosa fare se l'implementazione fallisce. Puoi specificare se attendere o meno che i componenti segnalino che possono essere aggiornati. È inoltre possibile specificare se ripristinare o meno i dispositivi alla configurazione precedente se applicano una distribuzione che non riesce.
+ **Interrompi la configurazione**
Definisci quando e come interrompere una distribuzione. La distribuzione si interrompe e fallisce se vengono soddisfatti i criteri definiti. Ad esempio, è possibile configurare una distribuzione in modo che si interrompa se una percentuale di dispositivi non riesce ad applicarla dopo che un numero minimo di dispositivi l'ha ricevuta.
+ **Rollout configuration** (Configurazione rollout)
Definisci la velocità con cui una distribuzione viene distribuita ai dispositivi di destinazione. È possibile configurare un aumento esponenziale della velocità con limiti di velocità minimi e massimi.
+ **Configurazione del timeout**
Definisci la quantità massima di tempo a disposizione di ciascun dispositivo per applicare una distribuzione. Se un dispositivo supera la durata specificata, il dispositivo non riesce ad applicare la distribuzione.
**Importante**
I componenti personalizzati possono definire artefatti nei bucket S3. Quando il software AWS IoT Greengrass Core distribuisce un componente, scarica gli artefatti del componente da. Cloud AWS Per impostazione predefinita, i ruoli principali dei dispositivi non consentono l'accesso ai bucket S3. Per distribuire componenti personalizzati che definiscono gli artefatti in un bucket S3, il ruolo principale del dispositivo deve concedere le autorizzazioni per scaricare gli artefatti da quel bucket. Per ulteriori informazioni, consulta [Consenti l'accesso ai bucket S3 per gli artefatti dei componenti](device-service-role.md#device-service-role-access-s3-bucket).
**Topics**
+ [Implementazioni principali dei dispositivi](#core-device-deployments)
+ [Risoluzione delle dipendenze dalla piattaforma](#platform-dependency-resolution)
+ [Risoluzione delle dipendenze dei componenti](#component-dependency-resolution)
+ [Rimuovere un dispositivo da un gruppo di oggetti](#thing-group-removal-behavior)
+ [Distribuzioni](#deployments)
+ [Opzioni di implementazione](#deployment-options)
+ [Creare distribuzione](create-deployments.md)
+ [Creare distribuzioni secondarie](create-subdeployments.md)
+ [Rivedi le distribuzioni](revise-deployments.md)
+ [Annullare le distribuzioni](cancel-deployments.md)
+ [Verifica lo stato della distribuzione](check-deployment-status.md)
# Creare distribuzione
È possibile creare una distribuzione destinata a un oggetto o a un gruppo di oggetti.
Quando si crea una distribuzione, si configurano i componenti software da distribuire e il modo in cui il processo di distribuzione viene distribuito sui dispositivi di destinazione. È possibile definire la distribuzione nel file JSON fornito a. AWS CLI
L'obiettivo di distribuzione determina i dispositivi su cui si desidera eseguire i componenti. Per eseguire la distribuzione su un dispositivo principale, specifica un elemento. Per eseguire la distribuzione su più dispositivi principali, specificate un gruppo di oggetti che includa tali dispositivi. Per ulteriori informazioni su come configurare i gruppi di oggetti, vedere Thing group [statici e Thing group](https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html) [dinamici](https://docs.aws.amazon.com/iot/latest/developerguide/dynamic-thing-groups.html) nella *AWS IoT Developer Guide*.
Segui i passaggi di questa sezione per creare una distribuzione su un target. Per ulteriori informazioni su come aggiornare i componenti software su una destinazione con una distribuzione, consulta[Rivedi le distribuzioni](revise-deployments.md).
**avvertimento**
L'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione può disinstallare componenti dai dispositivi principali. Se un componente è presente nella distribuzione precedente e non in quella nuova, il dispositivo principale disinstalla quel componente. Per evitare la disinstallazione dei componenti, utilizza innanzitutto l'[ListDeployments](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_ListDeployments.html)operazione per verificare se la destinazione per la distribuzione ha già una distribuzione esistente. Quindi, utilizza l'[GetDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_GetDeployment.html)operazione per iniziare da quella distribuzione esistente quando ne crei una nuova.
**Per creare una distribuzione (AWS CLI)**
1. Create un file chiamato`deployment.json`, quindi copiate il seguente oggetto JSON nel file. Sostituisci *targetArn* con l'ARN dell' AWS IoT oggetto o del gruppo di oggetti da utilizzare come target per la distribuzione. L'oggetto e il gruppo di ARNs oggetti hanno il seguente formato:
+ Oggetto: `arn:aws:iot:region:account-id:thing/thingName`
+ Gruppo di oggetti: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
```
{
"targetArn": "targetArn"
}
```
1. Controlla se il target di distribuzione ha una distribuzione esistente che desideri modificare. Esegui questa operazione:
1. Esegui il comando seguente per elencare le distribuzioni per l'obiettivo di distribuzione. Sostituisci *targetArn* con l'ARN dell' AWS IoT oggetto o del gruppo di oggetti di destinazione.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La risposta contiene un elenco con la distribuzione più recente per l'obiettivo. Se la risposta è vuota, la destinazione non ha una distribuzione esistente e puoi saltare a[Step 3](#create-deployment-define-name-step). Altrimenti, copia il `deploymentId` codice dalla risposta da utilizzare nel passaggio successivo.
**Nota**
Puoi anche modificare una distribuzione diversa dalla revisione più recente per la destinazione. Specificare l'`--history-filter ALL`argomento per elencare tutte le distribuzioni per l'obiettivo. Quindi, copia l'ID della distribuzione che desideri modificare.
1. Esegui il comando seguente per ottenere i dettagli della distribuzione. Questi dettagli includono metadati, componenti e configurazione del processo. Sostituisci *deploymentId* con l'ID del passaggio precedente.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La risposta contiene i dettagli della distribuzione.
1. Copia una delle seguenti coppie chiave-valore dalla risposta del comando precedente in. `deployment.json` È possibile modificare questi valori per la nuova distribuzione.
+ `deploymentName`— Il nome della distribuzione.
+ `components`— I componenti della distribuzione. Per disinstallare un componente, rimuovilo da questo oggetto.
+ `deploymentPolicies`— Le politiche della distribuzione.
+ `iotJobConfiguration`— La configurazione del lavoro della distribuzione.
+ `tags`— I tag della distribuzione.
1. (Facoltativo) Definire un nome per la distribuzione. Sostituisci *deploymentName* con il nome della distribuzione.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName"
}
```
1. Aggiungi ogni componente per distribuire i dispositivi di destinazione. A tale scopo, aggiungete coppie chiave-valore all'`components`oggetto, dove la chiave è il nome del componente e il valore è un oggetto che contiene i dettagli di quel componente. Specificate i seguenti dettagli per ogni componente che aggiungete:
+ `version`— La versione del componente da distribuire.
+ `configurationUpdate`— L'[aggiornamento della configurazione](update-component-configurations.md) da distribuire. L'aggiornamento è un'operazione di patch che modifica la configurazione esistente del componente su ciascun dispositivo di destinazione o la configurazione predefinita del componente se non esiste sul dispositivo di destinazione. È possibile specificare i seguenti aggiornamenti di configurazione:
+ Reset updates (`reset`) — (Facoltativo) Un elenco di puntatori JSON che definiscono i valori di configurazione da ripristinare ai valori predefiniti sul dispositivo di destinazione. Il software AWS IoT Greengrass Core applica gli aggiornamenti di ripristino prima di applicare gli aggiornamenti di fusione. Per ulteriori informazioni, consulta [Reimposta gli aggiornamenti](update-component-configurations.md#reset-configuration-update).
+ Merge updates (`merge`) - (Facoltativo) Un documento JSON che definisce i valori di configurazione da unire al dispositivo di destinazione. È necessario serializzare il documento JSON come stringa. Per ulteriori informazioni, consulta [Unisci gli aggiornamenti](update-component-configurations.md#merge-configuration-update).
+ `runWith`— (Facoltativo) Le opzioni di processo del sistema utilizzate dal software AWS IoT Greengrass Core per eseguire i processi di questo componente sul dispositivo principale. Se omettete un parametro nell'`runWith`oggetto, il software AWS IoT Greengrass Core utilizza i valori predefiniti configurati sul componente [Greengrass](greengrass-nucleus-component.md) nucleus.
È possibile specificare una delle seguenti opzioni:
+ `posixUser`— L'utente e, facoltativamente, il gruppo del sistema POSIX da utilizzare per eseguire questo componente sui dispositivi core Linux. L'utente e il gruppo, se specificato, devono esistere su ogni dispositivo principale Linux. Specifica l'utente e il gruppo separati da due punti (`:`) nel seguente formato: `user:group`. Il gruppo è facoltativo. Se non si specifica un gruppo, il software AWS IoT Greengrass Core utilizza il gruppo primario per l'utente. Per ulteriori informazioni, consulta [Configurare l'utente che esegue i componenti](configure-greengrass-core-v2.md#configure-component-user).
+ `windowsUser`— L'utente Windows da utilizzare per eseguire questo componente sui dispositivi Windows principali. L'utente deve esistere su ogni dispositivo Windows principale e il nome e la password devono essere memorizzati nell'istanza di Credentials Manager dell' LocalSystem account. Per ulteriori informazioni, consulta [Configurare l'utente che esegue i componenti](configure-greengrass-core-v2.md#configure-component-user).
Questa funzionalità è disponibile per la versione 2.5.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus.
+ `systemResourceLimits`— I limiti delle risorse di sistema da applicare ai processi di questo componente. È possibile applicare limiti di risorse di sistema a componenti Lambda generici e non containerizzati. Per ulteriori informazioni, consulta [Configura i limiti delle risorse di sistema per i componenti](configure-greengrass-core-v2.md#configure-component-system-resource-limits).
È possibile specificare una delle seguenti opzioni:
+ `cpus`— La quantità massima di tempo di CPU che i processi di questo componente possono utilizzare sul dispositivo principale. Il tempo totale della CPU di un dispositivo principale è equivalente al numero di core CPU del dispositivo. Ad esempio, su un dispositivo principale con 4 core CPU, è possibile impostare questo valore in modo da `2` limitare i processi di questo componente al 50% di utilizzo di ciascun core della CPU. Su un dispositivo con 1 core di CPU, puoi impostare questo valore `0.25` per limitare i processi di questo componente al 25 percento di utilizzo della CPU. Se imposti questo valore su un numero maggiore del numero di core della CPU, il software AWS IoT Greengrass Core non limita l'utilizzo della CPU del componente.
+ `memory`— La quantità massima di RAM (in kilobyte) che i processi di questo componente possono utilizzare sul dispositivo principale.
Questa funzionalità è disponibile per la versione 2.4.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus. AWS IoT Greengrass attualmente non supporta questa funzionalità sui dispositivi Windows core.
**Example Esempio di aggiornamento della configurazione di base**
L'`components`oggetto di esempio seguente specifica di distribuire un componente`com.example.PythonRuntime`, che prevede un parametro di configurazione denominato. `pythonVersion`
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.PythonRuntime": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"pythonVersion\":\"3.7\"}"
}
}
}
}
```
**Example Esempio di aggiornamento della configurazione con ripristino e unione degli aggiornamenti**
Consideriamo un esempio di componente di dashboard industriale con la seguente configurazione predefinita. `com.example.IndustrialDashboard`
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
Il seguente aggiornamento della configurazione specifica le seguenti istruzioni:
1. Reimposta l'impostazione HTTPS al valore predefinito (`true`).
1. Reimposta l'elenco dei tag industriali su un elenco vuoto.
1. Unisci un elenco di etichette industriali che identificano i flussi di dati di temperatura e pressione per due caldaie.
```
{
"reset": [
"/network/useHttps",
"/tags"
],
"merge": {
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
```
L'`components`oggetto di esempio seguente specifica la distribuzione di questo componente del dashboard industriale e l'aggiornamento della configurazione.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
1. (Facoltativo) Definire le politiche di distribuzione per la distribuzione. È possibile configurare quando i dispositivi principali possono applicare una distribuzione in sicurezza o cosa fare se un dispositivo principale non riesce ad applicare la distribuzione. A tale scopo, aggiungi un `deploymentPolicies` oggetto e quindi esegui una delle seguenti operazioni: `deployment.json`
1. (Facoltativo) Specificate la politica di aggiornamento dei componenti (`componentUpdatePolicy`). Questa politica definisce se la distribuzione consente o meno ai componenti di posticipare un aggiornamento finché non sono pronti per l'aggiornamento. Ad esempio, potrebbe essere necessario ripulire le risorse o completare azioni critiche prima di poter riavviarsi per applicare un aggiornamento. Questa politica definisce anche la quantità di tempo a disposizione dei componenti per rispondere a una notifica di aggiornamento.
Questa politica è un oggetto con i seguenti parametri:
+ `action`— (Facoltativo) Se notificare o meno i componenti e attendere che vengano segnalati quando sono pronti per l'aggiornamento. Seleziona una delle opzioni seguenti:
+ `NOTIFY_COMPONENTS`: l'implementazione avvisa ogni componente prima che venga interrotto e aggiornato. I componenti possono utilizzare l'operazione [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates) IPC per ricevere queste notifiche.
+ `SKIP_NOTIFY_COMPONENTS`: l'implementazione non avvisa i componenti né attende che vengano aggiornati in sicurezza.
L'impostazione predefinita è `NOTIFY_COMPONENTS`.
+ `timeoutInSeconds`La quantità di tempo in secondi a disposizione di ciascun componente per rispondere a una notifica di aggiornamento con l'operazione [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate) IPC. Se il componente non risponde entro questo lasso di tempo, la distribuzione procede sul dispositivo principale.
Il valore predefinito è 60 secondi.
1. (Facoltativo) Specificare la politica di convalida della configurazione (). `configurationValidationPolicy` Questa politica definisce il tempo a disposizione di ciascun componente per convalidare un aggiornamento della configurazione da una distribuzione. I componenti possono utilizzare l'operazione [SubscribeToValidateConfigurationUpdates](ipc-component-configuration.md#ipc-operation-subscribetovalidateconfigurationupdates) IPC per sottoscrivere le notifiche relative ai propri aggiornamenti di configurazione. Quindi, i componenti possono utilizzare l'operazione [SendConfigurationValidityReport](ipc-component-configuration.md#ipc-operation-sendconfigurationvalidityreport) IPC per comunicare al software AWS IoT Greengrass Core se l'aggiornamento della configurazione è valido. Se l'aggiornamento della configurazione non è valido, la distribuzione non riesce.
Questa politica è un oggetto con il seguente parametro:
+ `timeoutInSeconds`(Facoltativo) La quantità di tempo in secondi a disposizione di ogni componente per convalidare un aggiornamento della configurazione. Se il componente non risponde entro questo lasso di tempo, la distribuzione procede sul dispositivo principale.
Il valore predefinito è 30 secondi.
1. (Facoltativo) Specificare la politica di gestione degli errori ()`failureHandlingPolicy`. Questa policy è una stringa che definisce se ripristinare o meno i dispositivi se la distribuzione fallisce. Seleziona una delle opzioni seguenti:
+ `ROLLBACK`— Se l'installazione fallisce su un dispositivo principale, il software AWS IoT Greengrass Core ripristina il dispositivo principale alla configurazione precedente.
+ `DO_NOTHING`— Se l'installazione fallisce su un dispositivo principale, il software AWS IoT Greengrass Core mantiene la nuova configurazione. Ciò può causare il danneggiamento dei componenti se la nuova configurazione non è valida.
L'impostazione predefinita è `ROLLBACK`.
La tua distribuzione in `deployment.json` potrebbe essere simile al seguente esempio:
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
}
}
```
1. (Facoltativo) Definisci in che modo la distribuzione viene interrotta, implementata o scaduta. AWS IoT Greengrass utilizza i AWS IoT Core processi per inviare le distribuzioni ai dispositivi principali, quindi queste opzioni sono identiche alle opzioni di configurazione per AWS IoT Core i lavori. Per ulteriori informazioni, consulta [Job rollout and abort configuration](https://docs.aws.amazon.com/iot/latest/developerguide/job-rollout-abort.html) nella *AWS IoT Developer* Guide.
Per definire le opzioni di lavoro, aggiungi un `iotJobConfiguration` oggetto a. `deployment.json` Quindi, definite le opzioni da configurare.
La tua distribuzione in `deployment.json` potrebbe essere simile all'esempio seguente:
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
},
"iotJobConfiguration": {
"abortConfig": {
"criteriaList": [
{
"action": "CANCEL",
"failureType": "ALL",
"minNumberOfExecutedThings": 100,
"thresholdPercentage": 5
}
]
},
"jobExecutionsRolloutConfig": {
"exponentialRate": {
"baseRatePerMinute": 5,
"incrementFactor": 2,
"rateIncreaseCriteria": {
"numberOfNotifiedThings": 10,
"numberOfSucceededThings": 5
}
},
"maximumPerMinute": 50
},
"timeoutConfig": {
"inProgressTimeoutInMinutes": 5
}
}
}
```
1. (Facoltativo) Aggiungi tag (`tags`) per la distribuzione. Per ulteriori informazioni, consulta [Tagga le tue AWS IoT Greengrass Version 2 risorse](tag-resources.md).
1. Esegui il comando seguente per creare la distribuzione da`deployment.json`.
```
aws greengrassv2 create-deployment --cli-input-json file://deployment.json
```
La risposta include un messaggio `deploymentId` che identifica questa distribuzione. È possibile utilizzare l'ID di distribuzione per verificare lo stato della distribuzione. Per ulteriori informazioni, consulta [Verifica lo stato della distribuzione](check-deployment-status.md#check-cloud-deployment-status).
# Aggiornamento delle configurazioni dei componenti
Le configurazioni dei componenti sono oggetti JSON che definiscono i parametri per ogni componente. La ricetta di ogni componente definisce la sua configurazione predefinita, che viene modificata quando si distribuiscono i componenti sui dispositivi principali.
Quando si crea una distribuzione, è possibile specificare l'*aggiornamento della configurazione* da applicare a ciascun componente. Gli aggiornamenti di configurazione sono operazioni di patch, il che significa che l'aggiornamento modifica la configurazione del componente esistente sul dispositivo principale. Se il dispositivo principale non dispone del componente, l'aggiornamento della configurazione modifica e applica la configurazione predefinita per quella distribuzione.
L'aggiornamento della configurazione definisce gli aggiornamenti di *ripristino* e gli aggiornamenti di *unione.* Gli aggiornamenti di ripristino definiscono quali valori di configurazione ripristinare i valori predefiniti o rimuovere. Gli aggiornamenti di fusione definiscono i nuovi valori di configurazione da impostare per il componente. Quando si distribuisce un aggiornamento di configurazione, il software AWS IoT Greengrass Core esegue l'aggiornamento di ripristino prima dell'aggiornamento di fusione.
I componenti possono convalidare gli aggiornamenti di configurazione distribuiti. Il componente si iscrive per ricevere una notifica quando una distribuzione modifica la sua configurazione e può rifiutare una configurazione che non supporta. Per ulteriori informazioni, consulta [Interazione con la configurazione dei componenti](ipc-component-configuration.md).
**Topics**
+ [Reimposta gli aggiornamenti](#reset-configuration-update)
+ [Unisci gli aggiornamenti](#merge-configuration-update)
+ [Esempi](#configuration-update-example)
## Reimposta gli aggiornamenti
Gli aggiornamenti di ripristino definiscono quali valori di configurazione ripristinare ai valori predefiniti sul dispositivo principale. Se un valore di configurazione non ha un valore predefinito, l'aggiornamento di ripristino rimuove tale valore dalla configurazione del componente. Questo può aiutarti a correggere un componente che si rompe a causa di una configurazione non valida.
Usa un elenco di puntatori JSON per definire i valori di configurazione da reimpostare. I puntatori JSON iniziano con una barra. `/` Per identificare un valore in una configurazione di componenti annidati, utilizzate forward slashes (`/`) per separare le chiavi per ogni livello della configurazione. Per ulteriori informazioni, vedete la specifica del puntatore [JSON](https://tools.ietf.org/html/rfc6901).
**Nota**
È possibile ripristinare solo i valori predefiniti di un intero elenco. Non è possibile utilizzare la reimpostazione degli aggiornamenti per reimpostare un singolo elemento in un elenco.
Per ripristinare l'intera configurazione di un componente ai valori predefiniti, specifica una singola stringa vuota come aggiornamento di ripristino.
```
"reset": [""]
```
## Unisci gli aggiornamenti
Gli aggiornamenti di fusione definiscono i valori di configurazione da inserire nella configurazione del componente sul core. L'aggiornamento di fusione è un oggetto JSON che il software AWS IoT Greengrass Core unisce dopo aver ripristinato i valori nei percorsi specificati nell'aggiornamento di ripristino. Quando si utilizza AWS CLI o AWS SDKs, è necessario serializzare questo oggetto JSON come stringa.
È possibile unire una coppia chiave-valore che non esiste nella configurazione predefinita del componente. È inoltre possibile unire una coppia chiave-valore di tipo diverso dal valore con la stessa chiave. Il nuovo valore sostituisce il vecchio valore. Ciò significa che è possibile modificare la struttura dell'oggetto di configurazione.
È possibile unire valori nulli e stringhe, elenchi e oggetti vuoti.
**Nota**
Non è possibile utilizzare gli aggiornamenti di fusione per inserire o aggiungere un elemento a un elenco. È possibile sostituire un intero elenco oppure definire un oggetto in cui ogni elemento ha una chiave unica.
AWS IoT Greengrass utilizza JSON per i valori di configurazione. JSON specifica un tipo di numero ma non distingue tra numeri interi e float. Di conseguenza, i valori di configurazione potrebbero essere convertiti in float in. AWS IoT Greengrass Per garantire che il componente utilizzi il tipo di dati corretto, si consiglia di definire i valori di configurazione numerici come stringhe. Quindi, chiedi al componente di analizzarli come numeri interi o float. Ciò garantisce che i valori di configurazione abbiano lo stesso tipo nella configurazione e sul dispositivo principale.
### Usa le variabili di ricetta negli aggiornamenti di fusione
[Questa funzionalità è disponibile per la versione 2.6.0 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md)
Se imposti l'opzione di [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configurazione Greengrass nucleus su`true`, puoi utilizzare variabili di ricetta, diverse dalla variabile `component_dependency_name:configuration:json_pointer` recipe, negli aggiornamenti di fusione. Ad esempio, è possibile utilizzare la variabile `{iot:thingName}` recipe in un aggiornamento di fusione per includere il nome dell' AWS IoT oggetto del dispositivo principale in un valore di configurazione del componente, ad esempio una politica di autorizzazione per la [comunicazione tra processi (](interprocess-communication.md#ipc-authorization-policies)IPC).
## Esempi
L'esempio seguente mostra gli aggiornamenti di configurazione per un componente del dashboard con la seguente configurazione predefinita. Questo componente di esempio visualizza informazioni sulle apparecchiature industriali.
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
### Ricetta dei componenti del cruscotto industriale
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.IndustrialDashboard",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Displays information about industrial equipment.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/industrial_dashboard.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/industrial_dashboard.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.IndustrialDashboard
ComponentVersion: '1.0.0'
ComponentDescription: Displays information about industrial equipment.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
name: null
mode: REQUEST
network:
useHttps: true
port:
http: 80
https: 443
tags: []
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/industrial_dashboard.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/industrial_dashboard.py
```
------
**Example Esempio 1: Merge update**
Si crea una distribuzione che applica il seguente aggiornamento di configurazione, che specifica un aggiornamento di unione ma non un aggiornamento di ripristino. Questo aggiornamento di configurazione indica al componente di visualizzare il dashboard sulla porta HTTP 8080 con i dati provenienti da due caldaie.
**Configurazione da unire**
```
{
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
Il comando seguente crea una distribuzione su un dispositivo principale.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment.json
```
Il `dashboard-deployment.json` file contiene il seguente documento JSON.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"name\":\"Factory 2A\",\"network\":{\"useHttps\":false,\"port\":{\"http\":8080}},\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
Il seguente comando [Greengrass CLI](greengrass-cli-component.md) crea una distribuzione locale su un dispositivo principale.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration.json
```
Il `dashboard-configuration.json` file contiene il seguente documento JSON.
```
{
"com.example.IndustrialDashboard": {
"MERGE": {
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
}
```
Dopo questo aggiornamento, il componente del dashboard presenta la seguente configurazione.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": false,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
**Example Esempio 2: reimpostazione e unione degli aggiornamenti**
Quindi, si crea una distribuzione che applica il seguente aggiornamento di configurazione, che specifica un aggiornamento di ripristino e un aggiornamento di unione. Questi aggiornamenti specificano la visualizzazione del dashboard sulla porta HTTPS predefinita con dati provenienti da diverse caldaie. Questi aggiornamenti modificano la configurazione risultante dagli aggiornamenti di configurazione dell'esempio precedente.
**Reimposta i percorsi**
```
[
"/network/useHttps",
"/tags"
]
```
**Configurazione da unire**
```
{
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
```
Il comando seguente crea una distribuzione su un dispositivo principale.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment2.json
```
Il `dashboard-deployment2.json` file contiene il seguente documento JSON.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/3/temperature\",\"/boiler/3/pressure\",\"/boiler/4/temperature\",\"/boiler/4/pressure\"]}"
}
}
}
}
```
Il seguente comando [Greengrass CLI](greengrass-cli-component.md) crea una distribuzione locale su un dispositivo principale.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration2.json
```
Il `dashboard-configuration2.json` file contiene il seguente documento JSON.
```
{
"com.example.IndustrialDashboard": {
"RESET": [
"/network/useHttps",
"/tags"
],
"MERGE": {
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
}
}
```
Dopo questo aggiornamento, il componente del dashboard presenta la seguente configurazione.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure",
]
}
```
# Creare distribuzioni secondarie
**Nota**
La funzionalità di distribuzione secondaria è disponibile su Greengrass nucleus versione 2.9.0 e successive. Non è possibile implementare una configurazione in una sottodistribuzione con versioni precedenti dei componenti di Greengrass nucleus.
Una distribuzione secondaria è una distribuzione destinata a un sottoinsieme più piccolo di dispositivi all'interno di una distribuzione principale. È possibile utilizzare le distribuzioni secondarie per distribuire una configurazione in un sottoinsieme più piccolo di dispositivi. È inoltre possibile creare distribuzioni secondarie per riprovare una distribuzione principale non riuscita in caso di guasto di uno o più dispositivi in quella distribuzione principale. Con questa funzionalità, è possibile selezionare i dispositivi che hanno avuto un errore nella distribuzione principale e creare una sottodistribuzione per testare le configurazioni fino al completamento della sottodistribuzione. Una volta completata la sottodistribuzione, è possibile ridistribuire tale configurazione nella distribuzione principale.
Segui i passaggi in questa sezione per creare una sottodistribuzione e verificarne lo stato. [Per ulteriori informazioni su come creare distribuzioni, consulta Creare distribuzioni.](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html)
**Per creare una sottodistribuzione ()AWS CLI**
1. Esegui il comando seguente per recuperare le distribuzioni più recenti per un gruppo di oggetti. Sostituire l'ARN nel comando con l'ARN del gruppo di cose da interrogare. Imposta `--history-filter` **LATEST\$1ONLY** per visualizzare l'ultima implementazione di quel gruppo di cose.
```
aws greengrassv2 list-deployments --target-arn arn:aws:iot:region:account-id:thinggroup/thingGroupName --history-filter LATEST_ONLY
```
1. Copia il file `deploymentId` dalla risposta al **list-deployments** comando da utilizzare nel passaggio successivo.
1. Esegui il comando seguente per recuperare lo stato di una distribuzione. Sostituisci `deploymentId` con l'ID della distribuzione da interrogare.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
1. Copia il codice `iotJobId` dalla risposta al **get-deployment** comando da utilizzare nel passaggio successivo.
1. Esegui il comando seguente per recuperare l'elenco delle esecuzioni di job per il job specificato. Sostituire *jobID* con il `iotJobId` passaggio precedente. Sostituisci *status* con lo stato per cui desideri filtrare. Puoi filtrare i risultati con i seguenti stati:
+ `QUEUED`
+ `IN_PROGRESS`
+ `SUCCEEDED`
+ `FAILED`
+ `TIMED_OUT`
+ `REJECTED`
+ `REMOVED`
+ `CANCELED`
```
aws iot list-job-executions-for-job --job-id jobID --status status
```
1. Crea un nuovo gruppo di AWS IoT cose o utilizza un gruppo di cose esistente per la tua distribuzione secondaria. Quindi, aggiungi AWS IoT qualcosa a questo gruppo di oggetti. Utilizzi i gruppi di cose per gestire flotte di dispositivi core Greengrass. Quando distribuisci componenti software sui tuoi dispositivi, puoi scegliere come target singoli dispositivi o gruppi di dispositivi. È possibile aggiungere un dispositivo a un gruppo di oggetti con una distribuzione Greengrass attiva. Una volta aggiunto, è possibile distribuire i componenti software di quel gruppo di oggetti su quel dispositivo.
Per creare un nuovo gruppo di oggetti e aggiungervi i dispositivi, effettuate le seguenti operazioni:
1. Crea un gruppo AWS IoT di oggetti. Sostituire *MyGreengrassCoreGroup* con il nome del nuovo gruppo di oggetti. Non è possibile utilizzare i due punti (:)) nel nome di un gruppo di oggetti.
**Nota**
Se un gruppo di oggetti per una distribuzione secondaria viene utilizzato con uno`parentTargetArn`, non può essere riutilizzato con un parco dati principale diverso. Se un gruppo di oggetti è già stato utilizzato per creare una sottodistribuzione per un'altra flotta, l'API restituirà un errore.
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Se la richiesta ha esito positivo, la risposta è simile all'esempio seguente:
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Aggiungi un core Greengrass fornito al tuo gruppo di cose. Esegui il comando seguente con questi parametri:
+ Sostituiscilo *MyGreengrassCore* con il nome del core Greengrass fornito.
+ *MyGreengrassCoreGroup*Sostituiscilo con il nome del tuo gruppo di oggetti.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
Il comando non ha alcun output se la richiesta ha esito positivo.
1. Crea un file chiamato`deployment.json`, quindi copia il seguente oggetto JSON nel file. Sostituire *targetArn* con l'ARN del gruppo di oggetti AWS IoT da utilizzare come target per la sottodistribuzione. Un obiettivo di sottodistribuzione può essere solo un gruppo di oggetti. Il gruppo di cose ARNs ha il seguente formato:
+ **Gruppo di cose**: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
```
{
"targetArn": "targetArn"
}
```
1. Esegui nuovamente il comando seguente per ottenere i dettagli della distribuzione originale. Questi dettagli includono metadati, componenti e configurazione del processo. Sostituisci *deploymentId* con l'ID di[Step 1](#create-subdeployments-step1). È possibile utilizzare questa configurazione di distribuzione per configurare la sottodistribuzione e apportare le modifiche necessarie.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La risposta contiene i dettagli della distribuzione. Copia una delle seguenti coppie chiave-valore dalla risposta del **get-deployment** comando in. `deployment.json` È possibile modificare questi valori per la distribuzione secondaria. Per ulteriori informazioni sui dettagli di questo comando, vedere [GetDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_GetDeployment.html).
+ `components`— I componenti della distribuzione. Per disinstallare un componente, rimuovilo da questo oggetto. Se il componente definisce una fase del [ciclo di vita della disinstallazione](component-recipe-reference.md#uninstall-lifecycle-definition), il software AWS IoT Greengrass Core esegue lo script di disinstallazione prima di rimuovere il componente dal dispositivo.
+ `deploymentName`— Il nome della distribuzione.
+ `deploymentPolicies`— Le politiche della distribuzione.
+ `iotJobConfiguration`— La configurazione del lavoro della distribuzione.
+ `parentTargetArn`— L'obiettivo della distribuzione principale.
+ `tags`— I tag della distribuzione.
1. Esegui il comando seguente per creare la sottodistribuzione da`deployment.json`. Sostituire *subdeploymentName* con un nome per la sottodistribuzione.
```
aws greengrassv2 create-deployment --deployment-name subdeploymentName --cli-input-json file://deployment.json
```
La risposta include un messaggio `deploymentId` che identifica questa sottodistribuzione. È possibile utilizzare l'ID di distribuzione per verificare lo stato della distribuzione. Per ulteriori informazioni, consulta [Verifica dello stato della distribuzione](https://docs.aws.amazon.com/greengrass/v2/developerguide/check-deployment-status.html#check-cloud-deployment-status).
1. Se la distribuzione secondaria ha esito positivo, è possibile utilizzare la relativa configurazione per rivedere la distribuzione principale. Copia quello `deployment.json` che hai usato nel passaggio precedente. Sostituisci il `targetArn` file JSON con l'ARN della distribuzione principale ed esegui il comando seguente per creare la distribuzione principale utilizzando questa nuova configurazione.
**Nota**
Se crei una nuova revisione di distribuzione della flotta principale, sostituisce tutte le revisioni e le distribuzioni secondarie di quella distribuzione principale. [Per ulteriori informazioni, consulta Revisionare le distribuzioni.](https://docs.aws.amazon.com/greengrass/v2/developerguide/revise-deployments.html)
```
aws greengrassv2 create-deployment --cli-input-json file://deployment.json
```
La risposta include un messaggio `deploymentId` che identifica questa distribuzione. È possibile utilizzare l'ID di distribuzione per verificare lo stato della distribuzione. Per ulteriori informazioni, consulta [Verifica lo stato della distribuzione](check-deployment-status.md#check-cloud-deployment-status).
# Rivedi le distribuzioni
Ogni oggetto o gruppo di oggetti target può avere una distribuzione attiva alla volta. Quando si crea una distribuzione per una destinazione che dispone già di una distribuzione, i componenti software della nuova distribuzione sostituiscono quelli della distribuzione precedente. Se la nuova distribuzione non definisce un componente definito dalla distribuzione precedente, il software AWS IoT Greengrass Core rimuove quel componente dai dispositivi principali di destinazione. È possibile modificare una distribuzione esistente in modo da non rimuovere i componenti eseguiti sui dispositivi principali da una distribuzione precedente a una destinazione.
Per modificare una distribuzione, si crea una distribuzione che parte dagli stessi componenti e configurazioni esistenti in una distribuzione precedente. Si utilizza l'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione, che è la stessa operazione utilizzata per [creare](create-deployments.md) le distribuzioni.
**Per rivedere una distribuzione ()AWS CLI**
1. Esegui il comando seguente per elencare le distribuzioni per l'obiettivo di distribuzione. Sostituisci *targetArn* con l'ARN dell' AWS IoT oggetto o del gruppo di oggetti di destinazione.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La risposta contiene un elenco con la distribuzione più recente per l'obiettivo. Copia il file `deploymentId` dalla risposta da utilizzare nel passaggio successivo.
**Nota**
È inoltre possibile rivedere una distribuzione diversa dalla revisione più recente per l'obiettivo. Specificare l'`--history-filter ALL`argomento per elencare tutte le distribuzioni per l'obiettivo. Quindi, copia l'ID della distribuzione che desideri modificare.
1. Esegui il comando seguente per ottenere i dettagli della distribuzione. Questi dettagli includono metadati, componenti e configurazione del processo. Sostituisci *deploymentId* con l'ID del passaggio precedente.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La risposta contiene i dettagli della distribuzione.
1. Crea un file denominato `deployment.json` e copia la risposta del comando precedente nel file.
1. Rimuovi le seguenti coppie chiave-valore dall'oggetto JSON in `deployment.json`:
+ `deploymentId`
+ `revisionId`
+ `iotJobId`
+ `iotJobArn`
+ `creationTimestamp`
+ `isLatestForTarget`
+ `deploymentStatus`
L'[CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html)operazione prevede un payload con la seguente struttura.
```
{
"targetArn": "String",
"components": Map of components,
"deploymentPolicies": DeploymentPolicies,
"iotJobConfiguration": DeploymentIoTJobConfiguration,
"tags": Map of tags
}
```
1. In `deployment.json`, effettua una delle seguenti operazioni:
+ Cambia il nome della distribuzione ()`deploymentName`.
+ Modifica i componenti della distribuzione (`components`).
+ Modifica le politiche della distribuzione (`deploymentPolicies`).
+ Modifica la configurazione del lavoro della distribuzione (`iotJobConfiguration`).
+ Modifica i tag della distribuzione (`tags`).
Per ulteriori informazioni su come definire questi dettagli di distribuzione, consulta[Creare distribuzione](create-deployments.md).
1. Esegui il comando seguente per creare la distribuzione da`deployment.json`.
```
aws greengrassv2 create-deployment --cli-input-json file://deployment.json
```
La risposta include un messaggio `deploymentId` che identifica questa distribuzione. È possibile utilizzare l'ID di distribuzione per verificare lo stato della distribuzione. Per ulteriori informazioni, consulta [Verifica lo stato della distribuzione](check-deployment-status.md#check-cloud-deployment-status).
# Annullare le distribuzioni
È possibile annullare una distribuzione attiva per impedire l'installazione dei relativi componenti software sui dispositivi AWS IoT Greengrass principali. Se annulli una distribuzione destinata a un gruppo di oggetti, i dispositivi principali che aggiungi al gruppo non riceveranno quella distribuzione continua. Se un dispositivo principale esegue già la distribuzione, non modificherai i componenti di quel dispositivo quando annulli la distribuzione. È necessario [creare una nuova distribuzione](create-deployments.md) o [modificare la distribuzione](revise-deployments.md) per modificare i componenti in esecuzione sui dispositivi principali che hanno ricevuto la distribuzione annullata.
**Per annullare una distribuzione ()AWS CLI**
1. Esegui il comando seguente per trovare l'ID dell'ultima revisione di distribuzione per una destinazione. La revisione più recente è l'unica distribuzione che può essere attiva per un oggetto, poiché le distribuzioni precedenti vengono annullate quando si crea una nuova revisione. Sostituisci *targetArn* con l'ARN dell' AWS IoT oggetto o del gruppo di oggetti di destinazione.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La risposta contiene un elenco con la distribuzione più recente per l'obiettivo. Copia il file `deploymentId` dalla risposta da utilizzare nel passaggio successivo.
1. Esegui il comando seguente per annullare la distribuzione. Sostituisci *deploymentId* con l'ID del passaggio precedente.
```
aws greengrassv2 cancel-deployment --deployment-id deploymentId
```
Se l'operazione ha esito positivo, lo stato di distribuzione cambia in`CANCELED`.
# Verifica lo stato della distribuzione
Puoi controllare lo stato di una distribuzione in cui crei AWS IoT Greengrass. Puoi anche controllare lo stato dei AWS IoT processi che implementano la distribuzione su ogni dispositivo principale. Mentre una distribuzione è attiva, lo stato del AWS IoT processo è`IN_PROGRESS`. Dopo aver creato una nuova revisione di una distribuzione, lo stato del AWS IoT lavoro della revisione precedente cambia in. `CANCELLED`
**Topics**
+ [Verifica lo stato della distribuzione](#check-cloud-deployment-status)
+ [Controlla lo stato di distribuzione del dispositivo](#check-device-deployment-status)
## Verifica lo stato della distribuzione
Puoi controllare lo stato di una distribuzione identificata in base alla sua destinazione o al suo ID.
**Per controllare lo stato della distribuzione per destinazione (AWS CLI)**
+ Esegui il comando seguente per recuperare lo stato dell'ultima distribuzione per una destinazione. Sostituisci *targetArn* con l'Amazon Resource Name (ARN) dell' AWS IoT oggetto o del gruppo di oggetti a cui si rivolge la distribuzione.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La risposta contiene un elenco con la distribuzione più recente per l'obiettivo. Questo oggetto di distribuzione include lo stato della distribuzione.
**Per controllare lo stato della distribuzione tramite ID (AWS CLI)**
+ Esegui il comando seguente per recuperare lo stato di una distribuzione. Sostituisci *deploymentId* con l'ID della distribuzione da interrogare.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La risposta contiene lo stato della distribuzione.
## Controlla lo stato di distribuzione del dispositivo
Puoi controllare lo stato di un processo di distribuzione che si applica a un singolo dispositivo principale. È inoltre possibile controllare lo stato di un processo di distribuzione per una distribuzione di gruppi di oggetti.
**Per controllare lo stato del processo di distribuzione per un dispositivo principale ()AWS CLI**
+ Esegui il comando seguente per recuperare lo stato di tutti i processi di distribuzione per un dispositivo principale. Sostituisci *coreDeviceName* con il nome del dispositivo principale da interrogare.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name coreDeviceName
```
La risposta contiene l'elenco dei processi di distribuzione per il dispositivo principale. È possibile identificare il lavoro per una distribuzione in base al comando `deploymentId` o`targetArn`. Ogni processo di distribuzione contiene lo stato del processo sul dispositivo principale.
**Per controllare gli stati di distribuzione per un gruppo di oggetti ()AWS CLI**
1. Esegui il comando seguente per recuperare l'ID di una distribuzione esistente. Sostituisci *targetArn* con l'ARN del gruppo di oggetti target.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
La risposta contiene un elenco con la distribuzione più recente per la destinazione. Copia il file `deploymentId` dalla risposta da utilizzare nel passaggio successivo.
**Nota**
Puoi anche elencare una distribuzione diversa da quella più recente per l'obiettivo. Specificare l'`--history-filter ALL`argomento per elencare tutte le distribuzioni per l'obiettivo. Quindi, copia l'ID della distribuzione di cui desideri controllare lo stato.
1. Esegui il comando seguente per ottenere i dettagli della distribuzione. Sostituisci *deploymentID* con l'ID del passaggio precedente.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
La risposta contiene informazioni sulla distribuzione. Copia il codice `iotJobId` dalla risposta da utilizzare nel passaggio successivo.
1. Esegui il comando seguente per descrivere l'esecuzione del lavoro di un dispositivo principale per la distribuzione. Sostituisci *iotJobId* e *coreDeviceThingName* con l'ID del lavoro del passaggio precedente e il dispositivo principale di cui desideri controllare lo stato.
```
aws iot describe-job-execution --job-id iotJobId --thing-name coreDeviceThingName
```
La risposta contiene lo stato dell'esecuzione del processo di distribuzione del dispositivo principale e dettagli sullo stato. `detailsMap`Contiene le seguenti informazioni:
+ `detailed-deployment-status`— Lo stato del risultato della distribuzione, che può corrispondere a uno dei seguenti valori:
+ `SUCCESSFUL`— La distribuzione è riuscita.
+ `FAILED_NO_STATE_CHANGE`— La distribuzione non è riuscita mentre il dispositivo principale era pronto ad applicare la distribuzione.
+ `FAILED_ROLLBACK_NOT_REQUESTED`— La distribuzione non è riuscita e non è stata specificata la necessità di ripristinare una configurazione funzionante precedente, pertanto il dispositivo principale potrebbe non funzionare correttamente.
+ `FAILED_ROLLBACK_COMPLETE`— L'installazione non è riuscita e il dispositivo principale è stato ripristinato correttamente a una configurazione di lavoro precedente.
+ `FAILED_UNABLE_TO_ROLLBACK`— L'installazione non è riuscita e il dispositivo principale non è riuscito a ripristinare una configurazione di lavoro precedente, pertanto il dispositivo principale potrebbe non funzionare correttamente.
Se la distribuzione non è riuscita, controlla il `deployment-failure-cause` valore e i file di registro del dispositivo principale per identificare il problema. Per ulteriori informazioni su come accedere ai file di registro del dispositivo principale, consulta[Monitora AWS IoT Greengrass i registri](monitor-logs.md).
+ `deployment-failure-cause`— Un messaggio di errore che fornisce ulteriori dettagli sul motivo per cui l'esecuzione del job non è riuscita.
La risposta è simile all'esempio seguente.
```
{
"execution": {
"jobId": "2cc2698a-5175-48bb-adf2-1dd345606ebd",
"status": "FAILED",
"statusDetails": {
"detailsMap": {
"deployment-failure-cause": "No local or cloud component version satisfies the requirements. Check whether the version constraints conflict and that the component exists in your Account AWS with a version that matches the version constraints. If the version constraints conflict, revise deployments to resolve the conflict. Component com.example.HelloWorld version constraints: LOCAL_DEPLOYMENT requires =1.0.0, thinggroup/MyGreengrassCoreGroup requires =1.0.1.",
"detailed-deployment-status": "FAILED_NO_STATE_CHANGE"
}
},
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"queuedAt": "2022-02-15T14:45:53.098000-08:00",
"startedAt": "2022-02-15T14:46:05.670000-08:00",
"lastUpdatedAt": "2022-02-15T14:46:20.892000-08:00",
"executionNumber": 1,
"versionNumber": 3
}
}
```