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à.
# AWS IoT Greengrass Comandi dell'interfaccia a riga di comando del Development Kit
L'interfaccia a riga di comando del AWS IoT Greengrass Development Kit (GDK CLI) fornisce un'interfaccia a riga di comando che puoi usare per creare, creare e pubblicare componenti Greengrass sul tuo computer di sviluppo. I comandi GDK CLI utilizzano il seguente formato.
```
gdk [arguments]
```
Quando [installi la CLI GDK](install-greengrass-development-kit-cli.md), il programma di installazione si `gdk` aggiunge al PATH in modo da poter eseguire la CLI GDK dalla riga di comando.
È possibile utilizzare i seguenti argomenti con qualsiasi comando:
+ Usa `-h` o `--help` per informazioni su un comando GDK CLI.
+ Usa `-v` o `--version` per vedere quale versione di GDK CLI è installata.
+ Usa `-d` o `--debug` per generare log dettagliati che puoi usare per eseguire il debug della CLI di GDK.
Questa sezione descrive i comandi GDK CLI e fornisce esempi per ogni comando. La sinossi di ogni comando mostra i relativi argomenti e il loro utilizzo. Gli argomenti opzionali sono indicati tra parentesi quadre.
**Topics**
+ [componente](greengrass-development-kit-cli-component.md)
+ [config](greengrass-development-kit-cli-config.md)
+ [test-e2e](greengrass-development-kit-cli-test.md)
# componente
Usa il `component` comando nell'interfaccia a riga di comando del AWS IoT Greengrass Development Kit (GDK CLI) per creare, creare e pubblicare componenti Greengrass personalizzati.
**Topics**
+ [init](#greengrass-development-kit-cli-component-init)
+ [build](#greengrass-development-kit-cli-component-build)
+ [pubblicazione](#greengrass-development-kit-cli-component-publish)
+ [elenco](#greengrass-development-kit-cli-component-list)
## init
Inizializza una cartella di componenti Greengrass da un modello di componente o da un componente della community.
[La CLI GDK recupera i componenti della community dal [Greengrass Software](greengrass-software-catalog.md) Catalog e i modelli di componenti dal AWS IoT Greengrass repository Component Templates in poi. GitHub](https://github.com/aws-greengrass/aws-greengrass-component-templates)
**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.
Se il componente utilizza il [sistema di compilazione zip](gdk-cli-configuration-file.md#gdk-cli-configuration-file-build-system), la CLI di GDK comprime determinati file nella 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` Nella ricetta del componente, il nome dell'artefatto zip deve corrispondere al nome della cartella del componente. 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.
Se inizializzi un modello o un componente della community che utilizza il sistema di compilazione zip in una cartella con un nome diverso dal modello o dal componente, devi modificare il nome dell'artefatto zip nella ricetta del componente. Aggiorna le `Lifecycle` definizioni `Artifacts` and in modo che il nome del file zip corrisponda al nome della cartella del componente. L'esempio seguente evidenzia il nome del file zip nelle `Lifecycle` definizioni `Artifacts` and.
```
{
...
"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}"
}
}
]
}
```
```
---
...
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}"
```
**Riepilogo**
```
$ gdk component init
[--language]
[--template]
[--repository]
[--name]
```
**Argomenti (inizializzati dal modello del componente)**
+ `-l`, `--language` — Il linguaggio di programmazione da utilizzare per il modello specificato.
È necessario specificare `--repository` o `--language` e`--template`.
+ `-t`, `--template` — Il modello di componente da utilizzare per un progetto di componente locale. Per visualizzare i modelli disponibili, utilizzate il comando [list](#greengrass-development-kit-cli-component-list).
È necessario specificare `--repository` o `--language` e`--template`.
+ `-n`, `--name` — (Facoltativo) Il nome della cartella locale in cui la CLI di GDK inizializza il componente. Specificate una cartella che non esiste. La CLI GDK crea la cartella per te.
Questa funzionalità è disponibile per GDK CLI v1.1.0 e versioni successive.
**Argomenti (inizializzati dal componente della community)**
+ `-r`, `--repository` — Il componente della community da archiviare nella cartella locale. Per visualizzare i componenti della community disponibili, utilizzate il comando [list](#greengrass-development-kit-cli-component-list).
È necessario specificare `--repository` o `--language` e`--template`.
+ `-n`, `--name` — (Facoltativo) Il nome della cartella locale in cui la CLI di GDK inizializza il componente. Specificate una cartella che non esiste. La CLI GDK crea la cartella per te.
Questa funzionalità è disponibile per GDK CLI v1.1.0 e versioni successive.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando per inizializzare una cartella di componenti dal modello Python Hello World.
```
$ gdk component init -l python -t HelloWorld
[2021-11-29 12:51:40] INFO - Initializing the project directory with a python component template - 'HelloWorld'.
[2021-11-29 12:51:40] INFO - Fetching the component template 'HelloWorld-python' from Greengrass Software Catalog.
```
L'esempio seguente mostra l'output prodotto quando si esegue questo comando per inizializzare una cartella di componenti da un componente della comunità.
```
$ gdk component init -r aws-greengrass-labs-database-influxdb
[2022-01-24 15:44:33] INFO - Initializing the project directory with a component from repository catalog - 'aws-greengrass-labs-database-influxdb'.
[2022-01-24 15:44:33] INFO - Fetching the component repository 'aws-greengrass-labs-database-influxdb' from Greengrass Software Catalog.
```
## build
Crea il codice sorgente di un componente in una ricetta e in artefatti da pubblicare sul servizio. AWS IoT Greengrass La CLI GDK esegue il sistema di compilazione specificato nel file di configurazione della [CLI di GDK](gdk-cli-configuration-file.md),. `gdk-config.json` È necessario eseguire questo comando nella stessa cartella in cui si trova il file. `gdk-config.json`
Quando esegui questo comando, la CLI GDK crea una ricetta e degli artefatti nella cartella `greengrass-build` della cartella dei componenti. La CLI GDK salva la ricetta nella cartella e salva `greengrass-build/recipes` gli artefatti nella cartella. `greengrass-build/artifacts/componentName/componentVersion`
Se utilizzi GDK CLI v1.1.0 o versione successiva, la ricetta del componente può specificare artefatti che esistono in un bucket S3 ma non nella cartella di build del componente locale. È possibile utilizzare questa funzionalità per ridurre l'utilizzo della larghezza di banda quando si sviluppano componenti con artefatti di grandi dimensioni, come i modelli di machine learning.
Dopo aver creato un componente, puoi eseguire una delle seguenti operazioni per testarlo su un dispositivo centrale Greengrass:
+ Se sviluppi su un dispositivo diverso da quello su cui esegui il software AWS IoT Greengrass Core, devi pubblicare il componente per distribuirlo su un dispositivo principale Greengrass. Pubblica il componente sul AWS IoT Greengrass servizio e distribuiscilo sul dispositivo principale Greengrass. Per ulteriori informazioni, vedete il comando [publish](#greengrass-development-kit-cli-component-build) e. [Creare distribuzione](create-deployments.md)
+ Se sviluppate sullo stesso dispositivo su cui eseguite il software AWS IoT Greengrass Core, potete pubblicare il componente sul AWS IoT Greengrass servizio da distribuire oppure potete creare una distribuzione locale per installare ed eseguire il componente. Per creare una distribuzione locale, usa la CLI di Greengrass. Per ulteriori informazioni, consulta [Interfaccia a riga di comando Greengrass](gg-cli.md) e [Testare AWS IoT Greengrass i componenti con distribuzioni locali](test-components.md). Quando crei la distribuzione locale, specifica `greengrass-build/recipes` come cartella recipes e `greengrass-build/artifacts` come cartella artifacts.
**Riepilogo**
```
$ gdk component build
```
**Arguments (Argomenti)**
Nessuno
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando.
```
$ gdk component build
[2021-11-29 13:18:49] INFO - Getting project configuration from gdk-config.json
[2021-11-29 13:18:49] INFO - Found component recipe file 'recipe.yaml' in the project directory.
[2021-11-29 13:18:49] INFO - Building the component 'com.example.PythonHelloWorld' with the given project configuration.
[2021-11-29 13:18:49] INFO - Using 'zip' build system to build the component.
[2021-11-29 13:18:49] WARNING - This component is identified as using 'zip' build system. If this is incorrect, please exit and specify custom build command in the 'gdk-config.json'.
[2021-11-29 13:18:49] INFO - Zipping source code files of the component.
[2021-11-29 13:18:49] INFO - Copying over the build artifacts to the greengrass component artifacts build folder.
[2021-11-29 13:18:49] INFO - Updating artifact URIs in the recipe.
[2021-11-29 13:18:49] INFO - Creating component recipe in 'C:\Users\MyUser\Documents\greengrass-components\python\HelloWorld\greengrass-build\recipes'.
```
## pubblicazione
Pubblica questo componente nel AWS IoT Greengrass servizio. Questo comando carica gli elementi della build in un bucket S3, aggiorna l'URI degli artefatti nella ricetta e crea una nuova versione del componente dalla ricetta. L'interfaccia a riga di comando di GDK utilizza il bucket S3 AWS e la regione specificati nel file di configurazione della CLI di [GDK](gdk-cli-configuration-file.md),. `gdk-config.json` È necessario eseguire questo comando nella stessa cartella in cui si trova il file. `gdk-config.json`
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.
Se si utilizza GDK CLI v1.2.0 o versione successiva, è possibile sovrascrivere Regione AWS quanto specificato nel file di configurazione della CLI di GDK utilizzando il parametro. `--region` È inoltre possibile specificare opzioni aggiuntive utilizzando il parametro. `--options` Per un elenco delle opzioni disponibili, vedere[File di configurazione CLI del Greengrass Development Kit](gdk-cli-configuration-file.md).
Quando esegui questo comando, la CLI di GDK pubblica il componente con la versione specificata nella ricetta. Se lo specifichi`NEXT_PATCH`, la CLI di GDK utilizza la versione della patch successiva che non esiste già. *Le versioni semantiche utilizzano una major.* *minore*. sistema di numerazione delle *patch*. Per ulteriori informazioni, consulta la specifica della [versione semantica](https://semver.org/).
**Nota**
Se usi GDK CLI v1.1.0 o versione successiva, quando esegui questo comando, la CLI di GDK verifica se il componente è stato creato. Se il componente non è stato creato, la [CLI di GDK crea il](#greengrass-development-kit-cli-component-build) componente prima di pubblicarlo.
**Riepilogo**
```
$ gdk component publish
[--bucket] [--region] [--options]
```
**Arguments (Argomenti)**
+ `-b`, `--bucket` — (Facoltativo) Specificate il nome del bucket S3 in cui la CLI di GDK pubblica gli artefatti dei componenti.
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.
La CLI GDK crea il bucket se non esiste.
Questa funzionalità è disponibile per GDK CLI v1.1.0 e versioni successive.
+ `-r`, `--region` — (Facoltativo) Specificate il nome del Regione AWS to al momento della creazione del componente. Questo argomento sovrascrive il nome della regione nella configurazione della CLI di GDK.
Questa funzionalità è disponibile per GDK CLI v1.2.0 e versioni successive.
+ `-o`, `--options` (Facoltativo) Specificate un elenco di opzioni per la pubblicazione di un componente. L'argomento deve essere una stringa JSON valida o un percorso di file a un file JSON contenente le opzioni di pubblicazione. Questo argomento sovrascrive le opzioni nella configurazione della CLI di GDK.
Questa funzionalità è disponibile per GDK CLI v1.2.0 e versioni successive.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando.
```
$ gdk component publish
[2021-11-29 13:45:29] INFO - Getting project configuration from gdk-config.json
[2021-11-29 13:45:29] INFO - Found component recipe file 'recipe.yaml' in the project directory.
[2021-11-29 13:45:29] INFO - Found credentials in shared credentials file: ~/.aws/credentials
[2021-11-29 13:45:30] INFO - Publishing the component 'com.example.PythonHelloWorld' with the given project configuration.
[2021-11-29 13:45:30] INFO - No private version of the component 'com.example.PythonHelloWorld' exist in the account. Using '1.0.0' as the next version to create.
[2021-11-29 13:45:30] INFO - Uploading the component built artifacts to s3 bucket.
[2021-11-29 13:45:30] INFO - Uploading component artifacts to S3 bucket: {bucket}. If this is your first time using this bucket, add the 's3:GetObject' permission to each core device's token exchange role to allow it to download the component artifacts. For more information, see https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html.
[2021-11-29 13:45:30] INFO - Not creating an artifacts bucket as it already exists.
[2021-11-29 13:45:30] INFO - Updating the component recipe com.example.PythonHelloWorld-1.0.0.
[2021-11-29 13:45:30] INFO - Creating a new greengrass component com.example.PythonHelloWorld-1.0.0
[2021-11-29 13:45:30] INFO - Created private version '1.0.0' of the component in the account.'com.example.PythonHelloWorld'.
```
## elenco
Recupera l'elenco dei modelli di componenti e dei componenti della community disponibili.
[La CLI GDK recupera i componenti della community dal [Greengrass Software](greengrass-software-catalog.md) Catalog e i modelli di componenti dal AWS IoT Greengrass repository Component Templates in poi. GitHub](https://github.com/aws-greengrass/aws-greengrass-component-templates)
È possibile passare l'output di questo comando al comando [init per inizializzare i repository](#greengrass-development-kit-cli-component-init) di componenti dai modelli e dai componenti della community.
**Riepilogo**
```
$ gdk component list
[--template]
[--repository]
```
**Arguments (Argomenti)**
+ `-t`, `--template` — (Facoltativo) Specificate questo argomento per elencare i modelli di componenti disponibili. Questo comando restituisce il nome e la lingua di ogni modello nel formato`name-language`. Ad esempio, in`HelloWorld-python`, il nome del modello è `HelloWorld` e la lingua è`python`.
+ `-r`, `--repository` — (Facoltativo) Specificate questo argomento per elencare gli archivi di componenti della community disponibili.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando.
```
$ gdk component list --template
[2021-11-29 12:29:04] INFO - Listing all the available component templates from Greengrass Software Catalog.
[2021-11-29 12:29:04] INFO - Found '2' component templates to display.
1. HelloWorld-python
2. HelloWorld-java
```
# config
Usa il `config` comando nell'interfaccia a riga di comando del AWS IoT Greengrass Development Kit (GDK CLI) per modificare la configurazione per il GDK nel file di configurazione,. `gdk-config.json`
**Topics**
+ [aggiorna](#greengrass-development-kit-cli-config-update)
## aggiorna
Avvia un prompt interattivo per modificare i campi all'interno di un file di configurazione GDK esistente.
**Riepilogo**
```
$ gdk config update
[--component]
```
**Arguments (Argomenti)**
+ `-c`, `--component` — Per aggiornare i campi relativi ai componenti nel file. `gdk-config.json` Questo argomento è obbligatorio in quanto è l'unica opzione.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando per configurare un componente.
```
$ gdk config update --component
Current value of the REQUIRED component_name is (default: com.example.PythonHelloWorld):
Current value of the REQUIRED author is (default: author):
Current value of the REQUIRED version is (default: NEXT_PATCH):
Do you want to change the build configurations? (y/n)
Do you want to change the publish configurations? (y/n)
[2023-09-26 10:19:48] INFO - Config file has been updated. Exiting...
```
# test-e2e
Usa il `test-e2e` comando nell'interfaccia a riga di comando del AWS IoT Greengrass Development Kit (GDK CLI) per inizializzare, creare ed end-to-end eseguire moduli di test nel progetto GDK.
**Topics**
+ [init](#greengrass-development-kit-cli-test-init)
+ [build](#greengrass-development-kit-cli-test-build)
+ [run](#greengrass-development-kit-cli-test-run)
## init
Inizializza un progetto GDK CLI esistente con un modulo di test che utilizza Greengrass Testing Framework (GTF).
[Per impostazione predefinita, la CLI GDK recupera il modello del modulo Maven dal AWS IoT Greengrass repository Component Templates in poi. GitHub](https://github.com/aws-greengrass/aws-greengrass-component-templates) Questo modulo Maven ha una dipendenza dal file JAR. `aws-greengrass-testing-standalone`
Questo comando crea una nuova directory chiamata `gg-e2e-tests` all'interno del progetto GDK. Se la directory del modulo di test esiste già e non è vuota, il comando esce senza fare nulla. Questa `gg-e2e-tests` cartella contiene la funzionalità Cucumber e le definizioni dei passaggi strutturate in un progetto Maven.
Per impostazione predefinita, questo comando proverà a utilizzare l'ultima versione di GTF.
**Riepilogo**
```
$ gdk test-e2e init
[--gtf-version]
```
**Arguments (Argomenti)**
+ `-ov`, `--gtf-version` — (Facoltativo) La versione di GTF da usare con il modulo di end-to-end test nel progetto GDK. [Questo valore deve essere una delle versioni GTF delle release.](https://github.com/aws-greengrass/aws-greengrass-testing/releases) Questo argomento ha la precedenza sulla configurazione della `gtf_version` CLI di GDK.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando per inizializzare il progetto GDK con il modulo di test.
```
$ gdk test-e2e init
[2023-12-06 12:20:28] INFO - Using the GTF version provided in the GDK test config 1.2.0
[2023-12-06 12:20:28] INFO - Downloading the E2E testing template from GitHub into gg-e2e-tests directory...
```
## build
**Nota**
È necessario creare il componente eseguendolo **gdk component build** prima di creare il modulo di end-to-end test.
Crea il modulo end-to-end di test. La CLI GDK crea il modulo di test utilizzando il sistema di compilazione specificato nel file di [configurazione della CLI GDK](gdk-cli-configuration-file.md), sotto la proprietà. `gdk-config.json` `test-e2e` È necessario eseguire questo comando nella stessa cartella in cui si trova il file. `gdk-config.json`
Per impostazione predefinita, la CLI GDK utilizza il sistema di compilazione maven per creare il modulo di test. [Maven](https://maven.apache.org/) è necessario per eseguire il comando. `gdk test-e2e build`
È necessario creare il componente eseguendolo **gdk-component-build** prima di creare il modulo di test, se i file delle funzionalità di test hanno variabili simili `GDK_COMPONENT_RECIPE_FILE` a `GDK_COMPONENT_NAME` e da interpolare.
Quando esegui questo comando, la CLI GDK interpola tutte le variabili dalla configurazione del progetto GDK e crea il modulo per generare il file JAR di `gg-e2e-tests` test finale.
**Riepilogo**
```
$ gdk test-e2e build
```
**Arguments (Argomenti)**
Nessuno
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando.
```
$ gdk test-e2e build
[2023-07-20 15:36:48] INFO - Updating feature file: file:///path/to//HelloWorld/greengrass-build/gg-e2e-tests/src/main/resources/greengrass/features/component.feature
[2023-07-20 15:36:48] INFO - Creating the E2E testing recipe file:///path/to/HelloWorld/greengrass-build/recipes/e2e_test_recipe.yaml
[2023-07-20 15:36:48] INFO - Building the E2E testing module
[2023-07-20 15:36:48] INFO - Running the build command 'mvn package'
.........
```
## run
Esegui il modulo di test con le opzioni di test nel file di configurazione GDK.
**Nota**
È necessario creare il modulo di test eseguendolo **gdk test-e2e build** prima di eseguire i end-to-end test.
**Riepilogo**
```
$ gdk test-e2e run
[--gtf-options]
```
**Arguments (Argomenti)**
+ `-oo`, `--gtf-options` — (Facoltativo) Specificate un elenco di opzioni per l'esecuzione end-to-end dei test. L'argomento deve essere una stringa JSON valida o un percorso di file a un file JSON contenente le opzioni GTF. Le opzioni fornite nel file di configurazione vengono unite a quelle fornite negli argomenti del comando. Se un'opzione è presente in entrambi i posti, quella contenuta nell'argomento ha la precedenza su quella del file di configurazione.
Se l'`tags`opzione non è specificata in questo comando, GDK la usa per i tag. `Sample` Se non `ggc-archive` è specificato, GDK scarica l'ultima versione dell'archivio Greengrass nucleus.
**Output**
L'esempio seguente mostra l'output prodotto quando si esegue questo comando.
```
$ gdk test-e2e run
[2023-07-20 16:35:53] INFO - Downloading latest nucleus archive from url https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-latest.zip
[2023-07-20 16:35:57] INFO - Running test jar with command java -jar /path/to/greengrass-build/gg-e2e-tests/target/uat-features-1.0.0.jar —ggc-archive=/path/to/aws-greengrass-gdk-cli/HelloWorld/greengrass-build/greengrass-nucleus-latest.zip —tags=Sample
16:35:59.693 [] [] [] [INFO] com.aws.greengrass.testing.modules.GreengrassContextModule - Extracting /path/to/workplace/aws-greengrass-gdk-cli/HelloWorld/greengrass-build/greengrass-nucleus-latest.zip into /var/folders/7g/ltzcb_3s77nbtmkzfb6brwv40000gr/T/gg-testing-7718418114158172636/greengrass
16:36:00.534 [gtf-1.1.0-SNAPSHOT] [] [] [INFO] com.aws.greengrass.testing.features.LoggerSteps - GTF Version is gtf-1.1.0-SNAPSHOT
.......
```