Fase 4: Sviluppa e testa un componente sul tuo dispositivo

Un componente è un modulo software che viene eseguito sui dispositivi AWS IoT Greengrass principali. I componenti consentono di creare e gestire applicazioni complesse come elementi costitutivi discreti che puoi riutilizzare da un dispositivo core Greengrass a un altro. 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.

È possibile definire ricette in formato JSON o 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.

Con AWS IoT Greengrass, puoi utilizzare la Greengrass CLI per sviluppare e testare i componenti localmente su un dispositivo core Greengrass senza interazione con il Cloud. AWS Una volta completato il componente locale, puoi utilizzare la ricetta e gli artefatti del componente per creare quel componente nel AWS IoT Greengrass servizio nel AWS Cloud e quindi distribuirlo su tutti i tuoi dispositivi principali Greengrass. Per ulteriori informazioni sui componenti, vedere. Sviluppa AWS IoT Greengrass componenti

In questa sezione, imparerai come creare ed eseguire un componente Hello World di base localmente sul tuo dispositivo principale.

Per sviluppare un componente Hello World sul tuo dispositivo

Crea una cartella per i 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 ~/greengrassv2 o %USERPROFILE%\ greengrassv2 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
```
Usa 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.

Incolla la seguente ricetta nel file.

La ComponentConfiguration sezione di questa ricetta definisce un parametroMessage, il cui valore predefinito è. world La Manifests sezione definisce un manifesto, che è un insieme di istruzioni e artefatti del ciclo di vita per una piattaforma. È possibile definire più manifesti per specificare istruzioni di installazione diverse per varie piattaforme, ad esempio. Nel manifesto, la Lifecycle sezione indica al dispositivo principale Greengrass di eseguire lo script Hello World con il valore Message del parametro come argomento.

Eseguite il comando seguente per creare una cartella per gli artefatti del componente.
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/
```
Usa un editor di testo per creare un file artefatto di script Python per il tuo componente Hello World.

Ad esempio, su un sistema basato su Linux, puoi eseguire il comando seguente per usare GNU nano per creare il file.
```
nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Copia e incolla il seguente script Python nel file.
```
import sys

message = "Hello, %s!" % sys.argv[1]

# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
Utilizza la AWS IoT Greengrass CLI locale per gestire i componenti sul tuo dispositivo principale Greengrass.

Esegui il comando seguente per distribuire il componente nel core. AWS IoT Greengrass Sostituisci /greengrass/v2 o C:\greengrass\v2 con la cartella AWS IoT Greengrass V2 principale e sostituisci ~/greengrassv2 o %USERPROFILE%\ greengrassv2 con la cartella di sviluppo dei componenti.
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"
```
Questo comando aggiunge il componente che utilizza la ricetta in recipes e lo script Python in. artifacts L'--mergeopzione aggiunge o aggiorna il componente e la versione specificati.
Il software AWS IoT Greengrass Core salva lo stdout dal processo componente nei file di registro nella logs cartella. Esegui il comando seguente per verificare che il componente Hello World venga eseguito e stampi i messaggi.
Linux or Unix
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
Windows Command Prompt (CMD)
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Il type comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
PowerShell
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, world!
```
Nota
Se il file non esiste, la distribuzione locale potrebbe non essere ancora completa. Se il file non esiste entro 15 secondi, è probabile che la distribuzione non sia riuscita. Ciò può verificarsi, ad esempio, se la ricetta non è valida. Esegui il comando seguente per visualizzare il file di registro AWS IoT Greengrass principale. Questo file include i log del servizio di distribuzione del dispositivo principale Greengrass.
Linux or Unix

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

Windows Command Prompt (CMD)

type C:\greengrass\v2\logs\greengrass.log

Il type comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
Modifica il componente locale per iterare e testare il codice. Apri hello_world.py in un editor di testo e aggiungi il codice seguente alla riga 4 per modificare il messaggio registrato dal AWS IoT Greengrass core.
```
message += " Greetings from your first Greengrass component."
```
Lo hello_world.py script dovrebbe ora avere i seguenti contenuti.
```
import sys

message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."

# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```

Esegui il comando seguente per aggiornare il componente con le tue modifiche.

Questo comando aggiorna il com.example.HelloWorld componente con l'ultimo artefatto Hello World.

Eseguite il comando seguente per riavviare il componente. Quando riavviate un componente, il dispositivo principale utilizza le ultime modifiche.

Controlla nuovamente il registro per verificare che il componente Hello World stampi il nuovo messaggio.
Linux or Unix
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
Windows Command Prompt (CMD)
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
Il type comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
PowerShell
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, world! Greetings from your first Greengrass component.
```
È possibile aggiornare i parametri di configurazione del componente per testare diverse configurazioni. Quando si distribuisce un componente, è possibile specificare un aggiornamento della configurazione, che definisce come modificare la configurazione del componente sul dispositivo principale. È possibile specificare quali valori di configurazione ripristinare ai valori predefiniti e i nuovi valori di configurazione da unire al dispositivo principale. Per ulteriori informazioni, consulta Aggiornamento delle configurazioni dei componenti.

Esegui questa operazione:
1. Utilizzate un editor di testo per creare un file chiamato hello-world-config-update.json a contenere l'aggiornamento della configurazione
  
  Ad esempio, su un sistema basato su Linux, è possibile eseguire il comando seguente per utilizzare GNU nano per creare il file.
```
nano hello-world-config-update.json
```
2. Copiate e incollate il seguente oggetto JSON nel file. Questo oggetto JSON definisce un aggiornamento della configurazione che unisce il valore al Message parametro friend per aggiornarne il valore. Questo aggiornamento della configurazione non specifica alcun valore da reimpostare. Non è necessario reimpostare il Message parametro perché l'aggiornamento di fusione sostituisce il valore esistente.
```
{
  "com.example.HelloWorld": {
    "MERGE": {
      "Message": "friend"
    }
  }
}
```
3. Esegui il comando seguente per distribuire l'aggiornamento della configurazione nel componente Hello World.
  Linux or Unix
  sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json
  Windows Command Prompt (CMD)
  C:\greengrass\v2\bin\greengrass-cli deployment create ^ --merge "com.example.HelloWorld=1.0.0" ^ --update-config hello-world-config-update.json
  PowerShell
  C:\greengrass\v2\bin\greengrass-cli deployment create ` --merge "com.example.HelloWorld=1.0.0" ` --update-config hello-world-config-update.json
4. Controlla nuovamente il registro per verificare che il componente Hello World emetta il nuovo messaggio.
  Linux or Unix
  sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
  Windows Command Prompt (CMD)
  type C:\greengrass\v2\logs\com.example.HelloWorld.log
  
  Il type comando scrive il contenuto del file nel terminale. Esegui questo comando più volte per osservare le modifiche nel file.
  PowerShell
  gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
  Dovrebbero essere visualizzati messaggi simili a quelli dell'esempio seguente.
```
Hello, friend! Greetings from your first Greengrass component.
```
Dopo aver terminato il test del componente, rimuovilo dal dispositivo principale. Esegui il comando seguente.
Linux or Unix
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
Windows Command Prompt (CMD)
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
PowerShell
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
Importante
Questo passaggio è necessario per ridistribuire il componente sul dispositivo principale dopo averlo caricato su. AWS IoT Greengrass In caso contrario, la distribuzione fallisce con un errore di compatibilità della versione perché la distribuzione locale specifica una versione diversa del componente.

Esegui il comando seguente e verifica che il com.example.HelloWorld componente non compaia nell'elenco dei componenti del dispositivo.
Linux or Unix
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
Windows Command Prompt (CMD)
```
C:\greengrass\v2\bin\greengrass-cli component list
```
PowerShell
```
C:\greengrass\v2\bin\greengrass-cli component list
```

Il componente Hello World è completo e ora puoi caricarlo sul servizio AWS IoT Greengrass cloud. Quindi, puoi distribuire il componente sui dispositivi principali Greengrass.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Verifica l'CLIinstallazione di Greengrass sul dispositivo

Fase 5: Crea il tuo componente nel AWS IoT Greengrass servizio

Fase 4: Sviluppa e testa un componente sul tuo dispositivo

Per sviluppare un componente Hello World sul tuo dispositivo

Nota

Importante

Nota

Importante