Avviso di fine del supporto: il 7 ottobre 2026, AWS il supporto per. AWS IoT Greengrass Version 1 Dopo il 7 ottobre 2026, non potrai più accedere alle risorse. AWS IoT Greengrass V1 Per ulteriori informazioni, visita [Migrate](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html) from. AWS IoT Greengrass Version 1
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à.
# Esportazione di flussi di dati su Cloud AWS (CLI)
Questo tutorial mostra come utilizzare il AWS CLI per configurare e distribuire un AWS IoT Greengrass gruppo con lo stream manager abilitato. Il gruppo contiene una funzione Lambda definita dall'utente che scrive su uno stream in stream manager, che viene quindi esportata automaticamente in. Cloud AWS
Stream Manager rende più efficienti e affidabili l'acquisizione, l'elaborazione e l'esportazione di flussi di dati ad alto volume. In questo tutorial, crei una funzione `TransferStream` Lambda che utilizza dati IoT. La funzione Lambda utilizza AWS IoT Greengrass Core SDK per creare uno stream in stream manager e quindi leggerlo e scriverlo. Stream Manager esporta quindi il flusso in Kinesis Data Streams. Il diagramma seguente mostra questo flusso di lavoro.
![\[Diagramma del flusso di lavoro di gestione dei flussi.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/stream-manager-scenario.png)
L'obiettivo di questo tutorial è mostrare come le funzioni Lambda definite dall'utente utilizzano `StreamManagerClient` l'oggetto nel Core SDK per interagire con AWS IoT Greengrass lo stream manager. Per semplicità, la funzione Python Lambda creata per questo tutorial genera dati di dispositivo simulati.
Quando si utilizza l' AWS IoT Greengrass API, che include i comandi Greengrass in AWS CLI, per creare un gruppo, lo stream manager è disabilitato per impostazione predefinita. Per abilitare lo stream manager sul tuo core, [crei una versione di definizione di funzione](#stream-manager-cli-create-function-definition) che include la funzione `GGStreamManager` Lambda di sistema e una versione di gruppo che fa riferimento alla nuova versione di definizione della funzione. Quindi, distribuisci il flusso.
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un gruppo Greengrass e un core Greengrass (v1.10 o successivo). Per informazioni su come creare un gruppo e un core Greengrass, vedere. [Iniziare con AWS IoT Greengrass](gg-gs.md) Il tutorial Getting Started include anche i passaggi per l'installazione del software AWS IoT Greengrass Core.
**Nota**
Stream manager non è supportato nelle OpenWrt distribuzioni.
+ Java 8 Runtime (JDK 8) installato sul dispositivo principale.
+ Per distribuzioni basate su Debian (incluso Raspbian) o distribuzioni basate su Ubuntuu, eseguire il comando seguente:
```
sudo apt install openjdk-8-jdk
```
+ Per distribuzioni basate su Red Hat (incluso Amazon Linux), eseguire il comando seguente:
```
sudo yum install java-1.8.0-openjdk
```
Per ulteriori informazioni, consulta [How to download and install prebuilt OpenJDK packages](https://openjdk.java.net/install/) nella documentazione di OpenJDK.
+ AWS IoT Greengrass Core SDK per Python v1.5.0 o successivo. Per utilizzarlo `StreamManagerClient` nel AWS IoT Greengrass Core SDK per Python, devi:
+ Installa Python 3.7 o versione successiva sul dispositivo principale.
+ Includi l'SDK e le sue dipendenze nel pacchetto di distribuzione della funzione Lambda. Le istruzioni vengono fornite in questo tutorial.
**Suggerimento**
È possibile utilizzare `StreamManagerClient` con Java o NodeJS. Per esempio di codice, consulta [AWS IoT Greengrass Core SDK per](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) Java [AWS IoT Greengrass e Core SDK per](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) Node.js su. GitHub
+ Un flusso di destinazione denominato **MyKinesisStream** creato in Amazon Kinesis Data Streams nello Regione AWS stesso gruppo Greengrass. Per ulteriori informazioni, consulta [Create a stream](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) nella *Amazon Kinesis Developer* Guide.
**Nota**
In questo tutorial, lo stream manager esporta i dati in Kinesis Data Streams, con conseguente addebito a carico dell'utente. Account AWS Per informazioni sui prezzi, consulta la pagina dei prezzi di [Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/).
Per evitare costi aggiuntivi, puoi eseguire questo tutorial senza creare un flusso di dati Kinesis. In questo caso, controlli i log per vedere che lo stream manager ha tentato di esportare lo stream in Kinesis Data Streams.
+ Una policy IAM aggiunta a [Ruolo del gruppo Greengrass](group-role.md) quella che consente l'`kinesis:PutRecords`azione sul flusso di dati di destinazione, come mostrato nell'esempio seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream"
]
}
]
}
```
------
+ AWS CLI Installato e configurato sul tuo computer. Per ulteriori informazioni, vedere [Installazione AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) [e configurazione di AWS CLI nella](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Guida per l'AWS Command Line Interface utente*.
I comandi di esempio in questo tutorial sono scritti per Linux e altri sistemi basati su Unix. Se usi Windows, vedi [Specificazione dei valori dei parametri per l'interfaccia della AWS riga di comando](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) per ulteriori informazioni sulle differenze di sintassi.
Se il comando include una stringa JSON, il tutorial fornisce un esempio che ha JSON in un'unica riga. Su alcuni sistemi, potrebbe essere più efficiente modificare ed eseguire comandi utilizzando questo formato.
Il tutorial include le seguenti fasi di alto livello:
1. [Creare un pacchetto di distribuzione della funzione Lambda](#stream-manager-cli-create-deployment-package)
1. [Creazione di una funzione Lambda ](#stream-manager-cli-create-function)
1. [Creazione della versione e della definizione della funzione](#stream-manager-cli-create-function-definition)
1. [Creazione di una definizione e di una versione di logger](#stream-manager-cli-create-logger-definition)
1. [Ottenimento dell'ARN della versione di definizione del core](#stream-manager-cli-get-core-definition-version-arn)
1. [Creazione di una versione del gruppo](#stream-manager-cli-create-group-version)
1. [Crea distribuzione](#stream-manager-cli-create-deployment)
1. [Eseguire il test dell’applicazione](#stream-manager-cli-test-application)
Il completamento di questo tutorial richiede circa 30 minuti.
## Fase 1: Creare un pacchetto di distribuzione della funzione Lambda
In questo passaggio, crei un pacchetto di distribuzione della funzione Lambda che contiene il codice della funzione Python e le dipendenze. Carichi questo pacchetto più tardi quando crei la funzione Lambda in. AWS Lambda La funzione Lambda utilizza AWS IoT Greengrass Core SDK per creare e interagire con flussi locali.
**Nota**
Le funzioni Lambda definite dall'utente devono utilizzare [Core SDK per interagire con AWS IoT Greengrass lo](lambda-functions.md#lambda-sdks-core) stream manager. Per ulteriori informazioni sui requisiti di Stream Manager di Greengrass, consulta l'argomento relativo ai [requisiti di Stream Manager di Greengrass](stream-manager.md#stream-manager-requirements).
1. Scarica il [AWS IoT Greengrass Core SDK per Python](lambda-functions.md#lambda-sdks-core) v1.5.0 o versione successiva.
1. Decomprimere il pacchetto scaricato per ottenere l'SDK. Il kit SDK è la cartella `greengrasssdk`.
1. Installa le dipendenze dei pacchetti da includere con l'SDK nel pacchetto di distribuzione delle funzioni Lambda.
1. Passare alla directory SDK che contiene il file `requirements.txt`. Questo file elenca le dipendenze.
1. Installare le dipendenze SDK. Ad esempio, eseguire il comando `pip` seguente per installarle nella directory corrente:
```
pip install --target . -r requirements.txt
```
1. Salvare la seguente funzione del codice Python nel file locale `transfer_stream.py`.
**Suggerimento**
Per esempio di codice che utilizza Java e NodeJS, consulta AWS IoT Greengrass Core SDK [per AWS IoT Greengrass Java e Core SDK](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) [per Node.js](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) su. GitHub
```
import asyncio
import logging
import random
import time
from greengrasssdk.stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
ReadMessagesOptions,
ResourceNotFoundException,
StrategyOnFull,
StreamManagerClient,
)
# This example creates a local stream named "SomeStream".
# It starts writing data into that stream and then stream manager automatically exports
# the data to a customer-created Kinesis data stream named "MyKinesisStream".
# This example runs forever until the program is stopped.
# The size of the local stream on disk will not exceed the default (which is 256 MB).
# Any data appended after the stream reaches the size limit continues to be appended, and
# stream manager deletes the oldest data until the total stream size is back under 256 MB.
# The Kinesis data stream in the cloud has no such bound, so all the data from this script is
# uploaded to Kinesis and you will be charged for that usage.
def main(logger):
try:
stream_name = "SomeStream"
kinesis_stream_name = "MyKinesisStream"
# Create a client for the StreamManager
client = StreamManagerClient()
# Try deleting the stream (if it exists) so that we have a fresh start
try:
client.delete_message_stream(stream_name=stream_name)
except ResourceNotFoundException:
pass
exports = ExportDefinition(
kinesis=[KinesisConfig(identifier="KinesisExport" + stream_name, kinesis_stream_name=kinesis_stream_name)]
)
client.create_message_stream(
MessageStreamDefinition(
name=stream_name, strategy_on_full=StrategyOnFull.OverwriteOldestData, export_definition=exports
)
)
# Append two messages and print their sequence numbers
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "ABCDEFGHIJKLMNO".encode("utf-8")),
)
logger.info(
"Successfully appended message to stream with sequence number %d",
client.append_message(stream_name, "PQRSTUVWXYZ".encode("utf-8")),
)
# Try reading the two messages we just appended and print them out
logger.info(
"Successfully read 2 messages: %s",
client.read_messages(stream_name, ReadMessagesOptions(min_message_count=2, read_timeout_millis=1000)),
)
logger.info("Now going to start writing random integers between 0 and 1000 to the stream")
# Now start putting in random data between 0 and 1000 to emulate device sensor input
while True:
logger.debug("Appending new random integer to stream")
client.append_message(stream_name, random.randint(0, 1000).to_bytes(length=4, signed=True, byteorder="big"))
time.sleep(1)
except asyncio.TimeoutError:
logger.exception("Timed out while executing")
except Exception:
logger.exception("Exception while running")
def function_handler(event, context):
return
logging.basicConfig(level=logging.INFO)
# Start up this sample code
main(logger=logging.getLogger())
```
1. Comprimere le voci seguenti nel file `transfer_stream_python.zip`. Questo è il tuo pacchetto di implementazione della funzione Lambda.
+ **transfer\$1stream.py**. La logica dell'app.
+ **greengrasssdk**. Libreria richiesta per le funzioni Python Greengrass Lambda che pubblicano messaggi MQTT.
Le [operazioni di Stream Manager](work-with-streams.md) sono disponibili nella versione 1.5.0 o successiva di AWS IoT Greengrass Core SDK for Python.
+ Le dipendenze che hai installato per AWS IoT Greengrass Core SDK for Python (ad esempio, le directory). `cbor2`
Quando crei il file `zip`, includi solo questi elementi, non la cartella che li contiene.
## Passaggio 2: creazione di una funzione Lambda
1. Crea un ruolo IAM in modo da poter passare il ruolo ARN quando crei la funzione.
------
#### [ JSON Expanded ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws iam create-role --role-name Lambda_empty --assume-role-policy '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},"Action": "sts:AssumeRole"}]}'
```
------
**Nota**
AWS IoT Greengrass non utilizza questo ruolo perché le autorizzazioni per le funzioni Greengrass Lambda sono specificate nel ruolo del gruppo Greengrass. Per questo tutorial, viene creato un ruolo vuoto.
1. Copia il valore `Arn` dall'output.
1. Usa l' AWS Lambda API per creare la funzione. `TransferStream` Il comando seguente presuppone che il file ZIP si trovi nella directory corrente.
+ Sostituisci l’*role-arn* con l’`Arn` copiato.
```
aws lambda create-function \
--function-name TransferStream \
--zip-file fileb://transfer_stream_python.zip \
--role role-arn \
--handler transfer_stream.function_handler \
--runtime python3.7
```
1. Pubblicare una versione della funzione.
```
aws lambda publish-version --function-name TransferStream --description 'First version'
```
1. Creare un alias della versione pubblicata.
I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'utilizzo di un alias semplifica la gestione degli aggiornamenti del codice perché non è necessario modificare la tabella di sottoscrizione o la definizione del gruppo quando il codice della funzione viene aggiornato. Invece, è sufficiente indirizzare l'alias alla nuova versione della funzione.
```
aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1
```
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Copia il valore `AliasArn` dall'output. Si utilizza questo valore quando si configura la funzione per. AWS IoT Greengrass
Ora sei pronto per configurare la funzione per AWS IoT Greengrass.
## Fase 3: creazione della versione e della definizione della funzione
Questo passaggio crea una versione della definizione della funzione che fa riferimento alla funzione `GGStreamManager` Lambda di sistema e alla funzione Lambda definita dall'utente`TransferStream`. Per abilitare lo stream manager quando si utilizza l' AWS IoT Greengrass API, la versione della definizione della funzione deve includere la funzione. `GGStreamManager`
1. Crea una definizione di funzione con una versione iniziale che contenga il sistema e le funzioni Lambda definite dall'utente.
La seguente versione di definizione abilita lo stream manager con le impostazioni [dei parametri](configure-stream-manager.md) predefinite. Per configurare le impostazioni personalizzate, è necessario definire le variabili di ambiente per i parametri dello stream manager corrispondenti. Per un esempio, vedi[Per abilitare, disabilitare o configurare lo stream manager (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass utilizza le impostazioni predefinite per i parametri omessi. `MemorySize`dovrebbe esserlo almeno`128000`. `Pinned`deve essere impostato su`true`.
**Nota**
Una funzione Lambda di *lunga durata* (o *bloccata*) si avvia automaticamente dopo l'avvio e continua AWS IoT Greengrass a funzionare nel proprio contenitore. Ciò è in contrasto con una funzione Lambda *su richiesta*, che si avvia quando viene richiamata e si interrompe quando non ci sono più attività da eseguire. Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ *arbitrary-function-id*Sostituiscila con un nome per la funzione, ad esempio. **stream-manager**
+ Sostituisci *alias-arn* con `AliasArn` quello che hai copiato quando hai creato l'alias per la funzione Lambda`TransferStream`.
------
#### [ JSON expanded ]
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "arbitrary-function-id",
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 128000,
"Pinned": true,
"Timeout": 3
}
},
{
"Id": "TransferStreamFunction",
"FunctionArn": "alias-arn",
"FunctionConfiguration": {
"Executable": "transfer_stream.function_handler",
"MemorySize": 16000,
"Pinned": true,
"Timeout": 5
}
}
]
}'
```
------
#### [ JSON single ]
```
aws greengrass create-function-definition \
--name MyGreengrassFunctions \
--initial-version '{"Functions": [{"Id": "arbitrary-function-id","FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": {"Environment": {"Variables":{"STREAM_MANAGER_STORE_ROOT_DIR": "/data","STREAM_MANAGER_SERVER_PORT": "1234","STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH": "20000"}},"MemorySize": 128000,"Pinned": true,"Timeout": 3}},{"Id": "TransferStreamFunction", "FunctionArn": "alias-arn", "FunctionConfiguration": {"Executable": "transfer_stream.function_handler", "MemorySize": 16000,"Pinned": true,"Timeout": 5}}]}'
```
------
**Nota**
`Timeout` è richiesto dalla versione di definizione della funzione, ma non viene utilizzato da `GGStreamManager`. Per ulteriori informazioni `Timeout` e altre impostazioni a livello di gruppo, consulta. [Controllo dell'esecuzione delle funzioni Greengrass Lambda utilizzando la configurazione specifica del gruppo](lambda-group-config.md)
1. Copia il valore `LatestVersionArn` dall'output. È possibile utilizzare questo valore per aggiungere la definizione di funzione alla versione del gruppo distribuita nel core.
## Fase 4: creazione di una definizione e di una versione di logger
Configurare le impostazioni di registrazione del gruppo. In questo tutorial, configurerai i componenti di AWS IoT Greengrass sistema, le funzioni Lambda definite dall'utente e i connettori per scrivere i log nel file system del dispositivo principale. Puoi utilizzare i log per risolvere eventuali problemi che potrebbero verificarsi. Per ulteriori informazioni, consulta [Monitoraggio con AWS IoT Greengrass registri](greengrass-logs-overview.md).
1. Creare una definizione di logger che includa una versione iniziale.
------
#### [ JSON Expanded ]
```
aws greengrass create-logger-definition --name "LoggingConfigs" --initial-version '{
"Loggers": [
{
"Id": "1",
"Component": "GreengrassSystem",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
},
{
"Id": "2",
"Component": "Lambda",
"Level": "INFO",
"Space": 10240,
"Type": "FileSystem"
}
]
}'
```
------
#### [ JSON Single-line ]
```
aws greengrass create-logger-definition \
--name "LoggingConfigs" \
--initial-version '{"Loggers":[{"Id":"1","Component":"GreengrassSystem","Level":"INFO","Space":10240,"Type":"FileSystem"},{"Id":"2","Component":"Lambda","Level":"INFO","Space":10240,"Type":"FileSystem"}]}'
```
------
1. Copiare la `LatestVersionArn` della definizione di logger dall'output. Utilizzare questo valore per aggiungere la versione della definizione di logger alla versione del gruppo distribuita nel core.
## Fase 5: ottenimento dell'ARN della versione di definizione del core
Ottieni l'ARN della versione di definizione del core da aggiungere alla nuova versione del gruppo. Per distribuire una versione del gruppo, deve fare riferimento a una versione di definizione del core contenente esattamente un core.
1. Ottieni il gruppo Greengrass IDs di destinazione e la versione del gruppo. Questa procedura presuppone che questa sia la versione più recente del gruppo e del gruppo. La seguente query restituisce il gruppo creato più di recente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
In alternativa, puoi eseguire query in base al nome. I nomi dei gruppi non devono essere univoci, pertanto potrebbero essere restituiti più gruppi.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**Nota**
Puoi trovare questi valori anche nella AWS IoT console. L'ID gruppo viene visualizzato nella pagina **Settings (Impostazioni)** del gruppo. IDs Le versioni del gruppo vengono visualizzate nella scheda **Distribuzioni del gruppo.**
1. Copiare l'`Id` del gruppo di destinazione dall'output. Questo valore viene utilizzato per ottenere la versione della definizione del core e durante la distribuzione del gruppo.
1. Copiare la `LatestVersion` dall'output, che corrisponde all'ID dell'ultima versione aggiunta al gruppo. Questo valore viene utilizzato per ottenere la versione della definizione del core.
1. Per ottenere l'ARN della versione di definizione del core:
1. Ottenere la versione del gruppo.
+ *group-id*Sostituiscila con quella `Id` che hai copiato per il gruppo.
+ Sostituisci *group-version-id* con `LatestVersion` quello che hai copiato per il gruppo.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id group-version-id
```
1. Copia il valore `CoreDefinitionVersionArn` dall'output. Utilizza questo valore per aggiungere la versione di definizione del core alla versione del gruppo distribuita nel core.
## Fase 6: creazione di una versione del gruppo
È ora possibile creare una versione del gruppo che contenga tutti le entità da distribuire. A questo scopo, è necessario creare una versione di gruppo che faccia riferimento alla versione di destinazione di ciascun tipo di componente. Per questo tutorial, includere una versione di definizione del core, una versione di definizione della funzione e una versione di definizione di logger.
1. Creare una versione del gruppo.
+ Sostituisci *group-id* con `Id` quello che hai copiato per il gruppo.
+ Sostituiscilo *core-definition-version-arn* con `CoreDefinitionVersionArn` quello che hai copiato per la versione di definizione principale.
+ Sostituiscilo *function-definition-version-arn* con `LatestVersionArn` quello che hai copiato per la nuova versione della definizione di funzione.
+ *logger-definition-version-arn*Sostituiscilo con `LatestVersionArn` quello che hai copiato per la nuova versione della definizione del logger.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn
```
1. Copia il valore `Version` dall'output. Questo è l'ID della nuova versione gruppo.
## Fase 7: creazione di una distribuzione
Distribuire il gruppo al nuovo dispositivo core.
1. Assicurati che il AWS IoT Greengrass core sia in funzione. Esegui i seguenti comandi nel terminale di Raspberry Pi in base alle esigenze.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/ggc-version/bin/daemon`, allora il daemon è in esecuzione.
**Nota**
La versione indicata nel percorso dipende dalla versione del software AWS IoT Greengrass Core installata sul dispositivo principale.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Crea una implementazione .
+ *group-id*Sostituiscilo con `Id` quello che hai copiato per il gruppo.
+ Sostituisci *group-version-id* con `Version` quello che hai copiato per la nuova versione del gruppo.
```
aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id
```
1. Copia il valore `DeploymentId` dall'output.
1. Ottenere lo stato della distribuzione.
+ Sostituisci *group-id* con `Id` quello che hai copiato per il gruppo.
+ Sostituiscilo *deployment-id* con `DeploymentId` quello che hai copiato per la distribuzione.
```
aws greengrass get-deployment-status \
--group-id group-id \
--deployment-id deployment-id
```
Se lo stato è`Success`, la distribuzione è avvenuta con successo. Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
## Fase 8: test dell'applicazione
La funzione `TransferStream` Lambda genera dati simulati del dispositivo. Scrive i dati in un flusso che viene esportato da stream manager nel flusso di dati Kinesis target.
1. Nella console Amazon Kinesis, in **Kinesis data** stream, scegli. **MyKinesisStream**
**Nota**
Se il tutorial è stato eseguito senza un flusso di dati Kinesis di destinazione, [controllare il file di log](#stream-manager-cli-logs) per stream manager (`GGStreamManager`). Se contiene `export stream MyKinesisStream doesn't exist` in un messaggio di errore, il test viene superato. Questo errore indica che il servizio ha tentato di esportare nel flusso ma il flusso non esiste.
1. **Nella **MyKinesisStream**pagina, scegli Monitoraggio.** Se il test vien superato, i dati sono visibili nei grafici **Put Records (Inserisci record)** . A seconda della connessione, potrebbe essere necessario fino a un minuto prima che i dati vengano visualizzati.
**Importante**
Al termine della sessione di test, eliminare il flusso di dati Kinesis per evitare di incorrere in ulteriori costi.
In alternativa, eseguire i comandi seguenti per arrestare il daemon Greengrass. Ciò impedisce al core di inviare messaggi fino a quando non si è pronti a continuare il test.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Rimuovi la funzione **TransferStream**Lambda dal core.
1. Seguire [Fase 6: creazione di una versione del gruppo](#stream-manager-cli-create-group-version) per creare una nuova versione del gruppo, ma rimuovere l'opzione `--function-definition-version-arn` nel comando `create-group-version`. Oppure, crea una versione della definizione di funzione che non includa la funzione **TransferStream**Lambda.
**Nota**
Omettendo la funzione `GGStreamManager` Lambda del sistema dalla versione di gruppo distribuita, si disabilita la gestione del flusso sul core.
1. Seguire [Fase 7: creazione di una distribuzione](#stream-manager-cli-create-deployment) per distribuire la nuova versione del gruppo.
Per visualizzare le informazioni di registrazione o risolvere problemi con i flussi, controllare i log per le funzioni `TransferStream` e `GGStreamManager`. È necessario disporre `root` delle autorizzazioni per leggere i AWS IoT Greengrass log sul file system.
+ `TransferStream` scrive le voci di log in `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`.
+ `GGStreamManager` scrive le voci di log in `greengrass-root/ggc/var/log/system/GGStreamManager.log`.
Se sono necessarie ulteriori informazioni sulla risoluzione dei problemi, puoi impostare il livello di registrazione `Lambda` su `DEBUG` e quindi creare e distribuire una nuova versione del gruppo.
## Consulta anche
+ [Gestisci i flussi di dati sul core AWS IoT Greengrass](stream-manager.md)
+ [Utilizzalo StreamManagerClient per lavorare con gli stream](work-with-streams.md)
+ [Esporta le configurazioni per le destinazioni supportate Cloud AWS](stream-export-configurations.md)
+ [Configurare AWS IoT Greengrass lo stream manager](configure-stream-manager.md)
+ [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.md)
+ [AWS Identity and Access Management Comandi (IAM) nel Command AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/iam) *Reference*
+ [AWS Lambda comandi nel AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/lambda) *Reference*
+ [AWS IoT Greengrass comandi nel AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) *Reference*