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 (console) Questo tutorial mostra come utilizzare la AWS IoT console per configurare e distribuire un AWS IoT Greengrass gruppo con 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. ## 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" ] } ] } ``` ------ Il tutorial include le seguenti fasi di alto livello: 1. [Creare un pacchetto di distribuzione della funzione Lambda](#stream-manager-console-create-deployment-package) 1. [Creazione di una funzione Lambda ](#stream-manager-console-create-function) 1. [Aggiunta di una funzione al gruppo](#stream-manager-console-create-gg-function) 1. [Abilitazione di Stream Manager](#stream-manager-console-enable-stream-manager) 1. [Configurazione della registrazione locale](#stream-manager-console-configure-logging) 1. [Distribuzione del gruppo.](#stream-manager-console-create-deployment) 1. [Eseguire il test dell’applicazione](#stream-manager-console-test-application) Il completamento di questo tutorial richiede circa 20 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 installate 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 In questo passaggio, si utilizza la AWS Lambda console per creare una funzione Lambda e configurarla per utilizzare il pacchetto di distribuzione. In seguito, pubblicherai una versione della funzione e creerai un alias. 1. Innanzitutto, crea la funzione Lambda. 1. In Console di gestione AWS, scegli **Servizi** e apri la AWS Lambda console. 1. Scegli **Crea funzione**, quindi scegli **Autore da zero**. 1. Nella sezione **Basic information (Informazioni di base)**, specifica i seguenti valori: + Nel campo **Function name (Nome funzione)**, immettere **TransferStream**. + In **Runtime**, scegliere **Python 3.7**. + Per **le autorizzazioni**, mantieni l'impostazione predefinita. Questo crea un ruolo di esecuzione che concede le autorizzazioni Lambda di base. Questo ruolo non viene utilizzato da. AWS IoT Greengrass 1. Nella parte inferiore della pagina, scegli **Crea funzione**. 1. Quindi, registra il gestore e carica il pacchetto di distribuzione della funzione Lambda. 1. Nella scheda **Codice**, in **Codice sorgente**, scegli **Carica** da. Dal menu a discesa, scegli un **file.zip.** ![\[Il menu a discesa Carica da con il file.zip evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png) 1. Scegli **Carica**, quindi scegli il pacchetto di `transfer_stream_python.zip` distribuzione. Poi, scegli **Salva**. 1. Nella scheda **Codice** della funzione, in **Impostazioni di runtime**, scegliete **Modifica**, quindi immettete i seguenti valori. + In **Runtime**, scegliere **Python 3.7**. + In **Handler (Gestore)**, immetti **transfer\$1stream.function\$1handler** 1. Scegli **Save** (Salva). **Nota** Il pulsante **Test** sulla AWS Lambda console non funziona con questa funzione. Il AWS IoT Greengrass Core SDK non contiene moduli necessari per eseguire le funzioni Greengrass Lambda in modo indipendente nella console. AWS Lambda Questi moduli (ad esempio,`greengrass_common`) vengono forniti alle funzioni dopo essere stati distribuiti nel core Greengrass. 1. Ora, pubblica la prima versione della tua funzione Lambda e crea un [alias per la](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html) versione. **Nota** 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. 1. Nel menu **Actions (Operazioni)**, seleziona **Publish new version (Pubblica nuova versione)**. 1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**. 1. Nella pagina di configurazione **TransferStream: 1**, dal menu **Azioni**, scegli **Crea alias**. 1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori: + In **Nome**, inserisci **GG\$1TransferStream**. + In **Version (Versione)**, selezionare **1**. **Nota** AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.** 1. Scegli **Create** (Crea). Ora sei pronto per aggiungere la funzione Lambda al tuo gruppo Greengrass. ## Fase 3: Aggiungere una funzione Lambda al gruppo Greengrass In questo passaggio, aggiungi la funzione Lambda al gruppo e quindi configuri il ciclo di vita e le variabili di ambiente. Per ulteriori informazioni, consulta [Controllo dell'esecuzione delle funzioni Greengrass Lambda utilizzando la configurazione specifica del gruppo](lambda-group-config.md). 1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**). 1. Scegliere il gruppo target. 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni My Lambda**, scegli Aggiungi.** 1. Nella pagina **Aggiungi funzione Lambda, scegli la funzione** Lambda **per la tua funzione Lambda**. 1. **Per la **versione Lambda**, scegli Alias:gg\$1. TransferStream** Ora configurate le proprietà che determinano il comportamento della funzione Lambda nel gruppo Greengrass. 1. Nella sezione di **configurazione della funzione Lambda**, apporta le seguenti modifiche: + Impostare **Memory limit (Limite di memoria)** su 32 MB. + **Per **Pinned**, scegli 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). 1. Scegli **Aggiungi funzione Lambda**. ## Fase 4: abilitazione di Stream Manager In questa fase, assicurati che stream manager sia abilitato. 1. Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**. 1. In **Funzioni System Lambda**, seleziona **Stream manager** e controlla lo stato. Se disabilitato, scegliere **Edit (Modifica)**. Quindi, scegliere **Enable (Abilita)** e **Save (Salva)**. Puoi utilizzare le impostazioni dei parametri predefinite per questo tutorial. Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass lo stream manager](configure-stream-manager.md). **Nota** Quando si utilizza la console per abilitare lo stream manager e distribuire il gruppo, la dimensione della memoria per lo stream manager è impostata su 4194304 KB (4 GB) per impostazione predefinita. Ti consigliamo di impostare la dimensione della memoria su almeno 128000 KB. ## Fase 5: configurazione della registrazione locale In questo passaggio, configuri i componenti di AWS IoT Greengrass sistema, le funzioni Lambda definite dall'utente e i connettori del gruppo 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. In **Local logs configuration (Configurazione log locale)**, verificare se è configurata la registrazione locale. 1. **Se i log non sono configurati per i componenti del sistema Greengrass o per le funzioni Lambda definite dall'utente, scegli Modifica.** 1. Scegli il livello di **registro delle funzioni User Lambda e il livello di registro** del sistema **Greengrass**. 1. Mantenere i valori predefiniti per il livello di registrazione e il limite di spazio su disco e scegliere **Save (Salva)**. ## Fase 6: distribuzione del gruppo Greengrass 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. **Nella pagina di configurazione del gruppo, scegli Deploy.** 1. 1. **Nella scheda **Funzioni Lambda, nella sezione Funzioni** **System Lambda**, seleziona **Rilevatore IP** e scegli Modifica.** 1. Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **e sostituisci automaticamente gli endpoint del broker MQTT**. 1. Scegli **Save** (Salva). Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito. **Nota** Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi. Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**. Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md). ## Fase 7: 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.md#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. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**). 1. In **Gruppi Greengrass**, scegli il tuo gruppo. 1. **Nella pagina **Lambdas**, scegli i puntini di sospensione (**...**) per la **TransferStream**funzione, quindi scegli Rimuovi funzione.** 1. In **Actions (Operazioni)**, scegliere **Deploy (Distribuisci)**. 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 hai bisogno di ulteriori informazioni sulla risoluzione dei problemi, puoi [impostare il livello di registrazione](#stream-manager-console-configure-logging) per i log **User Lambda** su **Debug logs e quindi distribuire** nuovamente il gruppo. ## Consulta anche + [Gestisci i flussi di dati sul core AWS IoT Greengrass](stream-manager.md) + [Configurare AWS IoT Greengrass lo stream manager](configure-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) + [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md)