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à.
# Sviluppa AWS IoT Greengrass componenti
Puoi sviluppare e testare componenti sul tuo dispositivo principale Greengrass. Di conseguenza, è possibile creare e iterare il AWS IoT Greengrass software senza interagire con. Cloud AWS Quando completi una versione del componente, puoi caricarla nel cloud, AWS IoT Greengrass in modo che tu e il tuo team possiate distribuire il componente su altri dispositivi del parco macchine. Per ulteriori informazioni su come distribuire i componenti, consulta. [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md)
Ogni componente è composto da una *ricetta* e da *artefatti*.
+ **Ricette**
Ogni componente contiene un file di ricette, che ne definisce i metadati. La ricetta specifica anche i parametri di configurazione del componente, le dipendenze dei componenti, il ciclo di vita e la compatibilità della piattaforma. Il ciclo di vita del componente definisce i comandi che installano, eseguono e spengono il componente. Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
[È possibile definire ricette in formato [JSON](https://en.wikipedia.org/wiki/JSON) o YAML.](https://en.wikipedia.org/wiki/YAML)
+ **Artefatti**
I componenti possono avere un numero qualsiasi di artefatti, che sono componenti binari. Gli artefatti possono includere script, codice compilato, risorse statiche e qualsiasi altro file utilizzato da un componente. I componenti possono anche consumare artefatti derivanti dalle dipendenze dei componenti.
AWS IoT Greengrass fornisce componenti predefiniti che è possibile utilizzare nelle applicazioni e distribuire sui dispositivi. Ad esempio, puoi utilizzare il componente stream manager per caricare dati su vari AWS servizi oppure puoi utilizzare il componente CloudWatch metrics per pubblicare metriche personalizzate su Amazon. CloudWatch Per ulteriori informazioni, consulta [AWS-componenti forniti](public-components.md).
AWS IoT Greengrass cura un indice dei componenti di Greengrass, chiamato Greengrass Software Catalog. Questo catalogo tiene traccia dei componenti Greengrass sviluppati dalla comunità Greengrass. Da questo catalogo, puoi scaricare, modificare e distribuire componenti per creare le tue applicazioni Greengrass. Per ulteriori informazioni, consulta [Componenti comunitari](greengrass-software-catalog.md).
Il software AWS IoT Greengrass Core esegue i componenti come utente e gruppo del sistema, come `ggc_user` e`ggc_group`, configurati sul dispositivo principale. Ciò significa che i componenti dispongono delle autorizzazioni di quell'utente del sistema. Se utilizzi un utente di sistema senza una home directory, i componenti non possono utilizzare i comandi di esecuzione o il codice che utilizza una home directory. Ciò significa che non è possibile utilizzare il `pip install some-library --user` comando per installare pacchetti Python, ad esempio. Se hai seguito il [tutorial introduttivo](getting-started.md) per configurare il tuo dispositivo principale, allora l'utente del sistema non dispone di una home directory. Per ulteriori informazioni su come configurare l'utente e il gruppo che eseguono i componenti, consulta[Configurare l'utente che esegue i componenti](configure-greengrass-core-v2.md#configure-component-user).
**Nota**
AWS IoT Greengrass utilizza versioni semantiche per i componenti. *Le versioni semantiche seguono una delle principali.* *minore*. sistema di numerazione delle *patch*. Ad esempio, la versione `1.0.0` rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la [specifica della versione semantica](https://semver.org/).
**Topics**
+ [Ciclo di vita dei componenti](#component-lifecycle)
+ [Tipi di componenti](#component-types)
+ [Crea AWS IoT Greengrass componenti](create-components.md)
+ [Testare AWS IoT Greengrass i componenti con distribuzioni locali](test-components.md)
+ [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md)
+ [Interagisci con AWS i servizi](interact-with-aws-services.md)
+ [Esegui un contenitore Docker](run-docker-container.md)
+ [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md)
+ [Riferimento alla variabile di ambiente del componente](component-environment-variables.md)
## Ciclo di vita dei componenti
Il *ciclo di vita dei componenti* definisce le fasi utilizzate dal software AWS IoT Greengrass Core per installare ed eseguire i componenti. Ogni fase definisce uno script e altre informazioni che specificano il comportamento del componente. Ad esempio, quando si installa un componente, il software AWS IoT Greengrass Core esegue `install` lo script del ciclo di vita per quel componente. I componenti dei dispositivi principali hanno i seguenti stati del ciclo di vita:
+ `NEW`— La ricetta e gli artefatti del componente vengono caricati sul dispositivo principale, ma il componente non è installato. Dopo che un componente entra in questo stato, esegue lo script di [installazione](component-recipe-reference.md#install-lifecycle-definition).
+ `INSTALLED`— Il componente è installato sul dispositivo principale. Il componente entra in questo stato dopo aver eseguito lo [script di installazione](component-recipe-reference.md#install-lifecycle-definition).
+ `STARTING`— Il componente si avvia sul dispositivo principale. Il componente entra in questo stato quando esegue lo [script di avvio](component-recipe-reference.md#startup-lifecycle-definition). Se l'avvio ha esito positivo, il componente entra nello `RUNNING` stato.
+ `RUNNING`— Il componente è in esecuzione sul dispositivo principale. Il componente entra in questo stato quando esegue lo [script di esecuzione](component-recipe-reference.md#run-lifecycle-definition) o quando ha processi in background attivi dallo script di avvio.
+ `FINISHED`— Il componente è stato eseguito correttamente e l'esecuzione è stata completata.
+ `STOPPING`— Il componente si sta arrestando. Il componente entra in questo stato quando esegue lo script di [spegnimento](component-recipe-reference.md#shutdown-lifecycle-definition).
+ `ERRORED`— Il componente ha riscontrato un errore. Quando il componente entra in questo stato, esegue lo [script di ripristino](component-recipe-reference.md#recover-lifecycle-definition). Quindi, il componente si riavvia per provare a tornare al normale utilizzo. Se il componente entra nello `ERRORED` stato tre volte senza un'esecuzione riuscita, il componente diventa`BROKEN`.
+ `BROKEN`— Il componente ha riscontrato errori più volte e non può essere ripristinato. È necessario distribuire nuovamente il componente per risolverlo.
## Tipi di componenti
Il *tipo di componente* specifica in che modo il software AWS IoT Greengrass Core esegue il componente. I componenti possono avere i seguenti tipi:
+ **Nucleo** () `aws.greengrass.nucleus`
Il Greengrass nucleus è il componente che fornisce le funzionalità minime del AWS IoT Greengrass software Core. Per ulteriori informazioni, consulta [Nucleo Greengrass](greengrass-nucleus-component.md).
+ **Plugin** () `aws.greengrass.plugin`
Il nucleo Greengrass esegue un componente plug-in nella stessa Java Virtual Machine (JVM) del nucleo. Il nucleo si riavvia quando si modifica la versione di un componente plug-in su un dispositivo principale. Per installare ed eseguire i componenti del plug-in, è necessario configurare il nucleo Greengrass per l'esecuzione come servizio di sistema. Per ulteriori informazioni, consulta [Configurare il nucleo Greengrass come servizio di sistema](configure-greengrass-core-v2.md#configure-system-service).
Diversi componenti forniti da AWS sono componenti plug-in, che consentono loro di interfacciarsi direttamente con il nucleo Greengrass. I componenti del plug-in utilizzano lo stesso file di registro del nucleo Greengrass. Per ulteriori informazioni, consulta [Monitora AWS IoT Greengrass i registri](monitor-logs.md).
+ **Generico** () `aws.greengrass.generic`
Il nucleo Greengrass esegue gli script del ciclo di vita di un componente generico, se il componente definisce un ciclo di vita.
Questo tipo è il tipo predefinito per i componenti personalizzati.
+ **Lambda (**) `aws.greengrass.lambda`
[Il nucleo Greengrass esegue un componente della funzione Lambda utilizzando il componente di avvio Lambda.](lambda-launcher-component.md)
Quando si crea un componente da una funzione Lambda, il componente ha questo tipo. Per ulteriori informazioni, consulta [Esegui AWS Lambda funzioni](run-lambda-functions.md).
**Nota**
Non è consigliabile specificare il tipo di componente in una ricetta. AWS IoT Greengrass imposta il tipo automaticamente quando crei un componente.
# Crea AWS IoT Greengrass componenti
È possibile sviluppare AWS IoT Greengrass componenti personalizzati su un computer di sviluppo locale o su un dispositivo principale Greengrass. AWS IoT Greengrass [fornisce l'[interfaccia a riga di comando del AWS IoT Greengrass Development Kit (GDK CLI](greengrass-development-kit-cli.md)) per aiutarti a creare, creare e pubblicare componenti da modelli di componenti predefiniti e componenti della community.](greengrass-software-catalog.md) È inoltre possibile eseguire comandi shell incorporati per creare, creare e pubblicare componenti. Scegliete tra le seguenti opzioni per creare componenti Greengrass personalizzati:
+ **Usa la CLI del Greengrass Development Kit**
Usa la CLI GDK per sviluppare componenti su un computer di sviluppo locale. La CLI GDK compila e impacchetta il codice sorgente dei componenti in una ricetta e in artefatti che puoi pubblicare come componente privato del servizio. AWS IoT Greengrass Puoi configurare la CLI di GDK per aggiornare automaticamente la versione e l' URIs artefatto del componente quando pubblichi il componente, in modo da non dover aggiornare la ricetta ogni volta. Per sviluppare un componente utilizzando la CLI GDK, puoi iniziare da un modello o da un componente della community dal [Greengrass](greengrass-software-catalog.md) Software Catalog. Per ulteriori informazioni, consulta [AWS IoT Greengrass Interfaccia a riga di comando del Development Kit](greengrass-development-kit-cli.md).
+ **Esegui i comandi della shell incorporati**
È possibile eseguire comandi shell integrati per sviluppare componenti su un computer di sviluppo locale o su un dispositivo principale Greengrass. Utilizzate i comandi della shell per copiare o creare il codice sorgente dei componenti in artefatti. Ogni volta che create una nuova versione di un componente, dovete creare o aggiornare la ricetta con la nuova versione del componente. Quando pubblicate il componente sul AWS IoT Greengrass servizio, dovete aggiornare l'URI per ogni elemento del componente nella ricetta.
**Topics**
+ [Creare un componente (GDK CLI)](#create-component-gdk-cli)
+ [Crea un componente (comandi shell)](#create-component-shell-commands)
## Creare un componente (GDK CLI)
Segui le istruzioni in questa sezione per creare e creare un componente utilizzando la CLI GDK.
**Sviluppare un componente Greengrass (GDK CLI)**
1. Se non l'hai già fatto, installa la CLI GDK sul tuo computer di sviluppo. Per ulteriori informazioni, consulta [Installare o aggiornare l'interfaccia a riga di comando del AWS IoT Greengrass Development Kit](install-greengrass-development-kit-cli.md).
1. Passa alla cartella in cui desideri creare le cartelle dei componenti.
------
#### [ Linux or Unix ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2
cd ~/greengrassv2
```
------
1. Scegliete un modello di componente o un componente della community da scaricare. La CLI di GDK scarica il modello o il componente della community, quindi puoi iniziare da un esempio funzionale. Utilizzate il comando [component list](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-list) per recuperare l'elenco dei modelli disponibili o dei componenti della community.
+ Per elencare i modelli dei componenti, esegui il comando seguente. Ogni riga della risposta include il nome e il linguaggio di programmazione di un modello.
```
gdk component list --template
```
+ Per elencare i componenti della community, esegui il comando seguente.
```
gdk component list --repository
```
1. Crea e passa a una cartella di componenti in cui la CLI di GDK scarica il modello o il componente della community. Sostituisci *HelloWorld* con il nome del componente o un altro nome che ti aiuti a identificare la cartella del componente.
------
#### [ Linux or Unix ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir HelloWorld
cd HelloWorld
```
------
#### [ PowerShell ]
```
mkdir HelloWorld
cd HelloWorld
```
------
1. Scarica il modello o il componente della community nella cartella corrente. Usa il comando [component init](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-init).
+ Per creare una cartella di componenti da un modello, esegui il comando seguente. Sostituisci *HelloWorld* con il nome del modello e sostituisci *python* con il nome del linguaggio di programmazione.
```
gdk component init --template HelloWorld --language python
```
+ Per creare una cartella di componenti da un componente della community, esegui il comando seguente. Sostituisci *ComponentName* con il nome del componente della community.
```
gdk component init --repository ComponentName
```
**Nota**
Se usi GDK CLI v1.0.0, devi eseguire questo comando in una cartella vuota. La CLI GDK scarica il modello o il componente della community nella cartella corrente.
Se utilizzi GDK CLI v1.1.0 o versione successiva, puoi specificare `--name` l'argomento per specificare la cartella in cui la CLI di GDK scarica il modello o il componente della community. Se usi questo argomento, specifica una cartella che non esiste. La CLI GDK crea la cartella per te. Se non specificate questo argomento, la CLI di GDK utilizza la cartella corrente, che deve essere vuota.
1. 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. Il passaggio precedente crea questo file automaticamente. In questo passaggio, si aggiorna `gdk-config.json` con le informazioni sul componente. Esegui questa operazione:
1. Aprire `gdk-config.json` in un editor di testo.
1. (Facoltativo) Modifica il nome del componente. Il nome del componente è la chiave dell'`component`oggetto.
1. Cambia l'autore del componente.
1. (Facoltativo) Modifica la versione del componente. Specifica una delle seguenti proprietà:
+ `NEXT_PATCH`— Quando scegliete questa opzione, la CLI di GDK imposta la versione quando pubblicate il componente. La CLI GDK interroga AWS IoT Greengrass il servizio per identificare l'ultima versione pubblicata del componente. Quindi, imposta la versione alla versione della patch successiva a quella versione. Se non hai mai pubblicato il componente prima, la CLI di GDK utilizza la versione. `1.0.0`
Se scegli questa opzione, non puoi utilizzare la [CLI di Greengrass](greengrass-cli-component.md) per distribuire e testare localmente il componente sul tuo computer di sviluppo locale che esegue il software Core. AWS IoT Greengrass Per abilitare le distribuzioni locali, devi invece specificare una versione semantica.
+ Una versione semantica, ad esempio. **1.0.0** *Le versioni semantiche utilizzano un major.* *minore*. sistema di numerazione delle *patch*. Per ulteriori informazioni, consulta la specifica della [versione semantica](https://semver.org/).
Se sviluppate componenti su un dispositivo Greengrass core su cui desiderate distribuire e testare il componente, scegliete questa opzione. [È necessario creare il componente con una versione specifica per creare distribuzioni locali con la Greengrass CLI.](greengrass-cli-component.md)
1. (Facoltativo) Modificate la configurazione di compilazione per il componente. La configurazione di build definisce come la CLI di GDK crea il sorgente del componente in artefatti. Scegliete tra le seguenti opzioni per: `build_system`
+ `zip`— Impacchetta la cartella del componente in un file ZIP da definire come unico elemento del componente. Scegliete questa opzione per i seguenti tipi di componenti:
+ Componenti che utilizzano linguaggi di programmazione interpretati, come Python o. JavaScript
+ Componenti che impacchettano file diversi dal codice, come modelli di apprendimento automatico o altre risorse.
La CLI GDK comprime la cartella del componente in un file zip con lo stesso nome della cartella del componente. Ad esempio, se il nome della cartella del componente è`HelloWorld`, la CLI GDK crea un file zip denominato. `HelloWorld.zip`
**Nota**
Se si utilizza la versione 1.0.0 della CLI di GDK su un dispositivo Windows, i nomi delle cartelle dei componenti e dei file zip devono contenere solo lettere minuscole.
Quando la CLI di GDK comprime la cartella del componente in un file zip, salta i seguenti file:
+ Il file `gdk-config.json`
+ Il file della ricetta (o) `recipe.json` `recipe.yaml`
+ Crea cartelle, come `greengrass-build`
+ `maven`— Esegue il `mvn clean package` comando per creare il codice sorgente del componente in artefatti. Scegli questa opzione per i componenti che utilizzano [Maven](https://maven.apache.org/), come i componenti Java.
Sui dispositivi Windows, questa funzionalità è disponibile per GDK CLI v1.1.0 e versioni successive.
+ `gradle`— Esegue il `gradle build` comando per creare il codice sorgente del componente in artefatti. [Scegliete questa opzione per i componenti che utilizzano Gradle.](https://gradle.org/) Questa funzionalità è disponibile per GDK CLI v1.1.0 e versioni successive.
Il sistema di `gradle` build supporta Kotlin DSL come file di build. Questa funzionalità è disponibile per GDK CLI v1.2.0 e versioni successive.
+ `gradlew`— Esegue il `gradlew` comando per creare il codice sorgente del componente in artefatti. Scegliete questa opzione per i componenti che utilizzano il [Gradle](https://docs.gradle.org/current/userguide/gradle_wrapper.html) Wrapper.
Questa funzionalità è disponibile per GDK CLI v1.2.0 e versioni successive.
+ `custom`— Esegue un comando personalizzato per creare il codice sorgente del componente in una ricetta e in artefatti. Specificate il comando personalizzato nel `custom_build_command` parametro.
1. Se specificate `custom` for`build_system`, aggiungete il `custom_build_command` all'`build`oggetto. In`custom_build_command`, specificate una singola stringa o un elenco di stringhe, dove ogni stringa è una parola nel comando. Ad esempio, per eseguire un comando di compilazione personalizzato per un componente C\$1\$1, è possibile specificare. **["cmake", "--build", "build", "--config", "Release"]**
1. Se utilizzi GDK CLI v1.1.0 o versione successiva, puoi specificare `--bucket` l'argomento per specificare il bucket S3 in cui la CLI di GDK carica gli artefatti del componente. Se non specifichi questo argomento, la CLI di GDK viene caricata nel bucket S3 il cui nome `bucket-region-accountId` è, *bucket* dove *region* e sono i valori `gdk-config.json` in cui specifichi e rappresenta il tuo ID. *accountId* Account AWS La CLI GDK crea il bucket se non esiste.
Modifica la configurazione di pubblicazione per il componente. Esegui questa operazione:
1. Specificate il nome del bucket S3 da utilizzare per ospitare gli artefatti dei componenti.
1. Specificate Regione AWS dove la CLI di GDK pubblica il componente.
Al termine di questo passaggio, il `gdk-config.json` file potrebbe essere simile all'esempio seguente.
```
{
"component": {
"com.example.PythonHelloWorld": {
"author": "Amazon",
"version": "NEXT_PATCH",
"build": {
"build_system" : "zip"
},
"publish": {
"bucket": "greengrass-component-artifacts",
"region": "us-west-2"
}
}
},
"gdk_version": "1.0.0"
}
```
1. Aggiornate il file di ricetta del componente, denominato `recipe.yaml` o`recipe.json`. Esegui questa operazione:
1. Se hai scaricato un modello o un componente della community che utilizza il sistema di `zip` compilazione, verifica che il nome dell'artefatto zip corrisponda al nome della cartella del componente. La CLI GDK comprime la cartella del componente in un file zip con lo stesso nome della cartella del componente. La ricetta contiene il nome dell'artefatto zip nell'elenco degli artefatti dei componenti e negli script del ciclo di vita che utilizzano i file nell'elemento zip. Aggiorna le `Lifecycle` definizioni `Artifacts` e in modo che il nome del file zip corrisponda al nome della cartella del componente. I seguenti esempi di ricette parziali evidenziano il nome del file zip nelle `Lifecycle` definizioni `Artifacts` and.
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
...
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. (Facoltativo) Aggiornate la descrizione del componente, la configurazione predefinita, gli artefatti, gli script del ciclo di vita e il supporto della piattaforma. Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
Al termine di questo passaggio, il file delle ricette potrebbe essere simile ai seguenti esempi.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "{COMPONENT_NAME}",
"ComponentVersion": "{COMPONENT_VERSION}",
"ComponentDescription": "This is a simple Hello World component written in Python.",
"ComponentPublisher": "{COMPONENT_AUTHOR}",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "World"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Artifacts": [
{
"URI": "s3://{COMPONENT_NAME}/{COMPONENT_VERSION}/HelloWorld.zip",
"Unarchive": "ZIP"
}
],
"Lifecycle": {
"Run": "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: "2020-01-25"
ComponentName: "{COMPONENT_NAME}"
ComponentVersion: "{COMPONENT_VERSION}"
ComponentDescription: "This is a simple Hello World component written in Python."
ComponentPublisher: "{COMPONENT_AUTHOR}"
ComponentConfiguration:
DefaultConfiguration:
Message: "World"
Manifests:
- Platform:
os: all
Artifacts:
- URI: "s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/HelloWorld.zip"
Unarchive: ZIP
Lifecycle:
Run: "python3 -u {artifacts:decompressedPath}/HelloWorld/main.py {configuration:/Message}"
```
------
1. Sviluppa e costruisci il componente Greengrass. Il comando [component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) produce una ricetta e degli artefatti nella `greengrass-build` cartella della cartella del componente. Esegui il comando seguente.
```
gdk component build
```
Quando sei pronto per testare il tuo componente, usa la CLI di GDK per pubblicarlo AWS IoT Greengrass sul servizio. Quindi, puoi distribuire il componente sui dispositivi principali Greengrass. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
## Crea un componente (comandi shell)
Segui le istruzioni in questa sezione per creare cartelle di ricette e artefatti che contengono codice sorgente e artefatti per più componenti.
**Sviluppare un componente Greengrass (comandi di shell)**
1. Crea una cartella per i tuoi componenti con sottocartelle per ricette e artefatti. Esegui i seguenti comandi sul tuo dispositivo principale Greengrass per creare queste cartelle e passare alla cartella dei componenti. Sostituisci *\$1/greengrassv2* o *%USERPROFILE%\$1greengrassv2* con il percorso della cartella da utilizzare per lo sviluppo locale.
------
#### [ Linux or Unix ]
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
------
#### [ PowerShell ]
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
------
1. Utilizza un editor di testo per creare un file di ricette che definisca i metadati, i parametri, le dipendenze, il ciclo di vita e le funzionalità della piattaforma del componente. Includi la versione del componente nel nome del file di ricetta in modo da poter identificare quale ricetta riflette quale versione del componente. Puoi scegliere il formato YAML o JSON per la tua ricetta.
Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
------
#### [ JSON ]
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
------
**Nota**
AWS IoT Greengrass utilizza versioni semantiche per i componenti. *Le versioni semantiche seguono una delle principali.* *minore*. sistema di numerazione delle *patch*. Ad esempio, la versione `1.0.0` rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la [specifica della versione semantica](https://semver.org/).
1. Definite la ricetta per il componente. Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
La tua ricetta potrebbe essere simile alla seguente ricetta di esempio di Hello World.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
Questa ricetta esegue uno script Hello World Python, che potrebbe essere simile allo script di esempio seguente.
```
import sys
message = "Hello, %s!" % sys.argv[1]
# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
1. Crea una cartella per lo sviluppo della versione del componente. Ti consigliamo di utilizzare una cartella separata per gli artefatti di ogni versione del componente in modo da poter identificare quali artefatti sono per ogni versione del componente. Esegui il comando seguente.
------
#### [ Linux or Unix ]
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
#### [ PowerShell ]
```
mkdir artifacts/com.example.HelloWorld/1.0.0
```
------
**Importante**
È necessario utilizzare il seguente formato per il percorso della cartella degli artefatti. Includete il nome e la versione del componente specificati nella ricetta.
```
artifacts/componentName/componentVersion/
```
1. Create gli artefatti per il componente nella cartella creata nel passaggio precedente. Gli artefatti possono includere software, immagini e qualsiasi altro file binario utilizzato dal componente.
Quando il componente è pronto, [testalo](test-components.md).
# Testare AWS IoT Greengrass i componenti con distribuzioni locali
Se sviluppi un componente Greengrass su un dispositivo principale, puoi creare una distribuzione locale per installarlo e testarlo. Segui i passaggi di questa sezione per creare una distribuzione locale.
Se sviluppi il componente su un computer diverso, ad esempio un computer di sviluppo locale, non puoi creare una distribuzione locale. Pubblica invece il componente sul AWS IoT Greengrass servizio in modo da poterlo distribuire sui dispositivi core Greengrass per testarlo. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md) e [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md).
**Per testare un componente su un dispositivo centrale Greengrass**
1. Il dispositivo principale registra eventi come gli aggiornamenti dei componenti. È possibile visualizzare questo file di registro per individuare e risolvere errori relativi al componente, ad esempio una ricetta non valida. Questo file di registro mostra anche i messaggi che il componente stampa in modalità standard out (stdout). Ti consigliamo di aprire una sessione terminale aggiuntiva sul tuo dispositivo principale per osservare i nuovi messaggi di registro in tempo reale. Apri una nuova sessione di terminale, ad esempio tramite SSH, ed esegui il comando seguente per visualizzare i log. Sostituisci `/greengrass/v2` con il percorso della cartella AWS IoT Greengrass principale.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
------
È inoltre possibile visualizzare il file di registro del componente.
------
#### [ Linux or Unix ]
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
------
1. Nella sessione terminale originale, esegui il comando seguente per aggiornare il dispositivo principale con il componente. Sostituitelo `/greengrass/v2` con il percorso della cartella AWS IoT Greengrass principale e *\$1/greengrassv2* sostituitelo con il percorso della cartella di sviluppo locale.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
--recipeDir ~/greengrassv2/recipes \
--artifactDir ~/greengrassv2/artifacts \
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
--recipeDir %USERPROFILE%\greengrassv2\recipes ^
--artifactDir %USERPROFILE%\greengrassv2\artifacts ^
--merge "com.example.HelloWorld=1.0.0"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
--recipeDir ~/greengrassv2/recipes `
--artifactDir ~/greengrassv2/artifacts `
--merge "com.example.HelloWorld=1.0.0"
```
------
**Nota**
È inoltre possibile utilizzare il `greengrass-cli deployment create` comando per impostare il valore dei parametri di configurazione del componente. Per ulteriori informazioni, consulta [Crea](gg-cli-deployment.md#deployment-create).
1. Utilizzate il `greengrass-cli deployment status` comando per monitorare lo stato di avanzamento della distribuzione del componente.
------
#### [ Unix or Linux ]
```
sudo /greengrass/v2/bin/greengrass-cli deployment status \
-i deployment-id
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status ^
-i deployment-id
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli deployment status `
-i deployment-id
```
------
1. Testa il tuo componente mentre funziona sul dispositivo principale Greengrass. Una volta completata questa versione del componente, puoi caricarla sul AWS IoT Greengrass servizio. Quindi, è possibile distribuire il componente su altri dispositivi di base. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
# Pubblica componenti da distribuire sui tuoi dispositivi principali
Dopo aver creato o completato una versione di un componente, puoi pubblicarla sul AWS IoT Greengrass servizio. Quindi, puoi distribuirlo sui dispositivi principali di Greengrass.
Se utilizzi la [CLI del Greengrass Development Kit (GDK CLI)](greengrass-development-kit-cli.md) per [sviluppare e creare un componente](create-components.md), puoi utilizzare [la CLI GDK per pubblicare il](#publish-component-gdk-cli) componente su. Cloud AWS Altrimenti, [utilizzate i comandi di shell incorporati e](#publish-component-shell-commands) pubblicate il componente. AWS CLI
È inoltre possibile AWS CloudFormation utilizzarlo per creare componenti e altre AWS risorse a partire dai modelli. Per ulteriori informazioni, consulta [Cos'è AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) e [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-greengrassv2-componentversion.html) nella *Guida per l'utente di AWS CloudFormation *.
**Topics**
+ [Pubblica un componente (GDK CLI)](#publish-component-gdk-cli)
+ [Pubblica un componente (comandi shell)](#publish-component-shell-commands)
## Pubblica un componente (GDK CLI)
Segui le istruzioni in questa sezione per pubblicare un componente utilizzando la CLI GDK. La CLI GDK carica gli artefatti della build in un bucket S3, aggiorna l' URIs artefatto nella ricetta e crea il componente dalla ricetta. Si specifica il bucket S3 e la regione da utilizzare nel file di configurazione [GDK CLI](gdk-cli-configuration-file.md).
Se utilizzi GDK CLI v1.1.0 o versione successiva, puoi specificare `--bucket` l'argomento per specificare il bucket S3 in cui la CLI di GDK carica gli artefatti del componente. Se non specifichi questo argomento, la CLI di GDK viene caricata nel bucket S3 il cui nome `bucket-region-accountId` è, *bucket* dove *region* e sono i valori `gdk-config.json` in cui specifichi e rappresenta il tuo ID. *accountId* Account AWS La CLI GDK crea il bucket se non esiste.
**Importante**
Per impostazione predefinita, i ruoli principali dei dispositivi non consentono l'accesso ai bucket S3. Se è la prima volta che utilizzi questo bucket S3, devi aggiungere le autorizzazioni al ruolo per consentire ai dispositivi principali di recuperare gli artefatti dei componenti da questo bucket S3. 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).
**Per pubblicare un componente Greengrass (GDK CLI)**
1. Apri la cartella del componente in un prompt dei comandi o in un terminale.
1. Se non l'hai già fatto, crea il componente Greengrass. Il comando [component build](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-build) produce una ricetta e degli artefatti nella `greengrass-build` cartella della cartella del componente. Esegui il comando seguente.
```
gdk component build
```
1. Pubblica il componente in. Cloud AWS Il comando [component publish](greengrass-development-kit-cli-component.md#greengrass-development-kit-cli-component-publish) carica gli artefatti del componente su Amazon S3 e aggiorna la ricetta del componente con l'URI di ogni elemento. Quindi, crea il componente nel servizio. AWS IoT Greengrass
**Nota**
AWS IoT Greengrass calcola il digest di ogni artefatto quando si crea il componente. Ciò significa che non puoi modificare i file degli artefatti nel tuo bucket S3 dopo aver creato un componente. Se lo fai, le distribuzioni che includono questo componente falliranno, perché il file digest non corrisponde. Se modificate un file di artefatti, dovete creare una nuova versione del componente.
Se specifichi `NEXT_PATCH` la versione del componente nel file di configurazione della CLI di GDK, la CLI di GDK utilizza la versione della patch successiva che non esiste già nel servizio. AWS IoT Greengrass
Esegui il comando seguente.
```
gdk component publish
```
L'output indica la versione del componente creata dalla CLI GDK.
Dopo aver pubblicato il componente, puoi distribuirlo sui dispositivi principali. Per ulteriori informazioni, consulta [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md).
## Pubblica un componente (comandi shell)
Utilizzate la procedura seguente per pubblicare un componente utilizzando i comandi di shell e AWS Command Line Interface (AWS CLI). Quando pubblicate un componente, effettuate le seguenti operazioni:
1. Pubblica gli artefatti dei componenti in un bucket S3.
1. Aggiungi l'URI Amazon S3 di ogni elemento alla ricetta del componente.
1. Crea una versione del componente AWS IoT Greengrass dalla ricetta del componente.
**Nota**
Ogni versione del componente che carichi deve essere unica. Assicurati di caricare la versione corretta del componente, perché non puoi modificarla dopo averla caricata.
Puoi seguire questi passaggi per pubblicare un componente dal tuo computer di sviluppo o dal tuo dispositivo principale Greengrass.
**Per pubblicare un componente (comandi shell)**
1. Se il componente utilizza una versione esistente nel AWS IoT Greengrass servizio, è necessario modificare la versione del componente. Apri la ricetta in un editor di testo, incrementa la versione e salva il file. Scegliete una nuova versione che rifletta le modifiche apportate al componente.
**Nota**
AWS IoT Greengrass utilizza versioni semantiche per i componenti. *Le versioni semantiche seguono una delle principali.* *minore*. sistema di numerazione delle *patch*. Ad esempio, la versione `1.0.0` rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la [specifica della versione semantica](https://semver.org/).
1. Se il componente presenta artefatti, procedi come segue:
1. Pubblica gli artefatti del componente in un bucket S3 nel tuo. Account AWS
**Suggerimento**
Ti consigliamo di includere il nome e la versione del componente nel percorso dell'artefatto nel bucket S3. Questo schema di denominazione può aiutarti a mantenere gli artefatti utilizzati dalle versioni precedenti del componente, in modo da poter continuare a supportare le versioni precedenti del componente.
Esegui il comando seguente per pubblicare un file di artefatti in un bucket S3. Sostituisci amzn-s3-demo-bucket con il nome del bucket e sostituiscilo con il percorso del file degli artefatti. *artifacts/com.example.HelloWorld/1.0.0/artifact.py*
```
aws s3 cp artifacts/com.example.HelloWorld/1.0.0/artifact.py s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
**Importante**
Per impostazione predefinita, i ruoli principali dei dispositivi non consentono l'accesso ai bucket S3. Se è la prima volta che utilizzi questo bucket S3, devi aggiungere le autorizzazioni al ruolo per consentire ai dispositivi principali di recuperare gli artefatti dei componenti da questo bucket S3. 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).
1. Aggiungi un elenco denominato `Artifacts` alla ricetta del componente se non è presente. L'`Artifacts`elenco viene visualizzato in ogni manifesto, che definisce i requisiti del componente su ciascuna piattaforma supportata (o i requisiti predefiniti del componente per tutte le piattaforme).
1. Aggiungi ogni elemento all'elenco degli artefatti o aggiorna l'URI degli artefatti esistenti. L'URI Amazon S3 è composto dal nome del bucket e dal percorso dell'oggetto artefatto nel bucket. Amazon S3 dei tuoi artefatti URIs dovrebbe essere simile all'esempio seguente.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/artifact.py
```
Dopo aver completato questi passaggi, la ricetta dovrebbe avere un `Artifacts` elenco simile al seguente.
------
#### [ JSON ]
```
{
...
"Manifests": [
{
"Lifecycle": {
...
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py",
"Unarchive": "NONE"
}
]
}
]
}
```
**Nota**
È possibile aggiungere l'`"Unarchive": "ZIP"`opzione per un artefatto ZIP per configurare il software AWS IoT Greengrass Core per decomprimere l'artefatto quando il componente viene distribuito.
------
#### [ YAML ]
```
...
Manifests:
- Lifecycle:
...
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/MyGreengrassComponent/1.0.0/artifact.py
Unarchive: NONE
```
**Nota**
È possibile utilizzare l'`Unarchive: ZIP`opzione per configurare il software AWS IoT Greengrass Core per decomprimere un elemento ZIP quando il componente viene distribuito. [Per ulteriori informazioni su come utilizzare gli elementi ZIP in un componente, consultate la variabile di ricetta artifacts:DecompressedPath.](component-recipe-reference.md#component-recipe-artifacts-decompressed-path)
------
Per ulteriori informazioni sulle ricette, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
1. Utilizzate la AWS IoT Greengrass console per creare un componente dal file di ricetta.
Eseguite il comando seguente per creare il componente da un file di ricette. Questo comando crea il componente e lo pubblica come AWS IoT Greengrass componente privato nel tuo Account AWS. Sostituisci *path/to/recipeFile* con il percorso del file delle ricette.
```
aws greengrassv2 create-component-version --inline-recipe fileb://path/to/recipeFile
```
Copia il codice `arn` dalla risposta per verificare lo stato del componente nel passaggio successivo.
**Nota**
AWS IoT Greengrass calcola il digest di ogni artefatto quando si crea il componente. Ciò significa che non puoi modificare i file degli artefatti nel tuo bucket S3 dopo aver creato un componente. Se lo fai, le distribuzioni che includono questo componente falliranno, perché il file digest non corrisponde. Se modificate un file di artefatti, dovete creare una nuova versione del componente.
1. Ogni componente del AWS IoT Greengrass servizio ha uno stato. Eseguite il comando seguente per confermare lo stato della versione del componente pubblicata in questa procedura. Sostituisci *com.example.HelloWorld* e *1.0.0* con la versione del componente da interrogare. Sostituisci `arn` con l'ARN del passaggio precedente.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorld:versions:1.0.0"
```
L'operazione restituisce una risposta che contiene i metadati del componente. I metadati contengono un `status` oggetto che contiene lo stato del componente e gli eventuali errori, se applicabile.
Quando lo stato del componente è`DEPLOYABLE`, è possibile distribuire il componente sui dispositivi. Per ulteriori informazioni, consulta [Implementazione AWS IoT Greengrass dei componenti sui dispositivi](manage-deployments.md).
# Interagisci con AWS i servizi
I dispositivi core Greengrass utilizzano certificati X.509 a cui connettersi AWS IoT Core utilizzando i protocolli di autenticazione reciproca TLS. Questi certificati consentono ai dispositivi di interagire AWS IoT senza AWS credenziali, che in genere comprendono un ID della chiave di accesso e una chiave di accesso segreta. Altri AWS servizi richiedono AWS credenziali anziché certificati X.509 per richiamare le operazioni API sugli endpoint del servizio. AWS IoT Core dispone di un provider di credenziali che consente ai dispositivi di utilizzare il certificato X.509 per autenticare le richieste. AWS Il provider di AWS IoT credenziali autentica i dispositivi utilizzando un certificato X.509 e rilascia AWS credenziali sotto forma di token di sicurezza temporaneo con privilegi limitati. I dispositivi possono utilizzare questo token per firmare e autenticare qualsiasi richiesta. AWS Ciò elimina la necessità di memorizzare AWS le credenziali sui dispositivi core Greengrass. *Per ulteriori informazioni, consulta [Autorizzazione delle chiamate dirette ai AWS servizi](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) nella Guida per gli AWS IoT Core sviluppatori.*
Per recuperare le credenziali da AWS IoT Greengrass, i dispositivi principali utilizzano un alias di ruolo che punta a un AWS IoT ruolo IAM. *Questo ruolo IAM è chiamato ruolo di scambio di token.* L'alias del ruolo e il ruolo di scambio di token vengono creati quando si installa il software AWS IoT Greengrass Core. Per specificare l'alias di ruolo utilizzato da un dispositivo principale, configura il `iotRoleAlias` parametro di. [Nucleo Greengrass](greengrass-nucleus-component.md)
Il fornitore di AWS IoT credenziali assume il ruolo di scambio di token per conto dell'utente per fornire AWS le credenziali ai dispositivi principali. Puoi associare policy IAM appropriate a questo ruolo per consentire ai tuoi dispositivi principali di accedere alle tue AWS risorse, ad esempio componenti, artefatti nei bucket S3. Per ulteriori informazioni su come configurare il ruolo di scambio di token, consulta. [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md)
I dispositivi core Greengrass archiviano AWS le credenziali in memoria e le credenziali scadono dopo un'ora per impostazione predefinita. Se il software AWS IoT Greengrass Core si riavvia, deve recuperare nuovamente le credenziali. È possibile utilizzare l'[UpdateRoleAlias](https://docs.aws.amazon.com/iot/latest/apireference/API_UpdateRoleAlias.html)operazione per configurare la durata della validità delle credenziali.
AWS IoT Greengrass fornisce un componente pubblico, il componente del servizio di scambio di token, che è possibile definire come dipendenza nel componente personalizzato dall'interazione con AWS i servizi. Il servizio di scambio di token fornisce al componente una variabile di ambiente che definisce l'URI di un server locale che fornisce AWS le credenziali. `AWS_CONTAINER_CREDENTIALS_FULL_URI` Quando crei un client AWS SDK, il client verifica la presenza di questa variabile di ambiente e si connette al server locale per recuperare AWS le credenziali e le utilizza per firmare le richieste API. Ciò consente di utilizzare AWS SDKs altri strumenti per chiamare i AWS servizi nei componenti. Per ulteriori informazioni, consulta [Servizio di scambio di token](token-exchange-service-component.md).
**Importante**
Il supporto per l'acquisizione di AWS credenziali in questo modo è stato aggiunto il 13 AWS SDKs luglio 2016. Il componente deve utilizzare una versione AWS SDK creata a partire da tale data. Per ulteriori informazioni, consulta [Using a support AWS SDK](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#task-iam-roles-minimum-sdk) nella *Amazon Elastic Container Service Developer Guide*.
Per acquisire AWS credenziali nel componente personalizzato, definiscilo `aws.greengrass.TokenExchangeService` come dipendenza nella ricetta del componente. La seguente ricetta di esempio definisce un componente che installa [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) ed esegue uno script Python che utilizza AWS le credenziali del servizio di scambio di token per elencare i bucket Amazon S3.
**Nota**
Per eseguire questo componente di esempio, il dispositivo deve disporre dell'autorizzazione. `s3:ListAllMyBuckets` Per ulteriori informazioni, consulta [Autorizza i dispositivi principali a interagire con i servizi AWS](device-service-role.md).
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses the token exchange service to list S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "python3 -u {artifacts:path}/list_s3_buckets.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"install": "pip3 install --user boto3",
"Run": "py -3 -u {artifacts:path}/list_s3_buckets.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.ListS3Buckets
ComponentVersion: '1.0.0'
ComponentDescription: A component that uses the token exchange service to list S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: '^2.0.0'
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install:
pip3 install --user boto3
Run: |-
python3 -u {artifacts:path}/list_s3_buckets.py
- Platform:
os: windows
Lifecycle:
install:
pip3 install --user boto3
Run: |-
py -3 -u {artifacts:path}/list_s3_buckets.py
```
------
Questo componente di esempio esegue il seguente script Python, `list_s3_buckets.py` che elenca i bucket Amazon S3.
```
import boto3
import os
try:
print("Creating boto3 S3 client...")
s3 = boto3.client('s3')
print("Successfully created boto3 S3 client")
except Exception as e:
print("Failed to create boto3 s3 client. Error: " + str(e))
exit(1)
try:
print("Listing S3 buckets...")
response = s3.list_buckets()
for bucket in response['Buckets']:
print(f'\t{bucket["Name"]}')
print("Successfully listed S3 buckets")
except Exception as e:
print("Failed to list S3 buckets. Error: " + str(e))
exit(1)
```
# Esegui un contenitore Docker
Puoi configurare AWS IoT Greengrass i componenti per eseguire un contenitore [Docker](https://www.docker.com/) da immagini archiviate nelle seguenti posizioni:
+ Archivi di immagini pubblici e privati in Amazon Elastic Container Registry (Amazon ECR)
+ Archivio pubblico di Docker Hub
+ Registro pubblico affidabile di Docker
+ Bucket S3
Nel componente personalizzato, includi l'URI dell'immagine Docker come artefatto per recuperare l'immagine ed eseguirla sul dispositivo principale. Per le immagini di Amazon ECR e Docker Hub, puoi utilizzare il componente [Docker Application Manager](docker-application-manager-component.md) per scaricare le immagini e gestire le credenziali per i repository Amazon ECR privati.
**Topics**
+ [Requisiti](#run-docker-container-requirements)
+ [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Esegui un contenitore Docker da un'immagine privata in Amazon ECR](#run-docker-container-private-ecr)
+ [Esegui un contenitore Docker da un'immagine in Amazon S3](#run-docker-container-s3)
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
+ [Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
+ [Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
## Requisiti
Per eseguire un contenitore Docker in un componente, è necessario quanto segue:
+ Un dispositivo principale Greengrass. Se non lo hai, consultare [Tutorial: Guida introduttiva a AWS IoT Greengrass V2](getting-started.md).
+ [Docker Engine](https://docs.docker.com/engine/) 1.9.1 o versione successiva installato sul dispositivo principale Greengrass. La versione 20.10 è l'ultima versione verificata per funzionare con il software Core. AWS IoT Greengrass È necessario installare Docker direttamente sul dispositivo principale prima di distribuire componenti che eseguono contenitori Docker.
**Suggerimento**
Puoi anche configurare il dispositivo principale per installare Docker Engine quando il componente viene installato. Ad esempio, lo script di installazione seguente installa Docker Engine prima di caricare l'immagine Docker. Questo script di installazione funziona su distribuzioni Linux basate su Debian, come Ubuntu. Se si configura il componente per installare Docker Engine con questo comando, potrebbe essere necessario impostarlo `true` nello script del ciclo di vita `RequiresPrivilege` per eseguire l'installazione e i comandi. `docker` Per ulteriori informazioni, consulta [AWS IoT Greengrass riferimento alla ricetta del componente](component-recipe-reference.md).
```
apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar
```
+ L'utente di sistema che esegue un componente del contenitore Docker deve disporre delle autorizzazioni di root o amministratore oppure è necessario configurare Docker per eseguirlo come utente non root o non amministratore.
+ Sui dispositivi Linux, puoi aggiungere un utente al gruppo senza il quale chiamare i comandi. `docker` `docker` `sudo`
+ Nei dispositivi Windows, è possibile aggiungere un utente al `docker-users` gruppo per richiamare `docker` comandi senza privilegi di amministratore.
------
#### [ Linux or Unix ]
Per aggiungere `ggc_user` al `docker` gruppo l'utente non root che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente.
```
sudo usermod -aG docker ggc_user
```
Per ulteriori informazioni, consulta [Gestire Docker come](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user) utente non root.
------
#### [ Windows Command Prompt (CMD) ]
Per aggiungere al `docker-users` gruppo`ggc_user`, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.
```
net localgroup docker-users ggc_user /add
```
------
#### [ Windows PowerShell ]
Per aggiungere al `docker-users` gruppo`ggc_user`, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.
```
Add-LocalGroupMember -Group docker-users -Member ggc_user
```
------
+ File a cui accede il componente del contenitore Docker [montato come volume](https://docs.docker.com/storage/volumes/) nel contenitore Docker.
+ Se [configuri il software AWS IoT Greengrass Core per utilizzare un proxy di rete](configure-greengrass-core-v2.md#configure-alpn-network-proxy), devi [configurare Docker per utilizzare lo stesso](https://docs.docker.com/network/proxy/) server proxy.
Oltre a questi requisiti, è necessario soddisfare anche i seguenti requisiti, se applicabili al proprio ambiente:
+ Per utilizzare [Docker Compose](https://docs.docker.com/compose/) per creare e avviare i tuoi contenitori Docker, installa Docker Compose sul tuo dispositivo principale Greengrass e carica il file Docker Compose in un bucket S3. È necessario archiviare il file Compose in un bucket S3 nello stesso ambiente del componente. Account AWS Regione AWS Per un esempio che utilizza il `docker-compose up` comando in un componente personalizzato, vedi. [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ [Se utilizzi un AWS IoT Greengrass proxy di rete, configura il demone Docker per utilizzare un server proxy.](https://docs.docker.com/network/proxy/)
+ Se le tue immagini Docker sono archiviate in Amazon ECR o Docker Hub, includi il componente [Docker component manager](docker-application-manager-component.md) come dipendenza nel tuo componente contenitore Docker. È necessario avviare il demone Docker sul dispositivo principale prima di distribuire il componente.
Inoltre, includi l'immagine come artefatti del componente URIs . L'immagine URIs deve essere nel formato `docker:registry/image[:tag|@digest]` illustrato negli esempi seguenti:
+ Immagine Amazon ECR privata: `docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]`
+ Immagine pubblica di Amazon ECR: `docker:public.ecr.aws/repository/image[:tag|@digest]`
+ Immagine pubblica di Docker Hub: `docker:name[:tag|@digest]`
Per ulteriori informazioni sull'esecuzione di contenitori Docker da immagini archiviate in archivi pubblici, consulta. [Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub](#run-docker-container-public-ecr-dockerhub)
+ Se le tue immagini Docker sono archiviate in un repository privato Amazon ECR, devi includere il componente del servizio di scambio di token come dipendenza nel componente contenitore Docker. Inoltre, il [ruolo del dispositivo Greengrass](device-service-role.md) deve consentire le `ecr:GetDownloadUrlForLayer` azioni`ecr:GetAuthorizationToken`, e`ecr:BatchGetImage`, come mostrato nell'esempio seguente di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in un repository privato Amazon ECR, consulta. [Esegui un contenitore Docker da un'immagine privata in Amazon ECR](#run-docker-container-private-ecr)
+ Per utilizzare le immagini Docker archiviate in un repository privato Amazon ECR, l'archivio privato deve trovarsi nello Regione AWS stesso dispositivo principale.
+ Se le immagini Docker o i file Compose sono archiviati in un bucket S3, il [ruolo del dispositivo Greengrass](device-service-role.md) deve consentire l'`s3:GetObject`autorizzazione per consentire ai dispositivi principali di scaricare le immagini come artefatti componenti, come mostrato nel seguente esempio di politica IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject"
],
"Resource": [
"*"
],
"Effect": "Allow"
}
]
}
```
------
Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in Amazon S3, consulta. [Esegui un contenitore Docker da un'immagine in Amazon S3](#run-docker-container-s3)
+ Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
+ [Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
+ [Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
## Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub
Questa sezione descrive come creare un componente personalizzato che utilizza Docker Compose per eseguire un contenitore Docker da immagini Docker archiviate in Amazon ECR e Docker Hub.
**Per eseguire un contenitore Docker utilizzando Docker Compose**
1. Crea e carica un file Docker Compose in un bucket Amazon S3. Assicurati che il [ruolo del dispositivo Greengrass](device-service-role.md) consenta l'`s3:GetObject`autorizzazione per consentire al dispositivo di accedere al file Compose. Il file Compose di esempio mostrato nell'esempio seguente include l'immagine Amazon CloudWatch Agent di Amazon ECR e l'immagine MySQL di Docker Hub.
```
version: "3"
services:
cloudwatchagent:
image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
mysql:
image: "mysql:8.0"
```
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo principale. AWS IoT Greengrass La ricetta di esempio mostrata nell'esempio seguente ha le seguenti proprietà:
+ Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass scaricare immagini dai repository pubblici di Amazon ECR e Docker Hub.
+ Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR pubblico.
+ Un elemento componente che specifica un'immagine Docker in un repository pubblico di Docker Hub.
+ Un elemento componente che specifica il file Docker Compose che include i contenitori per le immagini Docker che si desidera eseguire.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker-compose up](https://docs.docker.com/compose/reference/up/) per creare e avviare un contenitore dalle immagini specificate.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyDockerComposeComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
},
"Artifacts": [
{
"URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
},
{
"URI": "docker:mysql:8.0"
},
{
"URI": "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker-compose -f {artifacts:path}/docker-compose.yaml up
Artifacts:
- URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
- URI: "docker:mysql:8.0"
- URI: "s3://amzn-s3-demo-bucket/folder/docker-compose.yaml"
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
**Importante**
È necessario installare e avviare il demone Docker prima di distribuire il componente.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Quando il componente è pronto, caricalo su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
## Esegui un contenitore Docker da un'immagine privata in Amazon ECR
Questa sezione descrive come creare un componente personalizzato che esegue un contenitore Docker da un'immagine Docker archiviata in un repository privato in Amazon ECR.
**Per eseguire un contenitore Docker**
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:
+ Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass gestire le credenziali per scaricare immagini da archivi privati.
+ Il componente del servizio di scambio di token come dipendenza. Questo componente consente di AWS IoT Greengrass recuperare AWS le credenziali per interagire con Amazon ECR.
+ Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR privato.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker run](https://docs.docker.com/engine/reference/commandline/run/) per creare e avviare un contenitore dall'immagine.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyPrivateDockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.DockerApplicationManager": {
"VersionRequirement": "~2.0.0"
},
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "~2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"Run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
},
"Artifacts": [
{
"URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.DockerApplicationManager:
VersionRequirement: ~2.0.0
aws.greengrass.TokenExchangeService:
VersionRequirement: ~2.0.0
Manifests:
- Platform:
os: all
Lifecycle:
Run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
Artifacts:
- URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
**Importante**
È necessario installare e avviare il demone Docker prima di distribuire il componente.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Carica il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
## Esegui un contenitore Docker da un'immagine in Amazon S3
Questa sezione descrive come eseguire un contenitore Docker in un componente da un'immagine Docker archiviata in Amazon S3.
**Per eseguire un contenitore Docker in un componente da un'immagine in Amazon S3**
1. Esegui il comando [docker save](https://docs.docker.com/engine/reference/commandline/save/) per creare un backup di un contenitore Docker. Fornisci questo backup come elemento componente su cui eseguire il contenitore. AWS IoT Greengrass Sostituisci *hello-world* con il nome dell'immagine e sostituisci *hello-world.tar* con il nome del file di archivio da creare.
```
docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
1. [Crea un componente personalizzato](create-components.md) sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:
+ Uno script di installazione del ciclo di vita che utilizza [docker load](https://docs.docker.com/engine/reference/commandline/load/) per caricare un'immagine Docker da un archivio.
+ Uno script di esecuzione del ciclo di vita che utilizza [docker run](https://docs.docker.com/engine/reference/commandline/run/) per creare e avviare un contenitore dall'immagine. L'`--rm`opzione pulisce il contenitore quando esce.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
```
------
**Nota**
Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:
[Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
[Usa AWS le credenziali nei componenti del contenitore Docker (Linux)](#docker-container-token-exchange-service)
[Usa lo stream manager nei componenti del contenitore Docker (Linux)](#docker-container-stream-manager)
1. [Testa il componente](test-components.md) per verificare che funzioni come previsto.
Dopo aver distribuito il componente localmente, puoi eseguire il comando [docker container](https://docs.docker.com/engine/reference/commandline/container_ls/) ls per verificare che il contenitore funzioni.
```
docker container ls
```
1. Quando il componente è pronto, carica l'archivio di immagini Docker in un bucket S3 e aggiungi il relativo URI alla ricetta del componente. Quindi, puoi caricare il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta [Pubblica componenti da distribuire sui tuoi dispositivi principali](publish-components.md).
Al termine, la ricetta del componente dovrebbe essere simile all'esempio seguente.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.MyS3DockerComponent",
"ComponentVersion": "1.0.0",
"ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
"ComponentPublisher": "Amazon",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": {
"Script": "docker load -i {artifacts:path}/hello-world.tar"
},
"Run": {
"Script": "docker run --rm hello-world"
}
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
- Platform:
os: linux
Lifecycle:
install:
Script: docker load -i {artifacts:path}/hello-world.tar
Run:
Script: docker run --rm hello-world
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar
```
------
## Usa la comunicazione tra processi nei componenti del contenitore Docker
È possibile utilizzare la libreria di comunicazione interprocesso (IPC) di Greengrass SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti Greengrass e. AWS IoT Core Per ulteriori informazioni, consulta [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).
Per utilizzare IPC in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:
+ Montate il socket IPC nel contenitore. Il nucleo Greengrass fornisce il percorso del file socket IPC nella variabile di ambiente. `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
+ Imposta le variabili `SVCUID` e di `AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT` ambiente sui valori che il nucleo Greengrass fornisce ai componenti. Il componente utilizza queste variabili di ambiente per autenticare le connessioni al nucleo Greengrass.
**Example Ricetta di esempio: pubblica un messaggio MQTT su AWS IoT Core (Python)**
La seguente ricetta definisce un componente contenitore Docker di esempio su cui pubblica un messaggio MQTT. AWS IoT Core La ricetta ha le seguenti proprietà:
+ Una politica di autorizzazione (`accessControl`) che consente al componente di pubblicare messaggi MQTT su tutti gli AWS IoT Core argomenti. Per ulteriori informazioni, vedere [Autorizza i componenti a eseguire operazioni IPC](interprocess-communication.md#ipc-authorization-policies) Autorizzazione [IPC AWS IoT Core MQTT](ipc-iot-core-mqtt.md#ipc-iot-core-mqtt-authorization).
+ Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`-v`argomento monta il socket IPC Greengrass nel contenitore.
+ I primi due `-e` argomenti impostano le variabili di ambiente richieste nel contenitore Docker.
+ `-e`Gli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.PublishToIoTCore",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"topic": "test/topic/java",
"message": "Hello, World!",
"qos": "1",
"accessControl": {
"aws.greengrass.ipc.mqttproxy": {
"com.example.python.docker.PublishToIoTCore:pubsub:1": {
"policyDescription": "Allows access to publish to IoT Core on all topics.",
"operations": [
"aws.greengrass#PublishToIoTCore"
],
"resources": [
"*"
]
}
}
}
}
},
"Manifests": [
{
"Platform": {
"os": "all"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
"Run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
topic: 'test/topic/java'
message: 'Hello, World!'
qos: '1'
accessControl:
aws.greengrass.ipc.mqttproxy:
'com.example.python.docker.PublishToIoTCore:pubsub:1':
policyDescription: Allows access to publish to IoT Core on all topics.
operations:
- 'aws.greengrass#PublishToIoTCore'
resources:
- '*'
Manifests:
- Platform:
os: all
Lifecycle:
install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
Run: |
docker run \
-v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e SVCUID \
-e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
-e MQTT_TOPIC="{configuration:/topic}" \
-e MQTT_MESSAGE="{configuration:/message}" \
-e MQTT_QOS="{configuration:/qos}" \
--rm publish-to-iot-core
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar
```
## Usa AWS le credenziali nei componenti del contenitore Docker (Linux)
È possibile utilizzare il [componente del servizio di scambio di token](token-exchange-service-component.md) per interagire con AWS i servizi nei componenti Greengrass. Questo componente fornisce AWS le credenziali derivanti dal [ruolo di scambio di token](device-service-role.md) del dispositivo principale utilizzando un server container locale. Per ulteriori informazioni, consulta [Interagisci con AWS i servizi](interact-with-aws-services.md).
**Nota**
L'esempio in questa sezione funziona solo su dispositivi core Linux.
Per utilizzare AWS le credenziali del servizio di scambio di token in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:
+ Fornisci l'accesso alla rete host utilizzando l'argomento. `--network=host` Questa opzione consente al contenitore Docker di connettersi al servizio di scambio di token locale per recuperare AWS le credenziali. Questo argomento funziona solo su Docker per Linux.
**avvertimento**
Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta [Network: host](https://docs.docker.com/engine/reference/run/#network-host) nella *documentazione Docker*.
+ Imposta le variabili `AWS_CONTAINER_CREDENTIALS_FULL_URI` e di `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente sui valori che il nucleo Greengrass fornisce ai componenti. AWS SDKs utilizzate queste variabili di ambiente per recuperare AWS le credenziali.
**Example Ricetta di esempio: elenca i bucket S3 in un componente contenitore Docker (Python)**
La seguente ricetta definisce un esempio di componente del contenitore Docker che elenca i bucket S3 presenti nel tuo. Account AWS La ricetta ha le seguenti proprietà:
+ Il componente del servizio di scambio di token come dipendenza. Questa dipendenza consente al componente di recuperare le AWS credenziali per interagire con altri servizi. AWS
+ Un elemento componente che specifica un'immagine Docker come archivio tar in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`--network=host`argomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al servizio di scambio di token.
+ L'`-e`argomento imposta le variabili di ambiente richieste nel contenitore Docker.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.ListS3Buckets",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.TokenExchangeService": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.TokenExchangeService:
VersionRequirement: ^2.0.0
DependencyType: HARD
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e AWS_CONTAINER_CREDENTIALS_FULL_URI \
--rm list-s3-buckets
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar
```
## Usa lo stream manager nei componenti del contenitore Docker (Linux)
È possibile utilizzare il [componente stream manager](stream-manager-component.md) per gestire i flussi di dati nei componenti Greengrass. Questo componente consente di elaborare flussi di dati e trasferire dati IoT ad alto volume a. Cloud AWS AWS IoT Greengrass fornisce un SDK per la gestione dello stream che puoi utilizzare per interagire con il componente stream manager. Per ulteriori informazioni, consulta [Gestisci i flussi di dati sui dispositivi core Greengrass](manage-data-streams.md).
**Nota**
L'esempio in questa sezione funziona solo su dispositivi core Linux.
Per utilizzare lo stream manager SDK in un componente del contenitore Docker, devi eseguire il contenitore Docker con i seguenti parametri:
+ Fornisci l'accesso alla rete host utilizzando l'argomento. `--network=host` Questa opzione consente al contenitore Docker di interagire con il componente stream manager tramite una connessione TLS locale. Questo argomento funziona solo su Docker per Linux
**avvertimento**
Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta [Network: host](https://docs.docker.com/engine/reference/run/#network-host) nella *documentazione Docker*.
+ Se configurate il componente stream manager per richiedere l'autenticazione, che è il comportamento predefinito, impostate la variabile di `AWS_CONTAINER_CREDENTIALS_FULL_URI` ambiente sul valore che il nucleo Greengrass fornisce ai componenti. Per ulteriori informazioni, consulta la configurazione dello [stream manager](stream-manager-component.md#stream-manager-component-configuration).
+ Se configuri il componente stream manager per utilizzare una porta non predefinita, usa la [comunicazione tra processi (IPC)](interprocess-communication.md) per ottenere la porta dalla configurazione del componente stream manager. È necessario eseguire il contenitore Docker con opzioni aggiuntive per utilizzare IPC. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Connect allo stream manager nel codice dell'applicazione](use-stream-manager-in-custom-components.md#connect-to-stream-manager)
+ [Usa la comunicazione tra processi nei componenti del contenitore Docker](#docker-container-ipc)
**Example Ricetta di esempio: trasmetti un file a un bucket S3 in un componente contenitore Docker (Python)**
La seguente ricetta definisce un esempio di componente contenitore Docker che crea un file e lo trasmette a un bucket S3. La ricetta ha le seguenti proprietà:
+ Il componente stream manager come dipendenza. Questa dipendenza consente al componente di utilizzare lo stream manager SDK per interagire con il componente stream manager.
+ Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.
+ Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.
+ Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando [Docker run](https://docs.docker.com/engine/reference/run/) ha i seguenti argomenti:
+ L'`--network=host`argomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al componente stream manager.
+ Il primo `-e` argomento imposta la variabile di `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente richiesta nel contenitore Docker.
+ `-e`Gli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.
+ L'`-v`argomento monta la [cartella di lavoro](component-recipe-reference.md#component-recipe-work-path) del componente nel contenitore. Questo esempio crea un file nella cartella di lavoro per caricare quel file su Amazon S3 utilizzando stream manager.
+ L'`--rm`argomento pulisce il contenitore quando esce.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.python.docker.StreamFileToS3",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0",
"DependencyType": "HARD"
}
},
"ComponentConfiguration": {
"DefaultConfiguration": {
"bucketName": ""
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
"Run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
}
]
}
]
}
```
```
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: ^2.0.0
DependencyType: HARD
ComponentConfiguration:
DefaultConfiguration:
bucketName: ''
Manifests:
- Platform:
os: linux
Lifecycle:
install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
Run: |
docker run \
--network=host \
-e AWS_CONTAINER_AUTHORIZATION_TOKEN \
-e BUCKET_NAME="{configuration:/bucketName}" \
-e WORK_PATH="{work:path}" \
-v {work:path}:{work:path} \
--rm stream-file-to-s3
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar
```
# AWS IoT Greengrass riferimento alla ricetta del componente
La ricetta del componente è un file che definisce i dettagli, le dipendenze, gli artefatti e i cicli di vita di un componente. Il *ciclo* di vita del componente specifica i comandi da eseguire per installare, eseguire e spegnere il componente, ad esempio. Il AWS IoT Greengrass core utilizza i cicli di vita definiti nella ricetta per installare ed eseguire i componenti. Il AWS IoT Greengrass servizio utilizza la ricetta per identificare le dipendenze e gli artefatti da distribuire sui dispositivi principali quando si distribuisce il componente.
Nella ricetta, puoi definire dipendenze e cicli di vita unici per ogni piattaforma supportata da un componente. È possibile utilizzare questa funzionalità per distribuire un componente su dispositivi con più piattaforme che hanno requisiti diversi. Puoi anche utilizzarla per AWS IoT Greengrass impedire l'installazione di un componente su dispositivi che non lo supportano.
Ogni ricetta contiene un elenco di *manifesti*. Ogni manifesto specifica una serie di requisiti della piattaforma, il ciclo di vita e gli artefatti da utilizzare per i dispositivi principali la cui piattaforma soddisfa tali requisiti. Il dispositivo principale utilizza il primo manifesto con i requisiti di piattaforma che il dispositivo soddisfa. Specificate un manifesto senza requisiti di piattaforma che corrisponda a qualsiasi dispositivo principale.
Puoi anche specificare un ciclo di vita globale che non si trova in un manifesto. Nel ciclo di vita globale, è possibile utilizzare *chiavi di selezione* che identificano le sottosezioni del ciclo di vita. Quindi, potete specificare queste chiavi di selezione all'interno di un manifesto per utilizzare quelle sezioni del ciclo di vita globale oltre al ciclo di vita del manifesto. Il dispositivo principale utilizza le chiavi di selezione del manifesto solo se il manifesto non definisce un ciclo di vita. È possibile utilizzare la `all` selezione in un manifesto per abbinare le sezioni del ciclo di vita globale senza chiavi di selezione.
Dopo aver selezionato un manifesto corrispondente al dispositivo principale, il software AWS IoT Greengrass Core effettua le seguenti operazioni per identificare le fasi del ciclo di vita da utilizzare:
+ Se il manifesto selezionato definisce un ciclo di vita, il dispositivo principale utilizza quel ciclo di vita.
+ Se il manifesto selezionato non definisce un ciclo di vita, il dispositivo principale utilizza il ciclo di vita globale. Il dispositivo principale esegue le seguenti operazioni per identificare quali sezioni del ciclo di vita globale utilizzare:
+ Se il manifesto definisce le chiavi di selezione, il dispositivo principale utilizza le sezioni del ciclo di vita globale che contengono le chiavi di selezione del manifesto.
+ Se il manifesto non definisce le chiavi di selezione, il dispositivo principale utilizza le sezioni del ciclo di vita globale che non dispongono di chiavi di selezione. Questo comportamento è equivalente a un manifesto che definisce la `all` selezione.
**Importante**
Un dispositivo principale deve soddisfare almeno i requisiti di piattaforma di un manifesto per installare il componente. Se nessun manifesto corrisponde al dispositivo principale, il software AWS IoT Greengrass Core non installa il componente e la distribuzione fallisce.
È possibile definire ricette in formato [JSON](https://en.wikipedia.org/wiki/JSON) o [YAML](https://en.wikipedia.org/wiki/YAML). La sezione degli esempi di ricette include ricette in ogni formato.
**Topics**
+ [Convalida delle ricette](#recipe-validation)
+ [Formato della ricetta](#recipe-format)
+ [Variabili di ricetta](#recipe-variables)
+ [Esempi di ricette](#recipe-examples)
## Convalida delle ricette
Greengrass convalida la ricetta di un componente JSON o YAML durante la creazione di una versione del componente. Questa convalida della ricetta verifica la presenza di errori comuni nella composizione dei componenti JSON o YAML al fine di prevenire potenziali problemi di implementazione. La convalida verifica la presenza di errori comuni (ad esempio virgole, parentesi e campi mancanti) e verifica che la ricetta sia ben formata.
Se ricevi un messaggio di errore di convalida della ricetta, controlla la ricetta per eventuali virgole, parentesi o campi mancanti. [Verifica che non manchi nessun campo esaminando il formato della ricetta.](#recipe-format)
## Formato della ricetta
Quando si definisce una ricetta per un componente, si specificano le seguenti informazioni nel documento della ricetta. La stessa struttura si applica alle ricette nei formati YAML e JSON.
`RecipeFormatVersion`
La versione modello per la ricetta. Scegliete la seguente opzione:
+ `2020-01-25`
`ComponentName`
Il nome del componente definito da questa ricetta. Il nome del componente deve essere univoco Account AWS in ogni regione.
**Suggerimenti**
+ Utilizza il formato di nome di dominio inverso per evitare la collisione dei nomi all'interno della tua azienda. Ad esempio, se la tua azienda possiede `example.com` e lavori a un progetto di energia solare, puoi assegnare un nome al tuo componente Hello World. `com.example.solar.HelloWorld` Questo aiuta a evitare le collisioni tra i nomi dei componenti all'interno dell'azienda.
+ Evitate il `aws.greengrass` prefisso nei nomi dei componenti. AWS IoT Greengrass utilizza questo prefisso per i [componenti pubblici](public-components.md) che fornisce. Se scegli lo stesso nome di un componente pubblico, il componente sostituisce quel componente. Quindi, AWS IoT Greengrass fornisce il componente anziché il componente pubblico quando distribuisce componenti che dipendono da quel componente pubblico. Questa funzionalità consente di ignorare il comportamento dei componenti pubblici, ma può anche interrompere altri componenti se non si intende sovrascrivere un componente pubblico.
`ComponentVersion`
La versione del componente. Il valore massimo per i valori principali, secondari e di patch è 999999.
AWS IoT Greengrass utilizza versioni semantiche per i componenti. *Le versioni semantiche seguono una delle principali.* *minore*. sistema di numerazione delle *patch*. Ad esempio, la versione `1.0.0` rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la [specifica della versione semantica](https://semver.org/).
`ComponentDescription`
(Facoltativo) La descrizione del componente.
`ComponentPublisher`
L'editore o l'autore del componente.
`ComponentConfiguration`
(Facoltativo) Un oggetto che definisce la configurazione o i parametri per il componente. Si definisce la configurazione predefinita e quindi, quando si distribuisce il componente, è possibile specificare l'oggetto di configurazione da fornire al componente. La configurazione dei componenti supporta parametri e strutture annidati. Questo oggetto contiene le seguenti informazioni:
`DefaultConfiguration`
Un oggetto che definisce la configurazione predefinita per il componente. Tu definisci la struttura di questo oggetto.
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.
`ComponentDependencies`
(Facoltativo) Un dizionario di oggetti che definiscono ciascuno una dipendenza dal componente. La chiave per ogni oggetto identifica il nome della dipendenza del componente. AWS IoT Greengrass installa le dipendenze dei componenti quando il componente viene installato. AWS IoT Greengrass attende l'inizio delle dipendenze prima di avviare il componente. Ogni oggetto contiene le seguenti informazioni:
`VersionRequirement`
Il vincolo di versione semantica in stile npm che definisce le versioni dei componenti compatibili per questa dipendenza. È possibile specificare una versione o un intervallo di versioni. Per ulteriori informazioni, consulta il calcolatore della [versione semantica di npm](https://semver.npmjs.com/).
`DependencyType`
(Facoltativo) Il tipo di questa dipendenza. Scegliere tra le seguenti opzioni.
+ `SOFT`: il componente non si riavvia se la dipendenza cambia stato.
+ `HARD`: il componente viene riavviato se la dipendenza cambia stato.
L’impostazione predefinita è `HARD`.
`ComponentType`
(Facoltativo) Il tipo di componente.
Non è consigliabile specificare il tipo di componente in una ricetta. AWS IoT Greengrass imposta il tipo automaticamente quando crei un componente.
Il tipo può essere uno dei seguenti tipi:
+ `aws.greengrass.generic`— Il componente esegue comandi o fornisce artefatti.
+ `aws.greengrass.lambda`— Il componente esegue una funzione Lambda utilizzando il componente [Lambda](lambda-launcher-component.md) launcher. Il `ComponentSource` parametro specifica l'ARN della funzione Lambda eseguita da questo componente.
Non è consigliabile utilizzare questa opzione, poiché è impostata da AWS IoT Greengrass quando si crea un componente da una funzione Lambda. Per ulteriori informazioni, consulta [Esegui AWS Lambda funzioni](run-lambda-functions.md).
+ `aws.greengrass.plugin`— Il componente viene eseguito nella stessa Java Virtual Machine (JVM) del nucleo Greengrass. Se si distribuisce o si riavvia un componente del plug-in, il nucleo Greengrass si riavvia.
I componenti del plug-in utilizzano lo stesso file di registro del nucleo Greengrass. Per ulteriori informazioni, consulta [Monitora AWS IoT Greengrass i registri](monitor-logs.md).
Non è consigliabile utilizzare questa opzione nelle ricette dei componenti, poiché è destinata ai componenti AWS forniti e scritti in Java che si interfacciano direttamente con il nucleo Greengrass. Per ulteriori informazioni su quali componenti pubblici sono plugin, consulta. [AWS-componenti forniti](public-components.md)
+ `aws.greengrass.nucleus`— Il componente del nucleo. Per ulteriori informazioni, consulta [Nucleo Greengrass](greengrass-nucleus-component.md).
Non è consigliabile utilizzare questa opzione nelle ricette dei componenti. È destinato al componente Greengrass nucleus, che fornisce la funzionalità minima del AWS IoT Greengrass software Core.
L'impostazione predefinita è `aws.greengrass.generic` quando si crea un componente da una ricetta o `aws.greengrass.lambda` quando si crea un componente da una funzione Lambda.
Per ulteriori informazioni, consulta [Tipi di componenti](develop-greengrass-components.md#component-types).
`ComponentSource`
(Facoltativo) L'ARN della funzione Lambda eseguita da un componente.
Non è consigliabile specificare l'origine del componente in una ricetta. AWS IoT Greengrass imposta questo parametro per te quando crei un componente da una funzione Lambda. Per ulteriori informazioni, consulta [Esegui AWS Lambda funzioni](run-lambda-functions.md).
`Manifests`
Un elenco di oggetti che definiscono ciascuno il ciclo di vita del componente, i parametri e i requisiti per una piattaforma. Se un dispositivo principale soddisfa i requisiti di piattaforma di più manifesti, AWS IoT Greengrass utilizza il primo manifest a cui il dispositivo principale soddisfa. Per garantire che i dispositivi principali utilizzino il manifesto corretto, definisci innanzitutto i manifesti con requisiti di piattaforma più rigorosi. Un manifesto che si applica a tutte le piattaforme deve essere l'ultimo manifesto dell'elenco.
Un dispositivo principale deve soddisfare i requisiti di piattaforma di almeno un manifesto per installare il componente. Se nessun manifesto corrisponde al dispositivo principale, il software AWS IoT Greengrass Core non installa il componente e la distribuzione fallisce.
Ogni oggetto contiene le seguenti informazioni:
`Name`
(Facoltativo) Un nome descrittivo per la piattaforma definita da questo manifesto.
Se ometti questo parametro, AWS IoT Greengrass crea un nome dalla piattaforma `os` e`architecture`.
`Platform`
(Facoltativo) Un oggetto che definisce la piattaforma a cui si applica questo manifesto. Omettete questo parametro per definire un manifesto applicabile a tutte le piattaforme.
Questo oggetto specifica le coppie chiave-valore relative alla piattaforma su cui viene eseguito un dispositivo principale. Quando si distribuisce questo componente, il software AWS IoT Greengrass Core confronta queste coppie chiave-valore con gli attributi della piattaforma sul dispositivo principale. Il software AWS IoT Greengrass Core definisce sempre `os` e `architecture` potrebbe definire attributi aggiuntivi. È possibile specificare attributi di piattaforma personalizzati per un dispositivo principale quando si distribuisce il componente Greengrass nucleus. Per ulteriori informazioni, consulta il [parametro platform overrides del componente](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides) [Greengrass](greengrass-nucleus-component.md) nucleus.
Per ogni coppia chiave-valore, è possibile specificare uno dei seguenti valori:
+ Un valore esatto, ad esempio o. `linux` `windows` I valori esatti devono iniziare con una lettera o un numero.
+ `*`, che corrisponde a qualsiasi valore. Ciò corrisponde anche quando un valore non è presente.
+ Un'espressione regolare in stile Java, ad esempio. `/windows|linux/` L'espressione regolare deve iniziare e terminare con un carattere barra (). `/` Ad esempio, l'espressione regolare `/.+/` corrisponde a qualsiasi valore non vuoto.
Questo oggetto contiene le seguenti informazioni:
`runtime`
Il [runtime Greengrass nucleus](https://docs.aws.amazon.com/greengrass/v2/developerguide/how-it-works.html#concept-overview) per la piattaforma supportata da questo manifest. Quando si definiscono più manifesti con platform`runtime`, i valori di runtime supportati in una ricetta sono `aws_nucleus_lite` e solo. `*` Per scegliere come target un dispositivo classico, il campo di runtime NON DEVE essere specificato nella ricetta. I runtime Greengrass Nucleus supportati includono i seguenti valori:
+ `*`
+ `aws_nucleus_lite`
`os`
(Facoltativo) Il nome del sistema operativo per la piattaforma supportata da questo manifesto. Le piattaforme comuni includono i seguenti valori:
+ `linux`
+ `windows`
+ `darwin` (macOS)
`architecture`
(Facoltativo) L'architettura del processore per la piattaforma supportata da questo manifesto. Le architetture comuni includono i seguenti valori:
+ `amd64`
+ `arm`
+ `aarch64`
+ `x86`
`architecture.detail`
(Facoltativo) I dettagli dell'architettura del processore per la piattaforma supportata da questo manifesto. I dettagli comuni dell'architettura includono i seguenti valori:
+ `arm61`
+ `arm71`
+ `arm81`
`key`
(Facoltativo) Un attributo di piattaforma definito per questo manifesto. Sostituisci *Key* con il nome dell'attributo della piattaforma. Il software AWS IoT Greengrass Core abbina questo attributo della piattaforma alle coppie chiave-valore specificate nella configurazione del componente Greengrass nucleus. Per ulteriori informazioni, consulta il [parametro platform overrides del componente](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides) [Greengrass](greengrass-nucleus-component.md) nucleus.
Utilizzate il formato inverso dei nomi di dominio per evitare la collisione dei nomi all'interno della vostra azienda. Ad esempio, se la tua azienda possiede `example.com` e lavori a un progetto radiofonico, puoi assegnare un nome a un attributo di piattaforma personalizzato. `com.example.radio.RadioModule` Questo aiuta a evitare le collisioni tra i nomi degli attributi della piattaforma all'interno dell'azienda.
Ad esempio, è possibile definire un attributo di piattaforma per specificare un manifesto diverso in base al modulo radio disponibile su un dispositivo principale. `com.example.radio.RadioModule` Ogni manifesto può includere diversi artefatti che si applicano a diverse configurazioni hardware, in modo da distribuire il set minimo di software sul dispositivo principale.
`Lifecycle`
Un oggetto o una stringa che definisce come installare ed eseguire il componente sulla piattaforma definita da questo manifest. È inoltre possibile definire un [ciclo di vita globale](#global-lifecycle-definition) applicabile a tutte le piattaforme. Il dispositivo principale utilizza il ciclo di vita globale solo se il manifesto da utilizzare non specifica un ciclo di vita.
Questo ciclo di vita viene definito all'interno di un manifesto. Le fasi del ciclo di vita specificate qui si applicano solo alla piattaforma definita da questo manifesto. È inoltre possibile definire un [ciclo di vita globale applicabile a tutte](#global-lifecycle-definition) le piattaforme.
Questo oggetto o stringa contiene le seguenti informazioni:
`Setenv`
(Facoltativo) Un dizionario di variabili di ambiente da fornire a tutti gli script del ciclo di vita. È possibile sovrascrivere queste variabili di ambiente `Setenv` in ogni script del ciclo di vita.
`install`
(Facoltativo) Un oggetto o una stringa che definisce lo script da eseguire durante l'installazione del componente. Il software AWS IoT Greengrass Core esegue inoltre questa fase del ciclo di vita a ogni avvio del software.
Se lo `install` script termina con un codice di successo, il componente entra nello stato. `INSTALLED`
Questo oggetto o stringa contiene le seguenti informazioni:
`Script`
Lo script da eseguire.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Skipif`
(Facoltativo) Il controllo per determinare se eseguire o meno lo script. È possibile definire se nel percorso è presente un eseguibile o se esiste un file. Se l'output è vero, il software AWS IoT Greengrass Core salta il passaggio. Scegliete uno dei seguenti controlli:
+ `onpath runnable`— Controlla se un runnable è presente sul percorso di sistema. Ad esempio, usa **onpath python3** per saltare questo passaggio del ciclo di vita se Python 3 è disponibile.
+ `exists file`— Controlla se esiste un file. Ad esempio, utilizzare **exists /tmp/my-configuration.db** per saltare questa fase del ciclo di vita, se `/tmp/my-configuration.db` presente.
`Timeout`
(Facoltativo) Il periodo di tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Impostazione predefinita: 120 secondi
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`run`
(Facoltativo) Un oggetto o una stringa che definisce lo script da eseguire all'avvio del componente.
Il componente entra nello `RUNNING` stato quando viene eseguita questa fase del ciclo di vita. Se lo `run` script termina con un codice di successo, il componente entra nello stato. `STOPPING` Se viene specificato uno `shutdown` script, viene eseguito; altrimenti il componente entra nello `FINISHED` stato.
I componenti che dipendono da questo componente vengono avviati durante l'esecuzione di questa fase del ciclo di vita. Per eseguire un processo in background, ad esempio un servizio utilizzato dai componenti dipendenti, utilizzate invece la fase del `startup` ciclo di vita.
Quando distribuisci componenti con un `run` ciclo di vita, il dispositivo principale può segnalare che l'implementazione è completa non appena viene eseguito questo script del ciclo di vita. Di conseguenza, l'implementazione può essere completa e riuscita anche se lo script del `run` ciclo di vita fallisce subito dopo l'esecuzione. Se desideri che lo stato della distribuzione dipenda dal risultato dello script di avvio del componente, utilizza invece la fase del `startup` ciclo di vita.
È possibile definirne solo uno `startup` o `run` il ciclo di vita.
Questo oggetto o stringa contiene le seguenti informazioni:
`Script`
Lo script da eseguire.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Skipif`
(Facoltativo) Il controllo per determinare se eseguire o meno lo script. È possibile definire se nel percorso è presente un eseguibile o se esiste un file. Se l'output è vero, il software AWS IoT Greengrass Core salta il passaggio. Scegliete uno dei seguenti controlli:
+ `onpath runnable`— Controlla se un runnable è presente sul percorso di sistema. Ad esempio, usa **onpath python3** per saltare questo passaggio del ciclo di vita se Python 3 è disponibile.
+ `exists file`— Controlla se esiste un file. Ad esempio, utilizzare **exists /tmp/my-configuration.db** per saltare questa fase del ciclo di vita, se `/tmp/my-configuration.db` presente.
`Timeout`
(Facoltativo) Il periodo di tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Per impostazione predefinita, questa fase del ciclo di vita non prevede il timeout. Se ometti questo timeout, lo `run` script viene eseguito fino alla sua chiusura.
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`startup`
(Facoltativo) Un oggetto o una stringa che definisce il processo in background da eseguire all'avvio del componente.
Viene utilizzato `startup` per eseguire un comando che deve terminare correttamente o aggiornare lo stato del componente `RUNNING` prima che i componenti dipendenti possano essere avviati. Utilizzate l'operazione [UpdateState](ipc-component-lifecycle.md#ipc-operation-updatestate)IPC per impostare lo stato del componente su `RUNNING` o `ERRORED` quando il componente avvia uno script che non esce. Ad esempio, è possibile definire un `startup` passaggio che avvia il processo MySQL con. `/etc/init.d/mysqld start`
Il componente entra nello `STARTING` stato quando viene eseguita questa fase del ciclo di vita. Se lo `startup` script termina con un codice di successo, il componente entra nello stato. `RUNNING` Quindi, i componenti dipendenti possono avviarsi.
Quando si distribuiscono componenti con un `startup` ciclo di vita, il dispositivo principale può segnalare l'implementazione come completa dopo la chiusura o la segnalazione dello stato di questo script del ciclo di vita. In altre parole, lo stato della distribuzione è valido `IN_PROGRESS` fino alla chiusura o alla segnalazione di uno stato da parte degli script di avvio di tutti i componenti.
È possibile definirne solo uno `startup` o `run` un ciclo di vita.
Questo oggetto o stringa contiene le seguenti informazioni:
`Script`
Lo script da eseguire.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Skipif`
(Facoltativo) Il controllo per determinare se eseguire o meno lo script. È possibile definire se nel percorso è presente un eseguibile o se esiste un file. Se l'output è vero, il software AWS IoT Greengrass Core salta il passaggio. Scegliete uno dei seguenti controlli:
+ `onpath runnable`— Controlla se un runnable è presente sul percorso di sistema. Ad esempio, usa **onpath python3** per saltare questo passaggio del ciclo di vita se Python 3 è disponibile.
+ `exists file`— Controlla se esiste un file. Ad esempio, utilizzare **exists /tmp/my-configuration.db** per saltare questa fase del ciclo di vita, se `/tmp/my-configuration.db` presente.
`Timeout`
(Facoltativo) Il periodo di tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Impostazione predefinita: 120 secondi
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`shutdown`
(Facoltativo) Un oggetto o una stringa che definisce lo script da eseguire quando il componente si spegne. Utilizzate il ciclo di vita di spegnimento per eseguire il codice che desiderate eseguire quando il componente è nello stato in cui si trova. `STOPPING` Il ciclo di vita dello spegnimento può essere utilizzato per interrompere un processo avviato dagli script o. `startup` `run`
Se avviate un processo in background in`startup`, utilizzate il `shutdown` passaggio per interrompere tale processo quando il componente si spegne. Ad esempio, è possibile definire un `shutdown` passaggio che interrompa il processo MySQL con. `/etc/init.d/mysqld stop`
Lo `shutdown` script viene eseguito dopo che il componente è entrato nello `STOPPING` stato. Se lo script viene completato correttamente, il componente entra nello `FINISHED` stato.
Questo oggetto o stringa contiene le seguenti informazioni:
`Script`
Lo script da eseguire.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Skipif`
(Facoltativo) Il controllo per determinare se eseguire o meno lo script. È possibile definire se nel percorso è presente un eseguibile o se esiste un file. Se l'output è vero, il software AWS IoT Greengrass Core salta il passaggio. Scegliete uno dei seguenti controlli:
+ `onpath runnable`— Controlla se un runnable è presente sul percorso di sistema. Ad esempio, usa **onpath python3** per saltare questo passaggio del ciclo di vita se Python 3 è disponibile.
+ `exists file`— Controlla se esiste un file. Ad esempio, utilizzare **exists /tmp/my-configuration.db** per saltare questa fase del ciclo di vita, se `/tmp/my-configuration.db` presente.
`Timeout`
(Facoltativo) Il periodo di tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Impostazione predefinita: 15 secondi.
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`recover`
(Facoltativo) Un oggetto o una stringa che definisce lo script da eseguire quando il componente rileva un errore.
Questo passaggio viene eseguito quando un componente entra nello `ERRORED` stato. Se il componente diventa `ERRORED` tre volte senza riprendersi correttamente, passa allo `BROKEN` stato del componente. Per riparare un `BROKEN` componente, è necessario distribuirlo nuovamente.
Questo oggetto o stringa contiene le seguenti informazioni:
`Script`
Lo script da eseguire.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Skipif`
(Facoltativo) Il controllo per determinare se eseguire o meno lo script. È possibile definire se nel percorso è presente un eseguibile o se esiste un file. Se l'output è vero, il software AWS IoT Greengrass Core salta il passaggio. Scegliete uno dei seguenti controlli:
+ `onpath runnable`— Controlla se un runnable è presente sul percorso di sistema. Ad esempio, usa **onpath python3** per saltare questo passaggio del ciclo di vita se Python 3 è disponibile.
+ `exists file`— Controlla se esiste un file. Ad esempio, utilizzare **exists /tmp/my-configuration.db** per saltare questa fase del ciclo di vita, se `/tmp/my-configuration.db` presente.
`Timeout`
(Facoltativo) Il periodo di tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Default: 60 secondi.
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`bootstrap`
(Facoltativo) Un oggetto o una stringa che definisce uno script che richiede il riavvio del software AWS IoT Greengrass Core o del dispositivo principale. Ciò consente di sviluppare un componente che esegua un riavvio dopo aver installato gli aggiornamenti del sistema operativo o gli aggiornamenti di runtime, ad esempio.
Per installare aggiornamenti o dipendenze che non richiedono il riavvio del software o del dispositivo AWS IoT Greengrass Core, utilizza il ciclo di vita di [installazione](#install-lifecycle-definition).
Questa fase del ciclo di vita viene eseguita prima della fase del ciclo di vita di installazione nei seguenti casi, quando il software Core distribuisce il componente: AWS IoT Greengrass
+ Il componente viene distribuito sul dispositivo principale per la prima volta.
+ La versione del componente cambia.
+ Lo script di bootstrap cambia a seguito di un aggiornamento della configurazione del componente.
Dopo che il software AWS IoT Greengrass Core ha completato la fase di bootstrap per tutti i componenti che hanno una fase di bootstrap in una distribuzione, il software si riavvia.
È necessario configurare il software AWS IoT Greengrass Core come servizio di sistema per riavviare il software AWS IoT Greengrass Core o il dispositivo principale. Se non configuri il software AWS IoT Greengrass Core come servizio di sistema, il software non verrà riavviato. Per ulteriori informazioni, consulta [Configurare il nucleo Greengrass come servizio di sistema](configure-greengrass-core-v2.md#configure-system-service).
Questo oggetto o stringa contiene le seguenti informazioni:
`BootstrapOnRollback`
Quando questa funzionalità è abilitata, `BootstrapOnRollback` verrà eseguita solo per i componenti che hanno completato o tentato di eseguire le fasi del ciclo di vita di bootstrap come parte di una distribuzione di destinazione non riuscita. Questa funzionalità è disponibile per le versioni 2.12.0 e successive di Greengrass nucleus.
(Facoltativo) È possibile eseguire le fasi del ciclo di vita di bootstrap come parte di una distribuzione di rollback. Se imposti questa opzione su`true`, verranno eseguite le fasi del ciclo di vita di bootstrap definite all'interno di una distribuzione di rollback. Quando una distribuzione fallisce, la versione precedente del ciclo di vita di bootstrap del componente verrà eseguita nuovamente durante una distribuzione di rollback.
L’impostazione predefinita è `false`.
`Script`
Lo script da eseguire. Il codice di uscita di questo script definisce l'istruzione di riavvio. Utilizza i seguenti codici di uscita:
+ `0`— Non riavviare il software AWS IoT Greengrass Core o il dispositivo principale. Il software AWS IoT Greengrass Core continua a riavviarsi dopo l'avvio di tutti i componenti.
+ `100`— Richiesta di riavvio del software AWS IoT Greengrass Core.
+ `101`— Richiesta di riavvio del dispositivo principale.
I codici di uscita da 100 a 199 sono riservati a comportamenti speciali. Altri codici di uscita rappresentano errori di script.
`RequiresPrivilege`
(Facoltativo) È possibile eseguire lo script con i privilegi di root. Se impostate questa opzione su`true`, il software AWS IoT Greengrass Core esegue questo script del ciclo di vita come root anziché come utente di sistema configurato per eseguire questo componente. L’impostazione predefinita è `false`.
`Timeout`
(Facoltativo) Il tempo massimo, in secondi, che lo script può essere eseguito prima che il software AWS IoT Greengrass Core termini il processo.
Impostazione predefinita: 120 secondi
`Setenv`
(Facoltativo) Il dizionario delle variabili di ambiente da fornire allo script. Queste variabili di ambiente sostituiscono le variabili fornite. `Lifecycle.Setenv`
`Selections`
(Facoltativo) Un elenco di chiavi di selezione che specificano le sezioni del [ciclo di vita globale](#global-lifecycle-definition) da eseguire per questo manifesto. Nel ciclo di vita globale, è possibile definire le fasi del ciclo di vita con chiavi di selezione a qualsiasi livello per selezionare le sottosezioni del ciclo di vita. Quindi, il dispositivo principale utilizza le sezioni che corrispondono ai tasti di selezione in questo manifesto. Per ulteriori informazioni, consulta gli esempi del [ciclo di vita globale](#global-lifecycle-definition).
Il dispositivo principale utilizza le selezioni dal ciclo di vita globale solo se questo manifesto non definisce un ciclo di vita.
È possibile specificare la chiave di `all` selezione per eseguire sezioni del ciclo di vita globale che non dispongono di chiavi di selezione.
`Artifacts`
(Facoltativo) Un elenco di oggetti che definiscono ciascuno un artefatto binario per il componente sulla piattaforma definito da questo manifesto. Ad esempio, è possibile definire codice o immagini come artefatti.
Quando il componente viene distribuito, il software AWS IoT Greengrass Core scarica l'elemento in una cartella sul dispositivo principale. È inoltre possibile definire gli artefatti come file di archivio che il software estrae dopo averli scaricati.
È possibile utilizzare [le variabili di ricetta](#recipe-variables) per ottenere i percorsi delle cartelle in cui gli artefatti si installano sul dispositivo principale.
+ File normali: utilizzate la [variabile artifacts:path recipe](#component-recipe-artifacts-path) per ottenere il percorso della cartella che contiene gli artefatti. Ad esempio, specificate `{artifacts:path}/my_script.py` in una ricetta di ottenere il percorso di un artefatto che ha l'URI. `s3://amzn-s3-demo-bucket/path/to/my_script.py`
+ Archivi estratti: utilizzate la [variabile di ricetta artifacts:DecompressedPath per ottenere il percorso della cartella che contiene](#component-recipe-artifacts-decompressed-path) gli elementi dell'archivio estratti. Il software AWS IoT Greengrass Core estrae ogni archivio in una cartella con lo stesso nome dell'archivio. Ad esempio, specificate `{artifacts:decompressedPath}/my_archive/my_script.py` in una ricetta il percorso dell'`my_script.py`elemento dell'archivio contenente l'URI. `s3://amzn-s3-demo-bucket/path/to/my_archive.zip`
Quando sviluppate un componente con un elemento di archivio su un dispositivo centrale locale, potreste non avere un URI per quell'artefatto. Per testare il componente con un'`Unarchive`opzione che estrae l'artefatto, specificate un URI in cui il nome del file corrisponda al nome del file dell'artefatto di archivio. È possibile specificare l'URI in cui si prevede di caricare l'elemento dell'archivio oppure è possibile specificare un nuovo URI segnaposto. Ad esempio, per estrarre l'`my_archive.zip`artefatto durante una distribuzione locale, è possibile specificare. `s3://amzn-s3-demo-bucket/my_archive.zip`
Ogni oggetto contiene le seguenti informazioni:
`Uri`
L'URI di un artefatto in un bucket S3. Il software AWS IoT Greengrass Core recupera l'artefatto da questo URI quando il componente viene installato, a meno che l'artefatto non esista già sul dispositivo. Ogni elemento deve avere un nome di file univoco all'interno di ogni manifesto.
`Unarchive`
(Facoltativo) Il tipo di archivio da decomprimere. Seleziona una delle opzioni seguenti:
+ `NONE`— Il file non è un archivio da decomprimere. Il software AWS IoT Greengrass Core installa l'artefatto in una cartella sul dispositivo principale. Puoi usare la [variabile artifacts:path recipe per ottenere il percorso](#component-recipe-artifacts-path) di questa cartella.
+ `ZIP`— Il file è un archivio ZIP. Il software AWS IoT Greengrass Core estrae l'archivio in una cartella con lo stesso nome dell'archivio. È possibile utilizzare la [variabile di ricetta Artifacts:DecompressedPath per ottenere il percorso](#component-recipe-artifacts-decompressed-path) della cartella che contiene questa cartella.
L’impostazione predefinita è `NONE`.
`Permission`
(Facoltativo) Un oggetto che definisce le autorizzazioni di accesso da impostare per questo file di artefatti. È possibile impostare il permesso di lettura e il permesso di esecuzione.
Non è possibile impostare l'autorizzazione di scrittura, poiché il software AWS IoT Greengrass Core non consente ai componenti di modificare i file degli artefatti nella cartella artifacts. Per modificare un file di artefatti in un componente, copiatelo in un'altra posizione o pubblicate e distribuite un nuovo file di artefatti.
Se definite un artefatto come un archivio da decomprimere, il software AWS IoT Greengrass Core imposta queste autorizzazioni di accesso sui file che decomprime dall'archivio. Il software AWS IoT Greengrass Core imposta le autorizzazioni di accesso della cartella su for e. `ALL` `Read` `Execute` Ciò consente ai componenti di visualizzare i file decompressi nella cartella. Per impostare le autorizzazioni su singoli file dall'archivio, è possibile impostare le autorizzazioni nello script del ciclo di vita di [installazione](#install-lifecycle-definition).
Questo oggetto contiene le seguenti informazioni:
`Read`
(Facoltativo) L'autorizzazione di lettura da impostare per questo file di artefatti. Per consentire ad altri componenti di accedere a questo elemento, ad esempio i componenti che dipendono da questo componente, specificare. `ALL` Seleziona una delle opzioni seguenti:
+ `NONE`— Il file non è leggibile.
+ `OWNER`— Il file è leggibile dall'utente di sistema configurato per eseguire questo componente.
+ `ALL`— Il file è leggibile da tutti gli utenti.
L’impostazione predefinita è `OWNER`.
`Execute`
(Facoltativo) L'autorizzazione di esecuzione da impostare per questo file di artefatti. L'`Execute`autorizzazione implica l'`Read`autorizzazione. Ad esempio, se si specifica `ALL` for`Execute`, tutti gli utenti possono leggere ed eseguire questo file di artefatti.
Seleziona una delle opzioni seguenti:
+ `NONE`— Il file non è eseguibile.
+ `OWNER`— Il file può essere eseguito dall'utente di sistema configurato per eseguire il componente.
+ `ALL`— Il file può essere eseguito da tutti gli utenti.
L’impostazione predefinita è `NONE`.
`Digest`
(Sola lettura) L'hash del digest crittografico dell'artefatto. Quando create un componente, AWS IoT Greengrass utilizza un algoritmo di hash per calcolare un hash del file dell'artefatto. Quindi, quando si distribuisce il componente, il nucleo di Greengrass calcola l'hash dell'elemento scaricato e lo confronta con questo digest per verificare l'artefatto prima dell'installazione. Se l'hash non corrisponde al digest, la distribuzione fallisce.
Se impostate questo parametro, AWS IoT Greengrass sostituisce il valore impostato al momento della creazione del componente.
`Algorithm`
(Sola lettura) L'algoritmo hash AWS IoT Greengrass utilizzato per calcolare l'hash digest dell'artefatto.
Se impostate questo parametro, AWS IoT Greengrass sostituisce il valore impostato durante la creazione del componente.
`Lifecycle`
Un oggetto che definisce come installare ed eseguire il componente. Il dispositivo principale utilizza il ciclo di vita globale solo se il [manifesto](#manifest-definition) da utilizzare non specifica un ciclo di vita.
Questo ciclo di vita viene definito all'esterno di un manifesto. È inoltre possibile definire un [ciclo di vita del manifesto](#manifest-lifecycle-definition) che si applica alle piattaforme che corrispondono a quel manifesto.
Nel ciclo di vita globale, è possibile specificare i cicli di vita che vengono eseguiti per determinate [chiavi di selezione](#manifest-selections-definition) specificate in ogni manifesto. Le chiavi di selezione sono stringhe che identificano le sezioni del ciclo di vita globale da eseguire per ogni manifesto.
La chiave `all` di selezione è l'impostazione predefinita per qualsiasi sezione senza chiave di selezione. Ciò significa che è possibile specificare la chiave di `all` selezione in un manifesto per eseguire le sezioni del ciclo di vita globale senza chiavi di selezione. Non è necessario specificare la chiave di `all` selezione nel ciclo di vita globale.
Se un manifesto non definisce un ciclo di vita o chiavi di selezione, per impostazione predefinita il dispositivo principale utilizza la selezione. `all` Ciò significa che in questo caso, il dispositivo principale utilizza le sezioni del ciclo di vita globale che non utilizzano chiavi di selezione.
Questo oggetto contiene le stesse informazioni del [ciclo di vita del manifesto](#manifest-lifecycle-definition), ma è possibile specificare chiavi di selezione a qualsiasi livello per selezionare sottosezioni del ciclo di vita.
Si consiglia di utilizzare solo lettere minuscole per ogni chiave di selezione per evitare conflitti tra le chiavi di selezione e le chiavi del ciclo di vita. Le chiavi del ciclo di vita iniziano con una lettera maiuscola.
**Example Esempio di ciclo di vita globale con tasti di selezione di primo livello**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script: command3
```
**Example Esempio di ciclo di vita globale con tasti di selezione di livello inferiore**
```
Lifecycle:
install:
Script:
key1: command1
key2: command2
all: command3
```
**Example Esempio di ciclo di vita globale con più livelli di tasti di selezione**
```
Lifecycle:
key1:
install:
SkipIf: either onpath executable or exists file
Script: command1
key2:
install:
Script: command2
all:
install:
Script:
key3: command3
key4: command4
all: command5
```
## Variabili di ricetta
Le variabili di ricetta espongono le informazioni del componente e del nucleo correnti da utilizzare nelle ricette. Ad esempio, potete utilizzare una variabile recipe per passare i parametri di configurazione dei componenti a un'applicazione eseguita in uno script del ciclo di vita.
È possibile utilizzare le variabili di ricetta nelle seguenti sezioni delle ricette dei componenti:
+ Definizioni del ciclo di vita.
+ Definizioni di configurazione dei componenti, se si utilizza [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 o versione successiva e si imposta l'opzione di configurazione su. [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)`true` [È inoltre possibile utilizzare le variabili recipes quando si distribuiscono gli aggiornamenti della configurazione dei componenti.](update-component-configurations.md#merge-configuration-update-recipe-variables)
Le variabili Recipe utilizzano la `{recipe_variable}` sintassi. Le parentesi arricciate indicano una variabile di ricetta.
AWS IoT Greengrass supporta le seguenti variabili di ricetta:
`component_dependency_name:configuration:json_pointer`
Il valore di un parametro di configurazione per il componente definito da questa ricetta o per un componente da cui dipende questo componente.
È possibile utilizzare questa variabile per fornire un parametro a uno script eseguito nel ciclo di vita del componente.
AWS IoT Greengrass supporta questa variabile di ricetta solo nelle definizioni del ciclo di vita dei componenti.
Questa variabile di ricetta ha i seguenti input:
+ `component_dependency_name`— (Facoltativo) Il nome della dipendenza del componente da interrogare. Omettete questo segmento per interrogare il componente definito da questa ricetta. È possibile specificare solo dipendenze dirette.
+ `json_pointer`— Il puntatore JSON al valore di configurazione da valutare. I puntatori JSON iniziano con una barra in avanti. `/` Per identificare un valore in una configurazione di componenti annidati, utilizzate forward slashes (`/`) per separare le chiavi per ogni livello della configurazione. È possibile utilizzare un numero come chiave per specificare un indice in un elenco. Per ulteriori informazioni, consulta la specifica del [puntatore JSON](https://tools.ietf.org/html/rfc6901).
AWS IoT Greengrass Core utilizza i puntatori JSON per le ricette in formato YAML.
Il puntatore JSON può fare riferimento ai seguenti tipi di nodi:
+ Un nodo di valore. AWS IoT Greengrass Core sostituisce la variabile recipe con la rappresentazione in formato stringa del valore. I valori nulli vengono convertiti in una `null` stringa.
+ Un nodo oggetto. AWS IoT Greengrass Core sostituisce la variabile recipe con la rappresentazione in stringa JSON serializzata di quell'oggetto.
+ Nessun nodo. AWS IoT Greengrass Core non sostituisce la variabile recipe.
Ad esempio, la variabile `{configuration:/Message}` recipe recupera il valore della `Message` chiave nella configurazione del componente. La variabile `{com.example.MyComponentDependency:configuration:/server/port}` recipe recupera il valore di `port` nell'oggetto di `server` configurazione di una dipendenza del componente.
`component_dependency_name:artifacts:path`
Il percorso principale degli artefatti per il componente definito da questa ricetta o per un componente da cui dipende questo componente.
Quando un componente viene installato, AWS IoT Greengrass copia gli artefatti del componente nella cartella esposta da questa variabile. È possibile utilizzare questa variabile per identificare la posizione di uno script da eseguire nel ciclo di vita del componente, ad esempio.
La cartella in questo percorso è di sola lettura. Per modificare i file degli artefatti, copiate i file in un'altra posizione, ad esempio nella directory di lavoro corrente (o). `$PWD` `.` Quindi, modificate i file lì.
Per leggere o eseguire un artefatto da una dipendenza di un componente, l'artefatto o l'autorizzazione di `Read` tale elemento devono essere. `Execute` `ALL` Per ulteriori informazioni, consultate le [autorizzazioni degli artefatti definite](#component-artifact-permission) nella ricetta del componente.
Questa variabile di ricetta ha i seguenti input:
+ `component_dependency_name`— (Facoltativo) Il nome della dipendenza del componente da interrogare. Omettete questo segmento per interrogare il componente definito da questa ricetta. È possibile specificare solo dipendenze dirette.
`component_dependency_name:artifacts:decompressedPath`
Il percorso principale degli elementi dell'archivio decompresso per il componente definito da questa ricetta o per un componente da cui dipende questo componente.
Quando un componente viene installato, AWS IoT Greengrass decomprime gli elementi dell'archivio del componente nella cartella esposta da questa variabile. È possibile utilizzare questa variabile per identificare la posizione di uno script da eseguire nel ciclo di vita del componente, ad esempio.
Ogni elemento viene decompresso in una cartella all'interno del percorso decompresso, dove la cartella ha lo stesso nome dell'elemento meno la sua estensione. Ad esempio, un elemento ZIP denominato viene decompresso nella cartella. `models.zip` `{artifacts:decompressedPath}/models`
La cartella in questo percorso è di sola lettura. Per modificare i file degli artefatti, copiate i file in un'altra posizione, ad esempio nella directory di lavoro corrente (o). `$PWD` `.` Quindi, modificate i file lì.
Per leggere o eseguire un artefatto da una dipendenza di un componente, l'artefatto o l'autorizzazione di `Read` tale elemento devono essere. `Execute` `ALL` Per ulteriori informazioni, consultate le [autorizzazioni degli artefatti definite](#component-artifact-permission) nella ricetta del componente.
Questa variabile di ricetta ha i seguenti input:
+ `component_dependency_name`— (Facoltativo) Il nome della dipendenza del componente da interrogare. Omettete questo segmento per interrogare il componente definito da questa ricetta. È possibile specificare solo dipendenze dirette.
`component_dependency_name:work:path`
Questa funzionalità è disponibile per la versione 2.0.4 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus.
Il percorso di lavoro per il componente definito da questa ricetta o per un componente da cui dipende questo componente. Il valore di questa variabile di ricetta è equivalente all'output della variabile di `$PWD` ambiente e del comando [pwd](https://en.wikipedia.org/wiki/Pwd) quando viene eseguito dal contesto del componente.
È possibile utilizzare questa variabile recipe per condividere file tra un componente e una dipendenza.
La cartella in questo percorso è leggibile e scrivibile dal componente definito da questa ricetta e da altri componenti che funzionano come lo stesso utente e gruppo.
Questa variabile di ricetta ha i seguenti input:
+ `component_dependency_name`— (Facoltativo) Il nome della dipendenza del componente da interrogare. Omettete questo segmento per interrogare il componente definito da questa ricetta. È possibile specificare solo dipendenze dirette.
`kernel:rootPath`
Il percorso AWS IoT Greengrass principale principale.
`iot:thingName`
Questa funzionalità è disponibile per la versione 2.3.0 e successive del componente [Greengrass](greengrass-nucleus-component.md) nucleus.
Il nome del dispositivo principale. AWS IoT
## Esempi di ricette
Puoi fare riferimento ai seguenti esempi di ricette per aiutarti a creare ricette per i tuoi componenti.
AWS IoT Greengrass cura un indice dei componenti di Greengrass, chiamato Greengrass Software Catalog. Questo catalogo tiene traccia dei componenti Greengrass sviluppati dalla comunità Greengrass. Da questo catalogo, puoi scaricare, modificare e distribuire componenti per creare le tue applicazioni Greengrass. Per ulteriori informazioni, consulta [Componenti comunitari](greengrass-software-catalog.md).
**Topics**
+ [Ricetta dei componenti Hello World](#recipe-example-hello-world)
+ [Esempio di componente runtime Python](#recipe-example-python-runtime)
+ [Ricetta del componente che specifica diversi campi](#recipe-example-all-fields)
### Ricetta dei componenti Hello World
La seguente ricetta descrive un componente Hello World che esegue uno script Python. Questo componente supporta tutte le piattaforme e accetta un `Message` parametro che AWS IoT Greengrass passa come argomento allo script Python. Questa è la ricetta per il componente Hello World del [tutorial Getting started](getting-started.md).
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
### Esempio di componente runtime Python
La seguente ricetta descrive un componente che installa Python. Questo componente supporta dispositivi Linux a 64 bit.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.PythonRuntime",
"ComponentDescription": "Installs Python 3.7",
"ComponentPublisher": "Amazon",
"ComponentVersion": "3.7.0",
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": "apt-get update\napt-get install python3.7"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.PythonRuntime
ComponentDescription: Installs Python 3.7
ComponentPublisher: Amazon
ComponentVersion: '3.7.0'
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install: |
apt-get update
apt-get install python3.7
```
------
### Ricetta del componente che specifica diversi campi
La seguente ricetta del componente utilizza diversi campi di ricetta.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.FooService",
"ComponentDescription": "Complete recipe for AWS IoT Greengrass components",
"ComponentPublisher": "Amazon",
"ComponentVersion": "1.0.0",
"ComponentConfiguration": {
"DefaultConfiguration": {
"TestParam": "TestValue"
}
},
"ComponentDependencies": {
"BarService": {
"VersionRequirement": "^1.1.0",
"DependencyType": "SOFT"
},
"BazService": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "linux",
"architecture": "amd64"
},
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git"
},
"Setenv": {
"environment_variable1": "variable_value1",
"environment_variable2": "variable_value2"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.zip",
"Unarchive": "ZIP"
},
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world_linux.py"
}
]
},
{
"Lifecycle": {
"install": {
"Skipif": "onpath git",
"Script": "sudo apt-get install git",
"RequiresPrivilege": "true"
}
},
"Artifacts": [
{
"Uri": "s3://amzn-s3-demo-bucket/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.FooService
ComponentDescription: Complete recipe for AWS IoT Greengrass components
ComponentPublisher: Amazon
ComponentVersion: 1.0.0
ComponentConfiguration:
DefaultConfiguration:
TestParam: TestValue
ComponentDependencies:
BarService:
VersionRequirement: ^1.1.0
DependencyType: SOFT
BazService:
VersionRequirement: ^2.0.0
Manifests:
- Platform:
os: linux
architecture: amd64
Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
SetEnv:
environment_variable1: variable_value1
environment_variable2: variable_value2
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.zip'
Unarchive: ZIP
- Uri: 's3://amzn-s3-demo-bucket/hello_world_linux.py'
- Lifecycle:
install:
SkipIf: onpath git
Script: sudo apt-get install git
RequiresPrivilege: 'true'
Artifacts:
- Uri: 's3://amzn-s3-demo-bucket/hello_world.py'
```
------
# Riferimento alla variabile di ambiente del componente
Il software AWS IoT Greengrass Core imposta le variabili di ambiente quando esegue gli script del ciclo di vita per i componenti. Puoi inserire queste variabili di ambiente nei tuoi componenti per ottenere il nome dell'oggetto e la Regione AWS versione del nucleo di Greengrass. [Il software imposta anche le variabili di ambiente necessarie al componente per utilizzare [l'SDK di comunicazione tra processi e per interagire](interprocess-communication.md) con i servizi. AWS](interact-with-aws-services.md)
È inoltre possibile impostare variabili di ambiente personalizzate per gli script del ciclo di vita dei componenti. [Per ulteriori informazioni, consulta Setenv.](component-recipe-reference.md#lifecycle-setenv-definition)
Il software AWS IoT Greengrass Core imposta le seguenti variabili di ambiente:
`AWS_IOT_THING_NAME`
Il nome della AWS IoT cosa che rappresenta questo dispositivo principale Greengrass.
`AWS_REGION`
Il Regione AWS luogo in cui funziona questo dispositivo principale Greengrass.
AWS SDKs Utilizza questa variabile di ambiente per identificare la regione predefinita da utilizzare. Questa variabile è equivalente a`AWS_DEFAULT_REGION`.
`AWS_DEFAULT_REGION`
Il Regione AWS luogo in cui funziona questo dispositivo principale Greengrass.
AWS CLI Utilizza questa variabile di ambiente per identificare la regione predefinita da utilizzare. Questa variabile è equivalente a`AWS_REGION`.
`GGC_VERSION`
La versione del [componente Greengrass nucleus](greengrass-nucleus-component.md) che funziona su questo dispositivo principale Greengrass.
`GG_ROOT_CA_PATH`
[Questa funzionalità è disponibile per la versione 2.5.5 e successive del componente Greengrass nucleus.](greengrass-nucleus-component.md)
Il percorso verso il certificato root certificate authority (CA) utilizzato dal nucleo Greengrass.
`AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT`
Il percorso verso il socket IPC utilizzato dai componenti per comunicare con il AWS IoT Greengrass software Core. Per ulteriori informazioni, consulta [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).
`SVCUID`
Il token segreto utilizzato dai componenti per connettersi al socket IPC e comunicare con il software AWS IoT Greengrass Core. Per ulteriori informazioni, consulta [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_CONTAINER_AUTHORIZATION_TOKEN`
Il token segreto utilizzato dai componenti per recuperare le credenziali dal componente del servizio di [scambio di token](token-exchange-service-component.md).
`AWS_CONTAINER_CREDENTIALS_FULL_URI`
L'URI richiesto dai componenti per recuperare le credenziali dal componente del servizio di scambio di [token](token-exchange-service-component.md).