Esporta flussi di dati in Cloud AWS (CLI)

Scarica il AWS IoT Greengrass Core SDK per Python v1.5.0 o successivo.

Decomprimere il pacchetto scaricato per ottenere l'SDK. Il kit SDK è la cartella greengrasssdk.

Installa le dipendenze del pacchetto da includere con l'SDK nel pacchetto di distribuzione delle funzioni Lambda.

Salvare la seguente funzione del codice Python nel file locale transfer_stream.py.

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())

Comprimere le voci seguenti nel file transfer_stream_python.zip. Questo è il tuo pacchetto di distribuzione delle funzioni Lambda.

Quando crei il file zip, includi solo questi elementi, non la cartella che li contiene.

Crea un ruolo IAM in modo da poter passare il ruolo ARN quando crei la funzione.

Copia il valore Arn dall'output.

Usa l' AWS Lambda API per creare la funzione. TransferStream Il comando seguente presuppone che il file ZIP si trovi nella directory corrente.

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

Pubblicare una versione della funzione.

aws lambda publish-version --function-name TransferStream --description 'First version'

Creare un alias della versione pubblicata.

I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'uso 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. Basta invece puntare l'alias alla nuova versione della funzione.

aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1

Copia il valore AliasArn dall'output. Si utilizza questo valore quando si configura la funzione per. AWS IoT Greengrass

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 predefinite. Per configurare le impostazioni personalizzate, è necessario definire le variabili di ambiente per i corrispondenti parametri di stream manager. Per un esempio, consultaPer abilitare, disabilitare o configurare lo stream manager (CLI). AWS IoT Greengrass utilizza le impostazioni predefinite per i parametri omessi. MemorySizedovrebbe essere almeno128000. Pinneddeve essere impostato sutrue.

Copia il valore LatestVersionArn dall'output. È possibile utilizzare questo valore per aggiungere la definizione di funzione alla versione del gruppo distribuita nel core.

Creare una definizione di logger che includa una versione iniziale.

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.

Ottieni gli ID del gruppo di destinazione Greengrass e la versione dei gruppi. Questa procedura presuppone che si tratti dell'ultima versione 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']"

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.

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.

Per ottenere l'ARN della versione di definizione del core:

1. Ottenere la versione del gruppo.

   • Sostituiscili group-id con Id quelli 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

2. Copia il valore CoreDefinitionVersionArn dall'output. Utilizza questo valore per aggiungere la versione di definizione del core alla versione del gruppo distribuita nel core.

Creare una versione del gruppo.

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

Copia il valore Version dall'output. Questo è l'ID della nuova versione gruppo.

Assicurati che il AWS IoT Greengrass core sia in esecuzione. 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.

2. Per avviare il demone:

   cd /greengrass/ggc/core/
   sudo ./greengrassd start

Crea una implementazione .

aws greengrass create-deployment \
--deployment-type NewDeployment \
--group-id group-id \
--group-version-id group-version-id

Copia il valore DeploymentId dall'output.

Ottenere lo stato della 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.

Nella console Amazon Kinesis, in Kinesis data stream, scegli. MyKinesisStream

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.

cd /greengrass/ggc/core/
sudo ./greengrassd stop

Rimuovi la funzione TransferStream Lambda dal core.

1. Seguire Fase 6: creazione di una versione del gruppo per creare una nuova versione del gruppo, ma rimuovere l'opzione --function-definition-version-arn nel comando create-group-version. Oppure, crea una versione di definizione della funzione che non includa la funzione TransferStream Lambda.

   Nota

   Omettendo la funzione GGStreamManager Lambda di sistema dalla versione di gruppo distribuita, disabiliti la gestione dello streaming sul core.

2. Seguire Fase 7: creazione di una distribuzione per distribuire la nuova versione del gruppo.