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à. # Gestisci i flussi di dati sul core AWS IoT Greengrass AWS IoT Greengrass stream manager semplifica e rende più affidabile il trasferimento di dati IoT ad alto volume a. Cloud AWS Stream Manager elabora i flussi di dati localmente e li esporta automaticamente. Cloud AWS Questa funzionalità si integra con gli scenari edge più comuni, come l'inferenza di machine learning (ML), in cui i dati vengono elaborati e analizzati localmente prima di essere esportati verso le destinazioni di archiviazione Cloud AWS o locali. Stream manager semplifica lo sviluppo di applicazioni. Le applicazioni IoT possono utilizzare un meccanismo standardizzato per elaborare flussi a elevato volume e gestire policy di conservazione dei dati locali anziché creare funzionalità di gestione dei flussi personalizzate. Le applicazioni IoT possono leggere e scrivere nei flussi. Possono definire policy per tipo di storage, dimensioni e conservazione dei dati in base al flusso per controllare in che modo stream manager elabora ed esporta i flussi. Stream manager è progettato per funzionare in ambienti con connettività intermittente o limitata. Puoi definire l'utilizzo della larghezza di banda, il comportamento di timeout e la modalità di gestione dei dati del flusso quando il core è connesso o disconnesso. Per i dati critici, è possibile impostare le priorità per controllare l'ordine in cui i flussi vengono esportati verso. Cloud AWS È possibile configurare le esportazioni automatiche verso Cloud AWS l'archiviazione o l'ulteriore elaborazione e analisi. Stream Manager supporta l'esportazione verso le seguenti Cloud AWS destinazioni. + Canali in AWS IoT Analytics. AWS IoT Analytics consente di eseguire analisi avanzate sui dati per aiutare a prendere decisioni aziendali e migliorare i modelli di apprendimento automatico. Per ulteriori informazioni, consulta [Cos'è AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) nella *Guida AWS IoT Analytics per l'utente*. + Stream in Kinesis Data Streams. Kinesis Data Streams viene comunemente utilizzato per aggregare dati di grandi volumi e caricarli in un data warehouse o in un cluster di riduzione delle mappe. Per ulteriori informazioni, consulta [Cos'è Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html)? nella *Amazon Kinesis Developer Guide*. + Proprietà delle risorse in AWS IoT SiteWise. AWS IoT SiteWise consente di raccogliere, organizzare e analizzare i dati provenienti da apparecchiature industriali su larga scala. Per ulteriori informazioni, consulta [Cos'è AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) nella *Guida AWS IoT SiteWise per l'utente*. + Oggetti in Amazon S3. Puoi usare Amazon S3 per archiviare e recuperare grandi quantità di dati. Per ulteriori informazioni, consulta [Cos'è Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html)? nella *Guida per sviluppatori di Amazon Simple Storage Service*. ## Flusso di lavoro della gestione dei flussi Le tue applicazioni IoT interagiscono con lo stream manager tramite AWS IoT Greengrass Core SDK. In un flusso di lavoro semplice, una funzione Lambda definita dall'utente in esecuzione sul core Greengrass consuma dati IoT, come le metriche di temperatura e pressione delle serie temporali. La funzione Lambda potrebbe filtrare o comprimere i dati e quindi chiamare AWS IoT Greengrass Core SDK per scrivere i dati in uno stream in stream manager. Lo stream manager può esportare lo stream Cloud AWS automaticamente, in base alle politiche definite per lo stream. Le funzioni Lambda definite dall'utente possono anche inviare dati direttamente ai database locali o agli archivi di archiviazione. Le tue applicazioni IoT possono includere più funzioni Lambda definite dall'utente che leggono o scrivono negli stream. Queste funzioni Lambda locali possono leggere e scrivere negli stream per filtrare, aggregare e analizzare i dati localmente. Questo consente di rispondere rapidamente a eventi locali ed estrarre informazioni utili prima che i dati vengano trasferiti dal core nel cloud o in destinazioni locali. Un flusso di lavoro di esempio è mostrato nel diagramma seguente. ![\[Diagramma del flusso di lavoro di stream manager.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/stream-manager-architecture.png) Per utilizzare lo stream manager, inizia configurando i parametri dello stream manager per definire le impostazioni di runtime a livello di gruppo che si applicano a tutti gli stream sul core Greengrass. Queste impostazioni personalizzabili consentono di controllare il modo in cui lo stream manager archivia, elabora ed esporta i flussi in base alle esigenze aziendali e ai vincoli ambientali. Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass lo stream manager](configure-stream-manager.md). Dopo aver configurato lo stream manager, puoi creare e distribuire le tue applicazioni IoT. Si tratta in genere di funzioni Lambda definite dall'utente che vengono `StreamManagerClient` utilizzate AWS IoT Greengrass nell'SDK Core per creare e interagire con gli stream. Durante la creazione dello stream, la funzione Lambda definisce le policy per flusso, come le destinazioni di esportazione, la priorità e la persistenza. Per ulteriori informazioni, inclusi frammenti di codice per le operazioni, consulta. `StreamManagerClient` [Utilizzalo StreamManagerClient per lavorare con gli stream](work-with-streams.md) Per i tutorial che configurano un flusso di lavoro semplice, consulta o. [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.md) [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) ## Requisiti Per l'utilizzo di stream manager si applicano i seguenti requisiti: + È necessario utilizzare il software AWS IoT Greengrass Core v1.10 o versione successiva, con lo stream manager abilitato. Per ulteriori informazioni, consulta [Configurare AWS IoT Greengrass lo stream manager](configure-stream-manager.md). Lo stream manager non è supportato nelle distribuzioni. OpenWrt + Java 8 Runtime (JDK 8) deve essere installato sul core. + 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.   + Stream Manager richiede un minimo di 70 MB di RAM in aggiunta al software AWS IoT Greengrass Core di base. Il requisito di memoria totale dipende dal carico di lavoro.   + Le funzioni Lambda definite dall'utente devono utilizzare [AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks-core) SDK per interagire con lo stream manager. Il AWS IoT Greengrass Core SDK è disponibile in diverse lingue, ma solo le seguenti versioni supportano le operazioni di gestione degli stream: + Java SDK (v1.4.0 o versione successiva) + Python SDK (v1.5.0 o successivo) + Node.js SDK (v1.6.0 o successivo) Scarica la versione dell'SDK che corrisponde al runtime della tua funzione Lambda e includila nel pacchetto di distribuzione della funzione Lambda. **Nota** Il AWS IoT Greengrass Core SDK per Python richiede Python 3.7 o versione successiva e ha altre dipendenze dai pacchetti. Per ulteriori informazioni, consulta [Creare un pacchetto di distribuzione di funzioni Lambda (console) o Creare un pacchetto](stream-manager-console.md#stream-manager-console-create-deployment-package) [di distribuzione di funzioni Lambda (](stream-manager-cli.md#stream-manager-cli-create-deployment-package)CLI). + Se definisci le destinazioni di Cloud AWS esportazione per uno stream, devi creare i tuoi obiettivi di esportazione e concedere le autorizzazioni di accesso nel ruolo del gruppo Greengrass. A seconda della destinazione, potrebbero applicarsi anche altri requisiti. Per ulteriori informazioni, consultare: + [AWS IoT Analytics canali](stream-export-configurations.md#export-to-iot-analytics) + [Flussi di dati Amazon Kinesis](stream-export-configurations.md#export-to-kinesis) + [AWS IoT SiteWise proprietà degli asset](stream-export-configurations.md#export-to-iot-sitewise) + [Oggetti Amazon S3](stream-export-configurations.md#export-to-s3) L'utente è responsabile del mantenimento di queste Cloud AWS risorse. ## Sicurezza dei dati Quando utilizzi stream manager, tiene presente le seguenti considerazioni di sicurezza. ### Sicurezza dei dati locali AWS IoT Greengrass non crittografa i dati di flusso inattivi o in transito localmente tra i componenti del dispositivo principale. + **Dati inattivi**. I dati di streaming vengono archiviati localmente in una directory di archiviazione sul core Greengrass. Per la sicurezza dei dati, AWS IoT Greengrass si affida alle autorizzazioni dei file Unix e alla crittografia dell'intero disco, se abilitata. Puoi utilizzare il parametro [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) opzionale per specificare la directory di storage. Se si modifica questo parametro in un secondo momento per utilizzare una directory di archiviazione diversa, AWS IoT Greengrass non elimina la directory di archiviazione precedente o il relativo contenuto.   + **Dati in transito a livello locale**. AWS IoT Greengrass non crittografa i dati di flusso in transito locale sul core tra fonti di dati, funzioni Lambda, AWS IoT Greengrass Core SDK e stream manager.   + **Dati in transito verso**. Cloud AWS I flussi di dati esportati da Stream Manager Cloud AWS utilizzano la crittografia client di AWS servizio standard con Transport Layer Security (TLS). Per ulteriori informazioni, consulta [Crittografia dei dati](data-encryption.md). ### Autenticazione client I client Stream Manager utilizzano AWS IoT Greengrass Core SDK per comunicare con lo stream manager. Quando l'autenticazione client è abilitata, solo le funzioni Lambda del gruppo Greengrass possono interagire con gli stream in stream manager. Quando l'autenticazione client è disabilitata, qualsiasi processo in esecuzione sul core Greengrass (ad esempio i [container Docker](docker-app-connector.md)) può interagire con i flussi in stream manager. È opportuno disabilitare l'autenticazione solo se richiesto dal business case. Utilizza il parametro [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT) per impostare la modalità di autenticazione client. È possibile configurare questo parametro dalla console o dall'API. AWS IoT Greengrass Le modifiche diventano effettive dopo la distribuzione del gruppo. **** |   | Abilitato | Disabilitato | | --- | --- | --- | | Valore del parametro | `true` (predefinito e consigliato) | `false` | | Client consentiti | Funzioni Lambda definite dall'utente nel gruppo Greengrass | Funzioni Lambda definite dall'utente nel gruppo Greengrass Altri processi in esecuzione sul dispositivo core Greengrass | ## Consulta anche + [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 (console)](stream-manager-console.md) + [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) # Configurare AWS IoT Greengrass lo stream manager AWS IoT Greengrass Fondamentalmente, lo stream manager può archiviare, elaborare ed esportare i dati dei dispositivi IoT. Stream manager fornisce i parametri utilizzati per configurare le impostazioni di runtime a livello del gruppo. Queste impostazioni si applicano a tutti i flussi sul core Greengrass. Puoi utilizzare la AWS IoT console o l' AWS IoT Greengrass API per configurare le impostazioni dello stream manager. Le modifiche diventano effettive dopo la distribuzione del gruppo. **Nota** Dopo aver configurato lo stream manager, puoi creare e distribuire applicazioni IoT che funzionano sul core Greengrass e interagiscono con lo stream manager. Queste applicazioni IoT sono in genere funzioni Lambda definite dall'utente. Per ulteriori informazioni, consulta [Utilizzalo StreamManagerClient per lavorare con gli stream](work-with-streams.md). ## Parametri di Stream Manager Stream manager fornisce i seguenti parametri che consentono di definire le impostazioni a livello del gruppo. Tutti i parametri sono opzionali: **Directory di storage** Nome parametro: `STREAM_MANAGER_STORE_ROOT_DIR` Il percorso assoluto della directory locale utilizzata per archiviare i flussi. Questo valore deve iniziare con una barra (ad esempio, `/data`). Per informazioni relative alla protezione dei dati del flusso, consulta [Sicurezza dei dati locali](stream-manager.md#stream-manager-security-stream-data). Versione minima AWS IoT Greengrass Core: 1.10.0 **Porta del server** Nome parametro: `STREAM_MANAGER_SERVER_PORT` Il numero di porta locale utilizzato per comunicare con stream manager. Il valore predefinito è `8088`. Versione minima AWS IoT Greengrass Core: 1.10.0 **Autentica client** Nome parametro: `STREAM_MANAGER_AUTHENTICATE_CLIENT` Indica se i client devono essere autenticati per interagire con stream manager. Tutte le interazioni tra i client e lo stream manager sono controllate dal AWS IoT Greengrass Core SDK. Questo parametro determina quali client possono chiamare il AWS IoT Greengrass Core SDK per lavorare con gli stream. Per ulteriori informazioni, consulta [Autenticazione client](stream-manager.md#stream-manager-security-client-authentication). I valori validi sono `true` e `false`. Il valore predefinito è `true` (consigliato). + `true`. Consente solo le funzioni Greengrass Lambda come client. I client con funzioni Lambda utilizzano i protocolli di AWS IoT Greengrass base interni per l'autenticazione con Core SDK. AWS IoT Greengrass + `false`. Consente a qualsiasi processo in esecuzione sul AWS IoT Greengrass core di essere un client. Non impostare su `false` meno che non venga richiesto dal business case. Ad esempio, imposta questo valore `false` solo se i processi non Lambda sul dispositivo principale devono comunicare direttamente con lo stream manager, come i [contenitori Docker](docker-app-connector.md) in esecuzione sul core. Versione minima AWS IoT Greengrass Core: 1.10.0 **Larghezza di banda massima** Nome parametro: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH` La larghezza di banda massima media (in kilobit al secondo) che può essere utilizzata per esportare i dati. L'impostazione predefinita consente l'uso illimitato della larghezza di banda disponibile. Versione minima AWS IoT Greengrass Core: 1.10.0 **Dimensione del pool di thread** Nome parametro: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE` Il numero massimo di thread attivi che possono essere utilizzati per esportare i dati. Il valore predefinito è `5`. La dimensione ottimale dipende dall'hardware, dal volume del flusso e dal numero pianificato di flussi di esportazione. Se la velocità di esportazione è bassa, puoi regolare questa impostazione per trovare la dimensione ottimale per l'hardware e il business case. La CPU e la memoria dell'hardware del dispositivo core sono fattori limitanti. Per iniziare, è possibile provare a impostare questo valore uguale al numero di core di processore sul dispositivo. Fare attenzione a non impostare una dimensione superiore a quella supportata dall'hardware. Ogni flusso consuma risorse hardware, pertanto occorre provare a limitare il numero di flussi di esportazione sui dispositivi vincolati. Versione minima AWS IoT Greengrass Core: 1.10.0 **Argomenti JVM** Nome parametro: `JVM_ARGS` Argomenti Java Virtual Machine personalizzati da passare a Stream Manager all'avvio. Più argomenti devono essere separati da spazi. Utilizza questo parametro solo quando devi sostituire le impostazioni predefinite utilizzate dalla JVM. Ad esempio, potrebbe essere necessario aumentare la dimensione heap predefinita se prevedi di esportare un numero elevato di flussi. Versione minima AWS IoT Greengrass Core: 1.10.0 **Directory di file di input di sola lettura** Nome parametro: `STREAM_MANAGER_READ_ONLY_DIRS` Un elenco separato da virgole di percorsi assoluti alle directory esterne al file system root che memorizzano i file di input. Stream Manager legge e carica i file su Amazon S3 e monta le directory come di sola lettura. Per ulteriori informazioni sull'esportazione in Amazon S3, consulta. [Oggetti Amazon S3](stream-export-configurations.md#export-to-s3) Utilizza questo parametro solo se sono vere le seguenti condizioni: + La directory dei file di input per uno stream che esporta in Amazon S3 si trova in una delle seguenti posizioni: + Una partizione diversa dal file system root. + Si `/tmp` trova nel file system root. + **La [containerizzazione predefinita](lambda-group-config.md#lambda-containerization-groupsettings) del gruppo Greengrass è il contenitore Greengrass.** Valore di esempio: `/mnt/directory-1,/mnt/directory-2,/tmp` Versione minima Core: 1.11.0 AWS IoT Greengrass **Dimensione minima per il caricamento in più parti** Nome parametro: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES` La dimensione minima (in byte) di una parte in un caricamento multiparte su Amazon S3. Stream Manager utilizza questa impostazione e la dimensione del file di input per determinare come raggruppare i dati in una richiesta PUT composta da più parti. Il valore minimo e predefinito è di `5242880` byte (5 MB). Stream Manager utilizza la `sizeThresholdForMultipartUploadBytes` proprietà dello stream per determinare se esportare in Amazon S3 come caricamento singolo o multiparte. Le funzioni Lambda definite dall'utente impostano questa soglia quando creano uno stream che esporta in Amazon S3. La soglia predefinita è 5 MB. Versione minima AWS IoT Greengrass del core: 1.11.0 ## Configurazione delle impostazioni di Stream Manager (console) È possibile utilizzare la AWS IoT console per le seguenti attività di gestione: + [Verificare se Stream Manager è abilitato](#check-stream-manager-console) + [Abilitazione o disabilitazione di Stream Manager durante la creazione del gruppo](#enable-stream-manager-console-new-group) + [Abilitazione o disabilitazione di Stream Manager per un gruppo esistente](#enable-stream-manager-console-existing-group) + [Modifica delle impostazioni di Stream Manager](#change-stream-manager-console) Le modifiche diventano effettive dopo la distribuzione del gruppo Greengrass. Per un tutorial che mostra come implementare un gruppo Greengrass che contiene una funzione Lambda che interagisce con lo stream manager, vedi. [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.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.   ### Per verificare se stream manager è abilitato (console) 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. Scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, seleziona **Stream manager** e scegli Modifica.** 1. Controlla lo stato abilitato o disabilitato. Vengono visualizzate anche le eventuali impostazioni di stream manager personalizzate configurate.   ### Per abilitare o disabilitare stream manager durante la creazione del gruppo (console) 1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**). 1. Selezionare **Create Group (Crea gruppo)**. L'opzione scelta nella pagina successiva determina come configurare stream manager per il gruppo. 1. Procedi attraverso la sezione **Assegna un nome al tuo gruppo** e scegli una delle pagine **principali di Greengrass**. 1. Seleziona **Crea gruppo**. 1. **Nella pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**, seleziona **Stream manager** e scegli Modifica.** + Per abilitare lo stream manager con le impostazioni predefinite, scegli **Abilita con impostazioni predefinite**.   + Per abilitare stream manager con impostazioni personalizzate, scegliere **Customize settings (Personalizza impostazioni)**. 1. Nella pagina **Configura Stream manager**, scegli **Abilita con impostazioni personalizzate**. 1. In **Custom settings (Impostazioni personalizzate)**, immettere i valori per i parametri di stream manager. Per ulteriori informazioni, consulta [Parametri di Stream Manager](#stream-manager-parameters). Lascia i campi vuoti AWS IoT Greengrass per consentire l'utilizzo dei valori predefiniti.   + Per disabilitare lo stream manager, scegli **Disabilita**. 1. Nella pagina **Configure stream manager (Configura stream manager)**, scegliere **Disable (Disabilita)**.   1. Scegli **Save** (Salva). 1. Continuare attraverso le pagine rimanenti per creare il tuo gruppo. 1. Nella pagina **Dispositivi client**, scarica le risorse di sicurezza, esamina le informazioni, quindi scegli **Fine**. **Nota** Quando stream manager è abilitato, è necessario [installare il runtime Java 8](stream-manager.md#stream-manager-requirements) sul dispositivo core prima di distribuire il gruppo.   ### Per abilitare o disabilitare stream manager per un gruppo esistente (console) 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. Scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, seleziona **Stream manager** e scegli Modifica.** 1. Controlla lo stato abilitato o disabilitato. Vengono visualizzate anche le eventuali impostazioni di stream manager personalizzate configurate.   ### Per modificare le impostazioni di stream manager (console) 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. Scegli la scheda **Funzioni Lambda**. 1. **In **Funzioni System Lambda**, seleziona **Stream manager** e scegli Modifica.** 1. Controlla lo stato abilitato o disabilitato. Vengono visualizzate anche le eventuali impostazioni di stream manager personalizzate configurate. 1. Scegli **Save** (Salva). ## Configurazione delle impostazioni di Stream Manager (CLI) Nel AWS CLI, utilizzare la funzione `GGStreamManager` Lambda del sistema per configurare lo stream manager. Le funzioni System Lambda sono componenti del software AWS IoT Greengrass Core. Per lo stream manager e alcune altre funzioni Lambda del sistema, è possibile configurare la funzionalità Greengrass gestendo gli oggetti corrispondenti `Function` e `FunctionDefinitionVersion` nel gruppo Greengrass. Per ulteriori informazioni, consulta [Panoramica del modello a oggetti di AWS IoT Greengrass gruppo](deployments.md#api-overview). È possibile utilizzare l'API per le seguenti attività di gestione. Gli esempi in questa sezione mostrano come utilizzare AWS CLI, ma puoi anche chiamare l' AWS IoT Greengrass API direttamente o utilizzare un AWS SDK. + [Verificare se Stream Manager è abilitato](#check-stream-manager-cli) + [Abilitare, disabilitare o configurare lo stream manager](#enable-stream-manager-cli) Le modifiche diventano effettive dopo la distribuzione del gruppo. Per un tutorial che mostra come implementare un gruppo Greengrass con una funzione Lambda che interagisce con lo stream manager, vedi. [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) **Suggerimento** Per verificare se lo stream manager è abilitato e se è in esecuzione dal dispositivo principale, puoi eseguire il seguente comando in un terminale del dispositivo. ``` ps aux | grep -i 'streammanager' ```   ### Per verificare se stream manager è abilitato (CLI) Stream Manager è abilitato se la versione di definizione della funzione distribuita include la funzione `GGStreamManager` Lambda di sistema. Per verificare, procedere come segue: 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 i valori `Id` e `LatestVersion` dal gruppo target nell'output. 1. Ottieni la versione gruppo più recente. + Sostituisci l’*group-id* con l’`Id` copiato. + Sostituisci l’*latest-group-version-id* con l’`LatestVersion` copiato. ``` aws greengrass get-group-version \ --group-id group-id \ --group-version-id latest-group-version-id ``` 1. Dall'`FunctionDefinitionVersionArn`output, ottieni la definizione della funzione e la versione IDs della definizione della funzione. + L'ID di definizione della funzione è il GUID che segue il `functions` segmento nell'Amazon Resource Name (ARN). + L'ID versione della definizione della funzione è il GUID che segue il segmento `versions` nell'ARN. ``` arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/function-definition-id/versions/function-definition-version-id ``` 1. Ottenere la versione di definizione della funzione. + Sostituisci *function-definition-id* con l'ID di definizione della funzione. + Sostituisci *function-definition-version-id* con l'ID della versione della definizione della funzione. ``` aws greengrass get-function-definition-version \ --function-definition-id function-definition-id \ --function-definition-version-id function-definition-version-id ``` Se l'array `functions` nell'output include la funzione `GGStreamManager`, allora stream manager è abilitato. Le eventuali variabili di ambiente definite per la funzione rappresentano impostazioni personalizzate per stream manager. ### Per abilitare, disabilitare o configurare lo stream manager (CLI) Nel AWS CLI, utilizzare la funzione `GGStreamManager` Lambda del sistema per configurare lo stream manager. Le modifiche diventano effettive dopo la distribuzione del gruppo. + Per abilitare stream manager, includi `GGStreamManager` nell'array `functions` della versione di definizione della funzione. Per configurare le impostazioni personalizzate, definisci le variabili di ambiente per i [parametri di Gestore di flussi](#stream-manager-parameters) corrispondenti. + Per disabilitare stream manager, rimuovi `GGStreamManager` dall'array `functions` della versione di definizione della funzione. **Gestore di flussi con impostazioni predefinite** La configurazione di esempio seguente consente di abilitare stream manager con impostazioni predefinite. Imposta l'ID della funzione arbitraria su `streamManager`. ``` { "FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": { "MemorySize": 4194304, "Pinned": true, "Timeout": 3 }, "Id": "streamManager" } ``` Per quanto riguarda le `FunctionConfiguration` proprietà, potresti sapere quanto segue: + `MemorySize`è impostato su 4194304 KB (4 GB) con le impostazioni predefinite. È sempre possibile modificare questo valore. Ti consigliamo di `MemorySize` impostarlo su almeno 128000 KB. + `Pinned` deve essere impostato su `true`. + `Timeout` è richiesto dalla versione di definizione della funzione, ma non viene utilizzato da `GGStreamManager`. **Gestore di flussi con impostazioni personalizzate** La configurazione di esempio seguente abilita lo stream manager con valori personalizzati per i parametri della directory di archiviazione, della porta del server e della dimensione del pool di thread. ``` { "FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": { "Environment": { "Variables": { "STREAM_MANAGER_STORE_ROOT_DIR": "/data", "STREAM_MANAGER_SERVER_PORT": "1234", "STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4" } }, "MemorySize": 4194304, "Pinned": true, "Timeout": 3 }, "Id": "streamManager" } ``` AWS IoT Greengrass utilizza valori predefiniti per i [parametri dello stream manager](#stream-manager-parameters) che non sono specificati come variabili di ambiente. **Stream manager con impostazioni personalizzate per le esportazioni di Amazon S3** La seguente configurazione di esempio abilita lo stream manager con valori personalizzati per la directory di caricamento e parametri minimi di dimensione di caricamento multiparte. ``` { "FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": { "Environment": { "Variables": { "STREAM_MANAGER_READ_ONLY_DIRS": "/mnt/directory-1,/mnt/directory-2,/tmp", "STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES": "10485760" } }, "MemorySize": 4194304, "Pinned": true, "Timeout": 3 }, "Id": "streamManager" } ```   **Per abilitare, disabilitare o configurare lo stream manager (CLI)** 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 i valori `Id` e `LatestVersion` dal gruppo target nell'output. 1. Ottieni la versione gruppo più recente. + Sostituisci l’*group-id* con l’`Id` copiato. + Sostituisci l’*latest-group-version-id* con l’`LatestVersion` copiato. ``` aws greengrass get-group-version \ --group-id group-id \ --group-version-id latest-group-version-id ``` 1. Copia la versione `CoreDefinitionVersionArn` e tutte le altre ARNs dall'output, tranne. `FunctionDefinitionVersionArn` Questi valori verranno utilizzati successivamente quando si crea una versione di gruppo. 1. Da `FunctionDefinitionVersionArn` nell'output, copia l'ID della definizione della funzione. L'ID è il GUID che segue il segmento `functions` nell'ARN, come mostrato nell'esempio seguente. ``` arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6 ``` **Nota** In alternativa, è possibile creare una definizione di funzione eseguendo il [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html)comando e quindi copiando l'ID dall'output. 1. Aggiungi una versione di definizione della funzione alla definizione della funzione. + *function-definition-id*Sostituiscilo con `Id` quello che hai copiato per la definizione della funzione. + Nell'`functions`array, includi tutte le altre funzioni che desideri rendere disponibili sul core Greengrass. Puoi utilizzare il comando `get-function-definition-version` per ottenere l'elenco delle funzioni esistenti.   **Abilitazione di stream manager con impostazioni predefinite** L'esempio seguente abilita lo stream manager, includendo la `GGStreamManager` funzione nell'`functions`array. In questo esempio vengono utilizzati i valori predefiniti per i [parametri di Gestore di flussi](#stream-manager-parameters). ``` aws greengrass create-function-definition-version \ --function-definition-id function-definition-id \ --functions '[ { "FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": { "MemorySize": 4194304, "Pinned": true, "Timeout": 3 }, "Id": "streamManager" }, { "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias", "FunctionConfiguration": { "Executable": "myLambdaFunction.function_handler", "MemorySize": 16000, "Pinned": true, "Timeout": 5 }, "Id": "myLambdaFunction" }, ... more user-defined functions ] }' ``` La `myLambdaFunction` funzione negli esempi rappresenta una delle funzioni Lambda definite dall'utente. **Abilitazione di stream manager con impostazioni personalizzate** L'esempio seguente abilita Gestore di flussi includendo la funzione `GGStreamManager` nell'array `functions`. Tutte le impostazioni dello stream manager sono opzionali, a meno che non si desideri modificare i valori predefiniti. Questo esempio mostra come utilizzare le variabili di ambiente per impostare valori personalizzati. ``` aws greengrass create-function-definition-version \ --function-definition-id function-definition-id \ --functions '[ { "FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1", "FunctionConfiguration": { "Environment": { "Variables": { "STREAM_MANAGER_STORE_ROOT_DIR": "/data", "STREAM_MANAGER_SERVER_PORT": "1234", "STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE": "4" } }, "MemorySize": 4194304, "Pinned": true, "Timeout": 3 }, "Id": "streamManager" }, { "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias", "FunctionConfiguration": { "Executable": "myLambdaFunction.function_handler", "MemorySize": 16000, "Pinned": true, "Timeout": 5 }, "Id": "myLambdaFunction" }, ... more user-defined functions ] }' ``` Per quanto riguarda le `FunctionConfiguration` proprietà, potresti sapere quanto segue: + `MemorySize`è impostato su 4194304 KB (4 GB) con le impostazioni predefinite. È sempre possibile modificare questo valore. Ti consigliamo di `MemorySize` impostarlo su almeno 128000 KB. + `Pinned` deve essere impostato su `true`. + `Timeout` è richiesto dalla versione di definizione della funzione, ma non viene utilizzato da `GGStreamManager`. **Disabilitazione di Gestore di flussi** L'esempio seguente omette la funzione `GGStreamManager`, che disabilita Gestore di flussi. ``` aws greengrass create-function-definition-version \ --function-definition-id function-definition-id \ --functions '[ { "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:MyLambdaFunction:MyAlias", "FunctionConfiguration": { "Executable": "myLambdaFunction.function_handler", "MemorySize": 16000, "Pinned": true, "Timeout": 5 }, "Id": "myLambdaFunction" }, ... more user-defined functions ] }' ``` Se non desideri distribuire alcuna funzione Lambda, puoi omettere completamente la versione della definizione della funzione. 1. Copia l'`Arn` della definizione di funzione dall'output. 1. Crea una versione di gruppo che contenga la funzione Lambda del sistema. + Sostituisci *group-id* con `Id` for the group. + Sostituiscilo *core-definition-version-arn* con `CoreDefinitionVersionArn` quello che hai copiato dalla versione più recente del gruppo. + Sostituiscilo *function-definition-version-arn* con `Arn` quello che hai copiato per la nuova versione della definizione di funzione. + Sostituisci ARNs i componenti degli altri gruppi (ad esempio, `SubscriptionDefinitionVersionArn` o`DeviceDefinitionVersionArn`) che hai copiato dalla versione più recente del gruppo. + Rimuovi eventuali parametri inutilizzati. Ad esempio, rimuovi `--resource-definition-version-arn` se la versione gruppo non contiene risorse. ``` 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 \ --device-definition-version-arn device-definition-version-arn \ --logger-definition-version-arn logger-definition-version-arn \ --resource-definition-version-arn resource-definition-version-arn \ --subscription-definition-version-arn subscription-definition-version-arn ``` 1. Copia il valore `Version` dall'output. Questo è l'ID della nuova versione gruppo. 1. Distribuisci il gruppo con la nuova versione del gruppo. + Sostituiscilo *group-id* 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 \ --group-id group-id \ --group-version-id group-version-id \ --deployment-type NewDeployment ```   Segui questa procedura se desideri modificare nuovamente le impostazioni dello stream manager in un secondo momento. Assicurati di creare una versione della definizione della funzione che includa la `GGStreamManager` funzione con la configurazione aggiornata. La versione di gruppo deve fare riferimento a tutte le versioni dei componenti ARNs che si desidera distribuire nel core. Le modifiche diventano effettive dopo la distribuzione 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) + [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.md) + [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) # Utilizzalo StreamManagerClient per lavorare con gli stream Le funzioni Lambda definite dall'utente in esecuzione AWS IoT Greengrass sul core possono utilizzare `StreamManagerClient` l'oggetto nel [AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks) SDK per creare [stream in stream manager e quindi interagire con gli stream](stream-manager.md). Quando una funzione Lambda crea un flusso, definisce le Cloud AWS destinazioni, l'assegnazione delle priorità e altre politiche di esportazione e conservazione dei dati per lo stream. Per inviare dati allo stream manager, le funzioni Lambda aggiungono i dati allo stream. Se viene definita una destinazione di esportazione per lo stream, stream manager esporta il flusso automaticamente. **Nota** In genere, i client di stream manager sono funzioni Lambda definite dall'utente. Se il tuo business case lo richiede, puoi anche consentire ai processi non Lambda in esecuzione sul core Greengrass (ad esempio, un contenitore Docker) di interagire con lo stream manager. Per ulteriori informazioni, consulta [Autenticazione client](stream-manager.md#stream-manager-security-client-authentication). Gli snippet di questo argomento mostrano come i client `StreamManagerClient` chiamano i metodi per lavorare con gli stream. Per i dettagli di implementazione sui metodi e i relativi argomenti, utilizzate i collegamenti al riferimento SDK elencati dopo ogni frammento. Per i tutorial che includono una funzione Lambda di Python completa, consulta o. [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.md) [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) La tua funzione Lambda dovrebbe creare un'istanza `StreamManagerClient` all'esterno del gestore delle funzioni. Se viene creata un'istanza nel gestore, la funzione crea un `client` e una connessione al gestore flussi ogni volta che viene richiamata. **Nota** Se si esegue un'istanza `StreamManagerClient` nel gestore, è necessario chiamare esplicitamente il metodo `close()` quando `client` completa il suo lavoro. In caso contrario, `client` mantiene la connessione aperta e un altro thread in esecuzione fino alla chiusura dello script. `StreamManagerClient` supporta le seguenti operazioni: + [Creazione del flusso di messaggi](#streammanagerclient-create-message-stream) + [Aggiunta di un messaggio](#streammanagerclient-append-message) + [Lettura di messaggi](#streammanagerclient-read-messages) + [Visualizzazione dell'elenco di flussi](#streammanagerclient-list-streams) + [Descrizione del flusso di messaggi](#streammanagerclient-describe-message-stream) + [Aggiorna il flusso di messaggi](#streammanagerclient-update-message-stream) + [Eliminazione del flusso di messaggi](#streammanagerclient-delete-message-stream) ## Creazione del flusso di messaggi Per creare uno stream, una funzione Lambda definita dall'utente chiama il metodo create e passa un oggetto. `MessageStreamDefinition` Questo oggetto specifica il nome univoco dello stream e definisce come lo stream manager deve gestire i nuovi dati quando viene raggiunta la dimensione massima del flusso. È possibile utilizzare `MessageStreamDefinition` e relativi tipi di dati (ad esempio `ExportDefinition`, `StrategyOnFull` e `Persistence`) per definire altre proprietà del flusso. Ciò include: + L'obiettivo AWS IoT Analytics, Kinesis Data AWS IoT SiteWise Streams e le destinazioni Amazon S3 per le esportazioni automatiche. Per ulteriori informazioni, consulta [Esporta le configurazioni per le destinazioni supportate Cloud AWS](stream-export-configurations.md). + Priorità di esportazione. Stream manager esporta i flussi con priorità più alta prima dei flussi con priorità più bassa. + Dimensione e intervallo massimi del batch per AWS IoT Analytics Kinesis Data Streams e destinazioni. AWS IoT SiteWise Stream manager esporta i messaggi quando viene soddisfatta una delle due condizioni. + Time-to-live (TTL). Il tempo necessario per garantire che i dati del flusso siano disponibili per l'elaborazione. È necessario assicurarsi che i dati possano essere utilizzati entro questo periodo di tempo. Questa non è una policy di eliminazione. È possibile che i dati non vengano eliminati immediatamente dopo il periodo TTL. + Persistenza del flusso. Scegliere di salvare i flussi nel file system per mantenere i dati tra riavvii core o salvare i flussi in memoria. + Numero di sequenza iniziale. Specificate il numero di sequenza del messaggio da utilizzare come messaggio iniziale nell'esportazione. Per ulteriori informazioni su`MessageStreamDefinition`, consultate il riferimento SDK per la lingua di destinazione: + [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)nell'SDK Java + [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)nell'SDK Node.js + [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)nell'SDK Python **Nota** `StreamManagerClient`fornisce anche una destinazione di destinazione che è possibile utilizzare per esportare flussi su un server HTTP. Questo target è destinato esclusivamente a scopi di test. Non è stabile né è supportato per l'uso in ambienti di produzione. Dopo aver creato uno stream, le funzioni Lambda possono [aggiungere messaggi](#streammanagerclient-append-message) allo stream per inviare dati per l'esportazione e [leggere i messaggi](#streammanagerclient-append-message) dallo stream per l'elaborazione locale. Il numero di flussi creati dipende dalle funzionalità hardware e dal business case. Una strategia consiste nel creare un flusso per ogni canale di destinazione nel AWS IoT Analytics nostro flusso di dati Kinesis, sebbene sia possibile definire più destinazioni per un flusso. Un flusso ha una lunga durata. ### Requisiti Questa operazione ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 **Nota** La creazione di stream con una destinazione AWS IoT SiteWise di esportazione Amazon S3 presenta i seguenti requisiti: Versione minima AWS IoT Greengrass Core: 1.11.0 Versione minima AWS IoT Greengrass Core SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0 ### Esempi Il frammento di codice seguente crea un flusso denominato `StreamName`. Definisce le proprietà del flusso nei tipi di dati subordinati. `MessageStreamDefinition` ------ #### [ Python ] ``` client = StreamManagerClient() try: client.create_message_stream(MessageStreamDefinition( name="StreamName", # Required. max_size=268435456, # Default is 256 MB. stream_segment_size=16777216, # Default is 16 MB. time_to_live_millis=None, # By default, no TTL is enabled. strategy_on_full=StrategyOnFull.OverwriteOldestData, # Required. persistence=Persistence.File, # Default is File. flush_on_write=False, # Default is false. export_definition=ExportDefinition( # Optional. Choose where/how the stream is exported to the Cloud AWS. kinesis=None, iot_analytics=None, iot_sitewise=None, s3_task_executor=None ) )) except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: create\$1message\$1stream \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.create_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { client.createMessageStream( new MessageStreamDefinition() .withName("StreamName") // Required. .withMaxSize(268435456L) // Default is 256 MB. .withStreamSegmentSize(16777216L) // Default is 16 MB. .withTimeToLiveMillis(null) // By default, no TTL is enabled. .withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required. .withPersistence(Persistence.File) // Default is File. .withFlushOnWrite(false) // Default is false. .withExportDefinition( // Optional. Choose where/how the stream is exported to the Cloud AWS. new ExportDefinition() .withKinesis(null) .withIotAnalytics(null) .withIotSitewise(null) .withS3TaskExecutor(null) ) ); } catch (StreamManagerException e) { // Properly handle exception. } ``` Riferimento a Java [createMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)SDK: \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { await client.createMessageStream( new MessageStreamDefinition() .withName("StreamName") // Required. .withMaxSize(268435456) // Default is 256 MB. .withStreamSegmentSize(16777216) // Default is 16 MB. .withTimeToLiveMillis(null) // By default, no TTL is enabled. .withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required. .withPersistence(Persistence.File) // Default is File. .withFlushOnWrite(false) // Default is false. .withExportDefinition( // Optional. Choose where/how the stream is exported to the Cloud AWS. new ExportDefinition() .withKinesis(null) .withIotAnalytics(null) .withIotSitewise(null) .withS3TaskExecutor(null) ) ); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: \$1 [createMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream) ------ Per ulteriori informazioni sulla configurazione delle destinazioni di esportazione, consulta. [Esporta le configurazioni per le destinazioni supportate Cloud AWS](stream-export-configurations.md)   ## Aggiunta di un messaggio Per inviare dati allo stream manager per l'esportazione, le funzioni Lambda aggiungono i dati allo stream di destinazione. La destinazione di esportazione determina il tipo di dati da passare a questo metodo. ### Requisiti Questa operazione presenta i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 **Nota** L'aggiunta di messaggi con una destinazione AWS IoT SiteWise di esportazione Amazon S3 presenta i seguenti requisiti: Versione minima AWS IoT Greengrass Core: 1.11.0 Versione minima AWS IoT Greengrass Core SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0 ### Esempi #### AWS IoT Analytics o destinazioni di esportazione Kinesis Data Streams Il frammento di codice seguente aggiunge un messaggio al flusso denominato `StreamName`. Per le AWS IoT Analytics nostre destinazioni Kinesis Data Streams, le funzioni Lambda aggiungono un blob di dati. Questo frammento ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 ------ #### [ Python ] ``` client = StreamManagerClient() try: sequence_number = client.append_message(stream_name="StreamName", data=b'Arbitrary bytes data') except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento Python SDK: append\$1message](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes()); } catch (StreamManagerException e) { // Properly handle exception. } ``` [Riferimento Java SDK: AppendMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const sequenceNumber = await client.appendMessage("StreamName", Buffer.from("Arbitrary byte array")); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` [Riferimento SDK Node.js: appendMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) ------ #### AWS IoT SiteWise destinazioni di esportazione Il frammento di codice seguente aggiunge un messaggio al flusso denominato `StreamName`. Per le AWS IoT SiteWise destinazioni, le funzioni Lambda aggiungono un oggetto serializzato. `PutAssetPropertyValueEntry` Per ulteriori informazioni, consulta [Esportazione in AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise). **Nota** Quando si inviano dati a AWS IoT SiteWise, i dati devono soddisfare i requisiti dell'azione. `BatchPutAssetPropertyValue` Per ulteriori informazioni, consulta [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) nella *documentazione di riferimento dell’API AWS IoT SiteWise *. Questo frammento presenta i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.11.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0 ------ #### [ Python ] ``` client = StreamManagerClient() try: # SiteWise requires unique timestamps in all messages. Add some randomness to time and offset. # Note: To create a new asset property data, you should use the classes defined in the # greengrasssdk.stream_manager module. time_in_nanos = TimeInNanos( time_in_seconds=calendar.timegm(time.gmtime()) - random.randint(0, 60), offset_in_nanos=random.randint(0, 10000) ) variant = Variant(double_value=random.random()) asset = [AssetPropertyValue(value=variant, quality=Quality.GOOD, timestamp=time_in_nanos)] putAssetPropertyValueEntry = PutAssetPropertyValueEntry(entry_id=str(uuid.uuid4()), property_alias="PropertyAlias", property_values=asset) sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(putAssetPropertyValueEntry)) except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: append\$1message \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.PutAssetPropertyValueEntry)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { Random rand = new Random(); // Note: To create a new asset property data, you should use the classes defined in the // com.amazonaws.greengrass.streammanager.model.sitewise package. List entries = new ArrayList<>() ; // IoTSiteWise requires unique timestamps in all messages. Add some randomness to time and offset. final int maxTimeRandomness = 60; final int maxOffsetRandomness = 10000; double randomValue = rand.nextDouble(); TimeInNanos timestamp = new TimeInNanos() .withTimeInSeconds(Instant.now().getEpochSecond() - rand.nextInt(maxTimeRandomness)) .withOffsetInNanos((long) (rand.nextInt(maxOffsetRandomness))); AssetPropertyValue entry = new AssetPropertyValue() .withValue(new Variant().withDoubleValue(randomValue)) .withQuality(Quality.GOOD) .withTimestamp(timestamp); entries.add(entry); PutAssetPropertyValueEntry putAssetPropertyValueEntry = new PutAssetPropertyValueEntry() .withEntryId(UUID.randomUUID().toString()) .withPropertyAlias("PropertyAlias") .withPropertyValues(entries); long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry)); } catch (StreamManagerException e) { // Properly handle exception. } ``` Riferimento Java SDK: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const maxTimeRandomness = 60; const maxOffsetRandomness = 10000; const randomValue = Math.random(); // Note: To create a new asset property data, you should use the classes defined in the // aws-greengrass-core-sdk StreamManager module. const timestamp = new TimeInNanos() .withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness)) .withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness)); const entry = new AssetPropertyValue() .withValue(new Variant().withDoubleValue(randomValue)) .withQuality(Quality.GOOD) .withTimestamp(timestamp); const putAssetPropertyValueEntry = new PutAssetPropertyValueEntry() .withEntryId(`${ENTRY_ID_PREFIX}${i}`) .withPropertyAlias("PropertyAlias") .withPropertyValues([entry]); const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry)); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) ------ #### Destinazioni di esportazione Amazon S3 Il seguente frammento aggiunge un'attività di esportazione allo stream denominato. `StreamName` Per le destinazioni Amazon S3, le funzioni Lambda aggiungono un oggetto serializzato che contiene informazioni sul file di input di origine e sull'`S3ExportTaskDefinition`oggetto Amazon S3 di destinazione. Se l'oggetto specificato non esiste, Stream Manager lo crea per te. Per ulteriori informazioni, consulta [Esportazione su Amazon S3](stream-export-configurations.md#export-streams-to-s3). Questo frammento ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.11.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0 ------ #### [ Python ] ``` client = StreamManagerClient() try: # Append an Amazon S3 Task definition and print the sequence number. s3_export_task_definition = S3ExportTaskDefinition(input_url="URLToFile", bucket="BucketName", key="KeyName") sequence_number = client.append_message(stream_name="StreamName", data=Util.validate_and_serialize_to_json_bytes(s3_export_task_definition)) except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.append_message) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { // Append an Amazon S3 export task definition and print the sequence number. S3ExportTaskDefinition s3ExportTaskDefinition = new S3ExportTaskDefinition() .withBucket("BucketName") .withKey("KeyName") .withInputUrl("URLToFile"); long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(s3ExportTaskDefinition)); } catch (StreamManagerException e) { // Properly handle exception. } ``` [Riferimento a Java SDK: [appendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/S3ExportTaskDefinition.html) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { // Append an Amazon S3 export task definition and print the sequence number. const taskDefinition = new S3ExportTaskDefinition() .withBucket("BucketName") .withKey("KeyName") .withInputUrl("URLToFile"); const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(taskDefinition))); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` [Riferimento all'SDK Node.js: [appendMessage \$1](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) S3 ExportTaskDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskDefinition.html) ------   ## Lettura di messaggi Leggi i messaggi da uno stream. ### Requisiti Questa operazione ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 ### Esempi Il frammento di codice seguente legge i messaggi dal flusso denominato `StreamName`. Il metodo di lettura accetta un oggetto `ReadMessagesOptions` facoltativo che specifica il numero di sequenza da cui iniziare la lettura, i numeri minimo e massimo da leggere e un timeout per la lettura dei messaggi. ------ #### [ Python ] ``` client = StreamManagerClient() try: message_list = client.read_messages( stream_name="StreamName", # By default, if no options are specified, it tries to read one message from the beginning of the stream. options=ReadMessagesOptions( desired_start_sequence_number=100, # Try to read from sequence number 100 or greater. By default, this is 0. min_message_count=10, # Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1. max_message_count=100, # Accept up to 100 messages. By default this is 1. read_timeout_millis=5000 # Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception. ) ) except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: read\$1messages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.ReadMessagesOptions)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { List messages = client.readMessages("StreamName", // By default, if no options are specified, it tries to read one message from the beginning of the stream. new ReadMessagesOptions() // Try to read from sequence number 100 or greater. By default this is 0. .withDesiredStartSequenceNumber(100L) // Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1. .withMinMessageCount(10L) // Accept up to 100 messages. By default this is 1. .withMaxMessageCount(100L) // Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception. .withReadTimeoutMillis(Duration.ofSeconds(5L).toMillis()) ); } catch (StreamManagerException e) { // Properly handle exception. } ``` Riferimento a Java SDK: [ReadMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const messages = await client.readMessages("StreamName", // By default, if no options are specified, it tries to read one message from the beginning of the stream. new ReadMessagesOptions() // Try to read from sequence number 100 or greater. By default this is 0. .withDesiredStartSequenceNumber(100) // Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is thrown. By default, this is 1. .withMinMessageCount(10) // Accept up to 100 messages. By default this is 1. .withMaxMessageCount(100) // Try to wait at most 5 seconds for the minMessageCount to be fulfilled. By default, this is 0, which immediately returns the messages or an exception. .withReadTimeoutMillis(5 * 1000) ); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: [ReadMessages \$1 [ReadMessagesOptions](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages) ------   ## Visualizzazione dell'elenco di flussi Ottieni l'elenco degli stream nello stream manager. ### Requisiti Questa operazione ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 ### Esempi Il frammento di codice seguente ottiene un elenco dei flussi (per nome) in stream manager. ------ #### [ Python ] ``` client = StreamManagerClient() try: stream_names = client.list_streams() except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: list\$1streams](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.list_streams) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { List streamNames = client.listStreams(); } catch (StreamManagerException e) { // Properly handle exception. } ``` [Riferimento Java SDK: ListStreams](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#listStreams--) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const streams = await client.listStreams(); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` [Riferimento all'SDK Node.js: ListStreams](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams) ------   ## Descrizione del flusso di messaggi Ottieni i metadati relativi a uno stream, tra cui la definizione, la dimensione e lo stato dell'esportazione. ### Requisiti Questa operazione ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 ### Esempi Il frammento di codice seguente ottiene i metadati relativi al flusso denominato `StreamName`, inclusi la definizione, le dimensioni e gli stati di esportatore del flusso. ------ #### [ Python ] ``` client = StreamManagerClient() try: stream_description = client.describe_message_stream(stream_name="StreamName") if stream_description.export_statuses[0].error_message: # The last export of export destination 0 failed with some error # Here is the last sequence number that was successfully exported stream_description.export_statuses[0].last_exported_sequence_number if (stream_description.storage_status.newest_sequence_number > stream_description.export_statuses[0].last_exported_sequence_number): pass # The end of the stream is ahead of the last exported sequence number except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: describe\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { MessageStreamInfo description = client.describeMessageStream("StreamName"); String lastErrorMessage = description.getExportStatuses().get(0).getErrorMessage(); if (lastErrorMessage != null && !lastErrorMessage.equals("")) { // The last export of export destination 0 failed with some error. // Here is the last sequence number that was successfully exported. description.getExportStatuses().get(0).getLastExportedSequenceNumber(); } if (description.getStorageStatus().getNewestSequenceNumber() > description.getExportStatuses().get(0).getLastExportedSequenceNumber()) { // The end of the stream is ahead of the last exported sequence number. } } catch (StreamManagerException e) { // Properly handle exception. } ``` Riferimento a Java SDK: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#describeMessageStream-java.lang.String-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const description = await client.describeMessageStream("StreamName"); const lastErrorMessage = description.exportStatuses[0].errorMessage; if (lastErrorMessage) { // The last export of export destination 0 failed with some error. // Here is the last sequence number that was successfully exported. description.exportStatuses[0].lastExportedSequenceNumber; } if (description.storageStatus.newestSequenceNumber > description.exportStatuses[0].lastExportedSequenceNumber) { // The end of the stream is ahead of the last exported sequence number. } } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream) ------   ## Aggiorna il flusso di messaggi Aggiorna le proprietà di uno stream esistente. Potresti voler aggiornare uno stream se i tuoi requisiti cambiano dopo la creazione dello stream. Esempio: + Aggiungi una nuova [configurazione di esportazione](stream-export-configurations.md) per una Cloud AWS destinazione. + Aumenta la dimensione massima di uno stream per modificare il modo in cui i dati vengono esportati o conservati. Ad esempio, la dimensione dello stream in combinazione con la tua strategia sulle impostazioni complete potrebbe comportare l'eliminazione o il rifiuto dei dati prima che lo stream manager possa elaborarli. + Metti in pausa e riprendi le esportazioni, ad esempio se le attività di esportazione richiedono molto tempo e desideri razionare i dati di caricamento. Le tue funzioni Lambda seguono questo processo di alto livello per aggiornare uno stream: 1. [Ottieni la descrizione dello stream.](#streammanagerclient-describe-message-stream) 1. Aggiorna le proprietà di destinazione sugli oggetti corrispondenti `MessageStreamDefinition` e subordinati. 1. Passa l'aggiornamento`MessageStreamDefinition`. Assicurati di includere le definizioni complete degli oggetti per lo stream aggiornato. Le proprietà non definite tornano ai valori predefiniti. È possibile specificare il numero di sequenza del messaggio da utilizzare come messaggio iniziale nell'esportazione. ### Requisiti Questa operazione presenta i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.11.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0 ### Esempi Il seguente frammento aggiorna lo stream denominato. `StreamName` Aggiorna più proprietà di un flusso che esporta in Kinesis Data Streams. ------ #### [ Python ] ``` client = StreamManagerClient() try: message_stream_info = client.describe_message_stream(STREAM_NAME) message_stream_info.definition.max_size=536870912 message_stream_info.definition.stream_segment_size=33554432 message_stream_info.definition.time_to_live_millis=3600000 message_stream_info.definition.strategy_on_full=StrategyOnFull.RejectNewData message_stream_info.definition.persistence=Persistence.Memory message_stream_info.definition.flush_on_write=False message_stream_info.definition.export_definition.kinesis= [KinesisConfig( # Updating Export definition to add a Kinesis Stream configuration. identifier=str(uuid.uuid4()), kinesis_stream_name=str(uuid.uuid4()))] client.update_message_stream(message_stream_info.definition) except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` Riferimento a Python SDK: \$1 [updateMessageStream[MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.update_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { MessageStreamInfo messageStreamInfo = client.describeMessageStream(STREAM_NAME); // Update the message stream with new values. client.updateMessageStream( messageStreamInfo.getDefinition() .withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data. // Max Size update should be greater than initial Max Size defined in Create Message Stream request .withMaxSize(536870912L) // Update Max Size to 512 MB. .withStreamSegmentSize(33554432L) // Update Segment Size to 32 MB. .withFlushOnWrite(true) // Update flush on write to true. .withPersistence(Persistence.Memory) // Update the persistence to Memory. .withTimeToLiveMillis(3600000L) // Update TTL to 1 hour. .withExportDefinition( // Optional. Choose where/how the stream is exported to the Cloud AWS. messageStreamInfo.getDefinition().getExportDefinition(). // Updating Export definition to add a Kinesis Stream configuration. .withKinesis(new ArrayList() {{ add(new KinesisConfig() .withIdentifier(EXPORT_IDENTIFIER) .withKinesisStreamName("test")); }}) ); } catch (StreamManagerException e) { // Properly handle exception. } ``` [Riferimento a Java SDK: update\$1message\$1stream \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { const messageStreamInfo = await c.describeMessageStream(STREAM_NAME); await client.updateMessageStream( messageStreamInfo.definition // Max Size update should be greater than initial Max Size defined in Create Message Stream request .withMaxSize(536870912) // Default is 256 MB. Updating Max Size to 512 MB. .withStreamSegmentSize(33554432) // Default is 16 MB. Updating Segment Size to 32 MB. .withTimeToLiveMillis(3600000) // By default, no TTL is enabled. Update TTL to 1 hour. .withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data. .withPersistence(Persistence.Memory) // Default is File. Update the persistence to Memory .withFlushOnWrite(true) // Default is false. Updating to true. .withExportDefinition( // Optional. Choose where/how the stream is exported to the Cloud AWS. messageStreamInfo.definition.exportDefinition // Updating Export definition to add a Kinesis Stream configuration. .withKinesis([new KinesisConfig().withIdentifier(uuidv4()).withKinesisStreamName(uuidv4())]) ) ); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'[updateMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#updateMessageStream)SDK Node.js: \$1 [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html) ------ ### Vincoli per l'aggiornamento degli stream I seguenti vincoli si applicano all'aggiornamento dei flussi. A meno che non sia indicato nell'elenco seguente, gli aggiornamenti hanno effetto immediato. + Non puoi aggiornare la persistenza di uno stream. Per modificare questo comportamento, [elimina lo stream](#streammanagerclient-delete-message-stream) e [crea uno stream](#streammanagerclient-create-message-stream) che definisca la nuova politica di persistenza. + Puoi aggiornare la dimensione massima di uno stream solo nelle seguenti condizioni: + La dimensione massima deve essere maggiore o uguale alla dimensione corrente dello stream. Per trovare queste informazioni, [descrivi lo stream](#streammanagerclient-describe-message-stream) e poi controlla lo stato di archiviazione dell'`MessageStreamInfo`oggetto restituito. + La dimensione massima deve essere maggiore o uguale alla dimensione del segmento dello stream. + Puoi aggiornare la dimensione del segmento di stream a un valore inferiore alla dimensione massima dello stream. L'impostazione aggiornata si applica ai nuovi segmenti. + Gli aggiornamenti alla proprietà time to live (TTL) si applicano alle nuove operazioni di aggiunta. Se riduci questo valore, stream manager potrebbe anche eliminare i segmenti esistenti che superano il TTL. + Gli aggiornamenti alla strategia sulla proprietà completa si applicano alle nuove operazioni di aggiunta. Se imposti la strategia per sovrascrivere i dati più vecchi, stream manager potrebbe anche sovrascrivere i segmenti esistenti in base alla nuova impostazione. + Gli aggiornamenti alla proprietà flush on write si applicano ai nuovi messaggi. + Gli aggiornamenti alle configurazioni di esportazione si applicano alle nuove esportazioni. La richiesta di aggiornamento deve includere tutte le configurazioni di esportazione che si desidera supportare. Altrimenti, stream manager le elimina. + Quando aggiorni una configurazione di esportazione, specifica l'identificatore della configurazione di esportazione di destinazione. + Per aggiungere una configurazione di esportazione, specificate un identificatore univoco per la nuova configurazione di esportazione. + Per eliminare una configurazione di esportazione, omettete la configurazione di esportazione. + Per [aggiornare](#streammanagerclient-update-message-stream) il numero di sequenza iniziale di una configurazione di esportazione in uno stream, è necessario specificare un valore inferiore al numero di sequenza più recente. Per trovare queste informazioni, [descrivi lo stream](#streammanagerclient-describe-message-stream) e quindi controlla lo stato di archiviazione dell'`MessageStreamInfo`oggetto restituito.   ## Eliminazione del flusso di messaggi Elimina un flusso. Quando si elimina un flusso, tutti i dati memorizzati per il flusso vengono eliminati dal disco. ### Requisiti Questa operazione ha i seguenti requisiti: + Versione minima AWS IoT Greengrass Core: 1.10.0 + Versione minima AWS IoT Greengrass Core SDK: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0 ### Esempi Il frammento di codice seguente elimina il flusso denominato `StreamName`. ------ #### [ Python ] ``` client = StreamManagerClient() try: client.delete_message_stream(stream_name="StreamName") except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` Riferimento all'SDK Python: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream) ------ #### [ Java ] ``` try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { client.deleteMessageStream("StreamName"); } catch (StreamManagerException e) { // Properly handle exception. } ``` [Riferimento Java SDK: delete\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#deleteMessageStream-java.lang.String-) ------ #### [ Node.js ] ``` const client = new StreamManagerClient(); client.onConnected(async () => { try { await client.deleteMessageStream("StreamName"); } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream) ------ ## 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) + [Esporta le configurazioni per le destinazioni supportate Cloud AWS](stream-export-configurations.md) + [Esportazione di flussi di dati su Cloud AWS (console)](stream-manager-console.md) + [Esportazione di flussi di dati su Cloud AWS (CLI)](stream-manager-cli.md) + `StreamManagerClient`nel riferimento AWS IoT Greengrass Core SDK: + [Python](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html) + [Java](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html) + [Node.js](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html) # Esporta le configurazioni per le destinazioni supportate Cloud AWS Le funzioni Lambda definite dall'utente vengono `StreamManagerClient` utilizzate AWS IoT Greengrass nell'SDK Core per interagire con lo stream manager. Quando una funzione Lambda [crea uno stream](work-with-streams.md#streammanagerclient-create-message-stream) o [aggiorna uno stream, passa un](work-with-streams.md#streammanagerclient-create-message-stream) `MessageStreamDefinition` oggetto che rappresenta le proprietà dello stream, inclusa la definizione di esportazione. L'`ExportDefinition`oggetto contiene le configurazioni di esportazione definite per lo stream. Stream Manager utilizza queste configurazioni di esportazione per determinare dove e come esportare lo stream. ![\[Diagramma del modello a oggetti del tipo di ExportDefinition proprietà.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/stream-manager-exportconfigs.png) È possibile definire zero o più configurazioni di esportazione su uno stream, incluse più configurazioni di esportazione per un singolo tipo di destinazione. Ad esempio, puoi esportare uno stream su due AWS IoT Analytics canali e un flusso di dati Kinesis. In caso di tentativi di esportazione falliti, stream manager riprova continuamente a esportare i dati verso il a Cloud AWS intervalli fino a cinque minuti. Il numero di tentativi di nuovo tentativo non ha un limite massimo. **Nota** `StreamManagerClient`fornisce anche una destinazione di destinazione che è possibile utilizzare per esportare i flussi su un server HTTP. Questo target è destinato esclusivamente a scopi di test. Non è stabile né è supportato per l'uso in ambienti di produzione. **Topics** + [AWS IoT Analytics canali](#export-to-iot-analytics) + [Flussi di dati Amazon Kinesis](#export-to-kinesis) + [AWS IoT SiteWise proprietà degli asset](#export-to-iot-sitewise) + [Oggetti Amazon S3](#export-to-s3) Sei responsabile del mantenimento di queste Cloud AWS risorse. ## AWS IoT Analytics canali Stream manager supporta le esportazioni automatiche verso AWS IoT Analytics. AWS IoT Analytics consente di eseguire analisi avanzate sui dati per aiutare a prendere decisioni aziendali e migliorare i modelli di apprendimento automatico. Per ulteriori informazioni, consulta [Cos'è AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) nella *Guida AWS IoT Analytics per l'utente*. Nel AWS IoT Greengrass Core SDK, le funzioni Lambda utilizzano per definire `IoTAnalyticsConfig` la configurazione di esportazione per questo tipo di destinazione. Per ulteriori informazioni, consulta il riferimento SDK per la lingua di destinazione: + [Io TAnalytics Config nell'SDK](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTAnalyticsConfig) Python + [Io TAnalytics Config nell'SDK](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) Java + [Io TAnalytics Config nell'SDK](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) Node.js ### Requisiti Questa destinazione di esportazione presenta i seguenti requisiti: + I canali di destinazione in ingresso AWS IoT Analytics devono appartenere allo Regione AWS stesso Account AWS gruppo Greengrass. + [Ruolo del gruppo Greengrass](group-role.md)Devono consentire l'`iotanalytics:BatchPutMessage`autorizzazione per i canali di destinazione. Esempio: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iotanalytics:BatchPutMessage" ], "Resource": [ "arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name", "arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name" ] } ] } ``` ------ È possibile concedere un accesso granulare o condizionale alle risorse, ad esempio utilizzando uno schema di denominazione con caratteri jolly`*`. *Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM nella IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) Guide.* ### Esportazione in AWS IoT Analytics Per creare un flusso in cui esportare AWS IoT Analytics, le funzioni Lambda [creano un flusso](work-with-streams.md#streammanagerclient-create-message-stream) con una definizione di esportazione che include uno o più `IoTAnalyticsConfig` oggetti. Questo oggetto definisce le impostazioni di esportazione, come il canale di destinazione, la dimensione del batch, l'intervallo del batch e la priorità. Quando le funzioni Lambda ricevono dati dai dispositivi, [aggiungono messaggi](work-with-streams.md#streammanagerclient-append-message) che contengono un blob di dati al flusso di destinazione. Quindi, stream manager esporta i dati in base alle impostazioni del batch e alla priorità definite nelle configurazioni di esportazione dello stream.   ## Flussi di dati Amazon Kinesis Stream Manager supporta le esportazioni automatiche verso Amazon Kinesis Data Streams. Kinesis Data Streams viene comunemente utilizzato per aggregare dati di grandi volumi e caricarli in un data warehouse o in un cluster di riduzione delle mappe. Per ulteriori informazioni, consulta [Cos'è Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html)? nella *Amazon Kinesis Developer Guide*. Nel AWS IoT Greengrass Core SDK, le funzioni Lambda utilizzano per definire `KinesisConfig` la configurazione di esportazione per questo tipo di destinazione. Per ulteriori informazioni, consulta il riferimento SDK per la lingua di destinazione: + [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.KinesisConfig)nell'SDK Python + [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)nell'SDK Java + [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)nell'SDK Node.js ### Requisiti Questa destinazione di esportazione presenta i seguenti requisiti: + I flussi di destinazione in Kinesis Data Streams devono appartenere allo Regione AWS stesso gruppo Account AWS Greengrass. + [Ruolo del gruppo Greengrass](group-role.md)Devono consentire l'`kinesis:PutRecords`autorizzazione per indirizzare i flussi di dati. Esempio: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kinesis:PutRecords" ], "Resource": [ "arn:aws:kinesis:us-east-1:123456789012:stream/stream_1_name", "arn:aws:kinesis:us-east-1:123456789012:stream/stream_2_name" ] } ] } ``` ------ È possibile concedere un accesso granulare o condizionale alle risorse, ad esempio utilizzando uno schema di denominazione con caratteri jolly`*`. *Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM nella IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) Guide.* ### Esportazione in Kinesis Data Streams Per creare un flusso che esporta in Kinesis Data Streams, le [funzioni Lambda creano](work-with-streams.md#streammanagerclient-create-message-stream) un flusso con una definizione di esportazione che include uno o più oggetti. `KinesisConfig` Questo oggetto definisce le impostazioni di esportazione, come il flusso di dati di destinazione, la dimensione del batch, l'intervallo del batch e la priorità. Quando le funzioni Lambda ricevono dati dai dispositivi, [aggiungono messaggi](work-with-streams.md#streammanagerclient-append-message) che contengono un blob di dati al flusso di destinazione. Quindi, stream manager esporta i dati in base alle impostazioni del batch e alla priorità definite nelle configurazioni di esportazione dello stream. Stream Manager genera un UUID univoco e casuale come chiave di partizione per ogni record caricato su Amazon Kinesis.   ## AWS IoT SiteWise proprietà degli asset Stream manager supporta le esportazioni automatiche verso AWS IoT SiteWise. AWS IoT SiteWise consente di raccogliere, organizzare e analizzare dati provenienti da apparecchiature industriali su larga scala. Per ulteriori informazioni, consulta [Cos'è AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) nella *Guida AWS IoT SiteWise per l'utente*. Nel AWS IoT Greengrass Core SDK, le funzioni Lambda utilizzano per definire `IoTSiteWiseConfig` la configurazione di esportazione per questo tipo di destinazione. Per ulteriori informazioni, consulta il riferimento SDK per la lingua di destinazione: + [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTSiteWiseConfig) nell'SDK Python + [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) nell'SDK Java + [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) nell'SDK Node.js **Nota** AWS fornisce anche la[SiteWise Connettore IoT](iot-sitewise-connector.md), che è una soluzione preconfigurata che è possibile utilizzare con i sorgenti OPC-UA. ### Requisiti Questa destinazione di esportazione presenta i seguenti requisiti: + Le proprietà degli asset di destinazione AWS IoT SiteWise devono appartenere al gruppo Greengrass Account AWS e a Regione AWS quelle del gruppo Greengrass. **Nota** *Per l'elenco delle regioni che lo AWS IoT SiteWise supportano, consulta gli [AWS IoT SiteWise endpoint e le quote nel AWS Riferimento](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region) generale.* + [Ruolo del gruppo Greengrass](group-role.md)Devono consentire l'`iotsitewise:BatchPutAssetPropertyValue`autorizzazione per indirizzare le proprietà degli asset. La seguente politica di esempio utilizza la chiave `iotsitewise:assetHierarchyPath` condition per concedere l'accesso a una risorsa principale di destinazione e ai suoi figli. Puoi rimuoverla `Condition` dalla policy per consentire l'accesso a tutte le tue AWS IoT SiteWise risorse o specificare ARNs singole risorse. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "iotsitewise:BatchPutAssetPropertyValue", "Resource": "*", "Condition": { "StringLike": { "iotsitewise:assetHierarchyPath": [ "/root node asset ID", "/root node asset ID/*" ] } } } ] } ``` ------ Puoi concedere un accesso granulare o condizionale alle risorse, ad esempio utilizzando uno schema di denominazione con caratteri jolly`*`. *Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM nella IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) Guide.* Per importanti informazioni sulla sicurezza, consulta [ BatchPutAssetPropertyValue l'autorizzazione](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-batchputassetpropertyvalue-action) nella *Guida AWS IoT SiteWise per l'utente*. ### Esportazione in AWS IoT SiteWise Per creare un flusso in cui esportare AWS IoT SiteWise, le funzioni Lambda [creano un flusso](work-with-streams.md#streammanagerclient-create-message-stream) con una definizione di esportazione che include uno o più `IoTSiteWiseConfig` oggetti. Questo oggetto definisce le impostazioni di esportazione, come la dimensione del batch, l'intervallo del batch e la priorità. Quando le funzioni Lambda ricevono dati sulle proprietà degli asset dai dispositivi, aggiungono messaggi che contengono i dati allo stream di destinazione. I messaggi sono `PutAssetPropertyValueEntry` oggetti serializzati in JSON che contengono valori di proprietà per una o più proprietà delle risorse. Per ulteriori informazioni, consulta [Aggiungi](work-with-streams.md#streammanagerclient-append-message-sitewise) messaggio per le destinazioni di esportazione. AWS IoT SiteWise **Nota** Quando invii dati a AWS IoT SiteWise, i tuoi dati devono soddisfare i requisiti dell'`BatchPutAssetPropertyValue`azione. Per ulteriori informazioni, consulta [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) nella *documentazione di riferimento dell’API AWS IoT SiteWise *. Quindi, stream manager esporta i dati in base alle impostazioni del batch e alla priorità definite nelle configurazioni di esportazione dello stream.   Puoi modificare le impostazioni dello stream manager e la logica della funzione Lambda per progettare la tua strategia di esportazione. Esempio: + Per esportazioni quasi in tempo reale, imposta impostazioni di intervallo e dimensioni dei batch ridotte e aggiungi i dati allo stream quando vengono ricevuti. + Per ottimizzare il batching, mitigare i vincoli di larghezza di banda o ridurre al minimo i costi, le funzioni Lambda possono raggruppare i punti dati timestamp-quality-value (TQV) ricevuti per una singola proprietà dell'asset prima di aggiungere i dati allo stream. Una strategia consiste nell'inserire in un unico messaggio le voci relative a un massimo di 10 diverse combinazioni proprietà-asset, o alias di proprietà, anziché inviare più di una voce per la stessa proprietà. [Questo aiuta lo stream manager a rimanere entro le quote.AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html)   ## Oggetti Amazon S3 Stream Manager supporta le esportazioni automatiche verso Amazon S3. Puoi usare Amazon S3 per archiviare e recuperare grandi quantità di dati. Per ulteriori informazioni, consulta [Cos'è Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html)? nella *Guida per sviluppatori di Amazon Simple Storage Service*. Nel AWS IoT Greengrass Core SDK, le funzioni Lambda utilizzano per definire `S3ExportTaskExecutorConfig` la configurazione di esportazione per questo tipo di destinazione. Per ulteriori informazioni, consulta il riferimento SDK per la lingua di destinazione: + [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskExecutorConfig) nell'SDK Python + [S3 nell'SDK Java ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) + [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) nell'SDK Node.js ### Requisiti Questa destinazione di esportazione presenta i seguenti requisiti: + I bucket Amazon S3 di Target devono appartenere allo stesso gruppo Account AWS Greengrass. + Se la [containerizzazione predefinita](lambda-group-config.md#lambda-containerization-groupsettings) per il gruppo Greengrass è il **contenitore** Greengrass, è necessario impostare il parametro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS per utilizzare una directory di file](configure-stream-manager.md#stream-manager-read-only-directories) di input che si trova o non si trova nel file system root. `/tmp` + Se una funzione Lambda in esecuzione in modalità **contenitore Greengrass** scrive i file di input nella directory dei file di input, è necessario creare una risorsa di volume locale per la directory e montare la directory nel contenitore con autorizzazioni di scrittura. Ciò garantisce che i file vengano scritti nel file system root e siano visibili all'esterno del contenitore. Per ulteriori informazioni, consulta [Accedi alle risorse locali con funzioni e connettori Lambda](access-local-resources.md). + [Ruolo del gruppo Greengrass](group-role.md)Deve consentire le seguenti autorizzazioni per i bucket di destinazione. Esempio: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:PutObject", "s3:AbortMultipartUpload", "s3:ListMultipartUploadParts" ], "Resource": [ "arn:aws:s3:::bucket-1-name/*", "arn:aws:s3:::bucket-2-name/*" ] } ] } ``` ------ È possibile concedere un accesso granulare o condizionale alle risorse, ad esempio utilizzando uno schema di denominazione con caratteri jolly. `*` *Per ulteriori informazioni, consulta [Aggiungere e rimuovere le policy IAM nella IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) Guide.* ### Esportazione su Amazon S3 Per creare uno stream che esporta in Amazon S3, le funzioni Lambda utilizzano l'`S3ExportTaskExecutorConfig`oggetto per configurare la politica di esportazione. La policy definisce le impostazioni di esportazione, come la soglia e la priorità di caricamento multiparte. Per le esportazioni di Amazon S3, stream manager carica i dati che legge dai file locali sul dispositivo principale. Per avviare un caricamento, le funzioni Lambda aggiungono un'attività di esportazione allo stream di destinazione. L'attività di esportazione contiene informazioni sul file di input e sull'oggetto Amazon S3 di destinazione. Stream manager esegue le attività nella sequenza in cui vengono aggiunte allo stream. **Nota** Il bucket di destinazione deve già esistere nel tuo. Account AWS Se non esiste un oggetto per la chiave specificata, lo stream manager crea l'oggetto per te. Questo flusso di lavoro di alto livello è illustrato nel diagramma seguente. ![\[Diagramma del flusso di lavoro dello stream manager per le esportazioni di Amazon S3.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/stream-manager-s3.png) Stream Manager utilizza la proprietà della soglia di caricamento [multiparte, l'impostazione della dimensione minima](configure-stream-manager.md#stream-manager-minimum-part-size) della parte e la dimensione del file di input per determinare come caricare i dati. La soglia di caricamento in più parti deve essere maggiore o uguale alla dimensione minima della parte. Se desideri caricare dati in parallelo, puoi creare più stream. Le chiavi che specificano gli oggetti Amazon S3 di destinazione possono includere DateTimeFormatter stringhe [Java](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) valide nei segnaposto. `!{timestamp:value}` Puoi utilizzare questi segnaposto con timestamp per partizionare i dati in Amazon S3 in base all'ora in cui i dati del file di input sono stati caricati. Ad esempio, il seguente nome di chiave si risolve in un valore come. `my-key/2020/12/31/data.txt` ``` my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt ``` **Nota** Se desideri monitorare lo stato dell'esportazione di uno stream, crea prima uno stream di stato e poi configura il flusso di esportazione per utilizzarlo. Per ulteriori informazioni, consulta [Monitora le attività di esportazione](#monitor-export-status-s3). #### Gestisci i dati di input Puoi creare codice utilizzato dalle applicazioni IoT per gestire il ciclo di vita dei dati di input. Il seguente flusso di lavoro di esempio mostra come utilizzare le funzioni Lambda per gestire questi dati. 1. Un processo locale riceve dati da dispositivi o periferiche e quindi li scrive su file in una directory sul dispositivo principale. Questi sono i file di input per lo stream manager. **Nota** Per determinare se è necessario configurare l'accesso alla directory dei file di input, vedete il parametro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories). [Il processo in cui viene eseguito lo stream manager eredita tutte le autorizzazioni del file system dell'identità di accesso predefinita per il gruppo.](lambda-group-config.md#lambda-access-identity-groupsettings) Lo stream manager deve disporre dell'autorizzazione per accedere ai file di input. È possibile utilizzare il `chmod(1)` comando per modificare l'autorizzazione dei file, se necessario. 1. Una funzione Lambda analizza la directory e [aggiunge un'attività di esportazione](work-with-streams.md#streammanagerclient-append-message-export-task) al flusso di destinazione quando viene creato un nuovo file. L'attività è un `S3ExportTaskDefinition` oggetto serializzato in JSON che specifica l'URL del file di input, il bucket e la chiave Amazon S3 di destinazione e i metadati utente opzionali. 1. Stream Manager legge il file di input ed esporta i dati in Amazon S3 nell'ordine delle attività aggiunte. Il bucket di destinazione deve già esistere nel tuo. Account AWS Se non esiste un oggetto per la chiave specificata, lo stream manager crea l'oggetto per te. 1. La funzione Lambda [legge i messaggi](work-with-streams.md#streammanagerclient-read-messages) da un flusso di stato per monitorare lo stato dell'esportazione. Una volta completate le attività di esportazione, la funzione Lambda può eliminare i file di input corrispondenti. Per ulteriori informazioni, consulta [Monitora le attività di esportazione](#monitor-export-status-s3). ### Monitora le attività di esportazione Puoi creare codice utilizzato dalle applicazioni IoT per monitorare lo stato delle esportazioni Amazon S3. Le funzioni Lambda devono creare un flusso di stato e quindi configurare il flusso di esportazione per scrivere aggiornamenti di stato nel flusso di stato. Un singolo flusso di stato può ricevere aggiornamenti di stato da più flussi esportati in Amazon S3. Innanzitutto, [crea uno stream](work-with-streams.md#streammanagerclient-create-message-stream) da utilizzare come flusso di stato. Puoi configurare le dimensioni e le politiche di conservazione dello stream per controllare la durata dei messaggi di stato. Esempio: + `Persistence`Imposta su `Memory` se non desideri archiviare i messaggi di stato. + Impostato `StrategyOnFull` in `OverwriteOldestData` modo che i nuovi messaggi di stato non vadano persi. Quindi, crea o aggiorna il flusso di esportazione per utilizzare il flusso di stato. In particolare, imposta la proprietà di configurazione dello stato della configurazione di `S3ExportTaskExecutorConfig` esportazione dello stream. Questo dice al gestore dello stream di scrivere messaggi di stato sulle attività di esportazione nello stream di stato. Nell'`StatusConfig`oggetto, specifica il nome del flusso di stato e il livello di verbosità. I seguenti valori supportati vanno da least verbose (`ERROR`) a most verbose (). `TRACE` Il valore predefinito è `INFO`. + `ERROR` + `WARN` + `INFO` + `DEBUG` + `TRACE`   Il seguente flusso di lavoro di esempio mostra come le funzioni Lambda potrebbero utilizzare un flusso di stato per monitorare lo stato delle esportazioni. 1. Come descritto nel flusso di lavoro precedente, una funzione Lambda [aggiunge un'attività di esportazione](work-with-streams.md#streammanagerclient-append-message-export-task) a uno stream configurato per scrivere messaggi di stato sulle attività di esportazione in un flusso di stato. L'operazione di aggiunta restituisce un numero di sequenza che rappresenta l'ID dell'attività. 1. Una funzione Lambda [legge i messaggi](work-with-streams.md#streammanagerclient-read-messages) in sequenza dallo stream di stato, quindi filtra i messaggi in base al nome del flusso e all'ID dell'attività o in base a una proprietà dell'attività di esportazione dal contesto del messaggio. Ad esempio, la funzione Lambda può filtrare in base all'URL del file di input dell'attività di esportazione, che è rappresentato dall'`S3ExportTaskDefinition`oggetto nel contesto del messaggio. I seguenti codici di stato indicano che un'attività di esportazione ha raggiunto lo stato di completamento: + `Success`. Il caricamento è stato completato con successo. + `Failure`. Lo stream manager ha riscontrato un errore, ad esempio, il bucket specificato non esiste. Dopo aver risolto il problema, puoi aggiungere nuovamente l'attività di esportazione allo stream. + `Canceled`. L'attività è stata interrotta perché la definizione dello stream o dell'esportazione è stata eliminata o il periodo time-to-live (TTL) dell'attività è scaduto. **Nota** L'attività potrebbe anche avere lo stato o. `InProgress` `Warning` Stream manager emette avvisi quando un evento restituisce un errore che non influisce sull'esecuzione dell'attività. Ad esempio, la mancata pulizia di un caricamento parziale interrotto restituisce un avviso. 1. Una volta completate le attività di esportazione, la funzione Lambda può eliminare i file di input corrispondenti. L'esempio seguente mostra come una funzione Lambda potrebbe leggere ed elaborare i messaggi di stato. ------ #### [ Python ] ``` import time from greengrasssdk.stream_manager import ( ReadMessagesOptions, Status, StatusConfig, StatusLevel, StatusMessage, StreamManagerClient, ) from greengrasssdk.stream_manager.util import Util client = StreamManagerClient() try: # Read the statuses from the export status stream is_file_uploaded_to_s3 = False while not is_file_uploaded_to_s3: try: messages_list = client.read_messages( "StatusStreamName", ReadMessagesOptions(min_message_count=1, read_timeout_millis=1000) ) for message in messages_list: # Deserialize the status message first. status_message = Util.deserialize_json_bytes_to_obj(message.payload, StatusMessage) # Check the status of the status message. If the status is "Success", # the file was successfully uploaded to S3. # If the status was either "Failure" or "Cancelled", the server was unable to upload the file to S3. # We will print the message for why the upload to S3 failed from the status message. # If the status was "InProgress", the status indicates that the server has started uploading # the S3 task. if status_message.status == Status.Success: logger.info("Successfully uploaded file at path " + file_url + " to S3.") is_file_uploaded_to_s3 = True elif status_message.status == Status.Failure or status_message.status == Status.Canceled: logger.info( "Unable to upload file at path " + file_url + " to S3. Message: " + status_message.message ) is_file_uploaded_to_s3 = True time.sleep(5) except StreamManagerException: logger.exception("Exception while running") except StreamManagerException: pass # Properly handle errors. except ConnectionError or asyncio.TimeoutError: pass # Properly handle errors. ``` [Riferimento all'SDK Python: read\$1messages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.StatusMessage)](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.streammanagerclient.html#greengrasssdk.stream_manager.streammanagerclient.StreamManagerClient.read_messages) ------ #### [ Java ] ``` import com.amazonaws.greengrass.streammanager.client.StreamManagerClient; import com.amazonaws.greengrass.streammanager.client.utils.ValidateAndSerialize; import com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions; import com.amazonaws.greengrass.streammanager.model.Status; import com.amazonaws.greengrass.streammanager.model.StatusConfig; import com.amazonaws.greengrass.streammanager.model.StatusLevel; import com.amazonaws.greengrass.streammanager.model.StatusMessage; try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) { try { boolean isS3UploadComplete = false; while (!isS3UploadComplete) { try { // Read the statuses from the export status stream List messages = client.readMessages("StatusStreamName", new ReadMessagesOptions().withMinMessageCount(1L).withReadTimeoutMillis(1000L)); for (Message message : messages) { // Deserialize the status message first. StatusMessage statusMessage = ValidateAndSerialize.deserializeJsonBytesToObj(message.getPayload(), StatusMessage.class); // Check the status of the status message. If the status is "Success", the file was successfully uploaded to S3. // If the status was either "Failure" or "Canceled", the server was unable to upload the file to S3. // We will print the message for why the upload to S3 failed from the status message. // If the status was "InProgress", the status indicates that the server has started uploading the S3 task. if (Status.Success.equals(statusMessage.getStatus())) { System.out.println("Successfully uploaded file at path " + FILE_URL + " to S3."); isS3UploadComplete = true; } else if (Status.Failure.equals(statusMessage.getStatus()) || Status.Canceled.equals(statusMessage.getStatus())) { System.out.println(String.format("Unable to upload file at path %s to S3. Message %s", statusMessage.getStatusContext().getS3ExportTaskDefinition().getInputUrl(), statusMessage.getMessage())); sS3UploadComplete = true; } } } catch (StreamManagerException ignored) { } finally { // Sleep for sometime for the S3 upload task to complete before trying to read the status message. Thread.sleep(5000); } } catch (e) { // Properly handle errors. } } catch (StreamManagerException e) { // Properly handle exception. } ``` Riferimento a Java SDK: [ReadMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-) ------ #### [ Node.js ] ``` const { StreamManagerClient, ReadMessagesOptions, Status, StatusConfig, StatusLevel, StatusMessage, util, } = require('aws-greengrass-core-sdk').StreamManager; const client = new StreamManagerClient(); client.onConnected(async () => { try { let isS3UploadComplete = false; while (!isS3UploadComplete) { try { // Read the statuses from the export status stream const messages = await c.readMessages("StatusStreamName", new ReadMessagesOptions() .withMinMessageCount(1) .withReadTimeoutMillis(1000)); messages.forEach((message) => { // Deserialize the status message first. const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage); // Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3. // If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3. // We will print the message for why the upload to S3 failed from the status message. // If the status was "InProgress", the status indicates that the server has started uploading the S3 task. if (statusMessage.status === Status.Success) { console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`); isS3UploadComplete = true; } else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) { console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`); isS3UploadComplete = true; } }); // Sleep for sometime for the S3 upload task to complete before trying to read the status message. await new Promise((r) => setTimeout(r, 5000)); } catch (e) { // Ignored } } catch (e) { // Properly handle errors. } }); client.onError((err) => { // Properly handle connection errors. // This is called only when the connection to the StreamManager server fails. }); ``` Riferimento all'SDK Node.js: [ReadMessages \$1 [StatusMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages) ------ # 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) # 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*