Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html). As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Exportar fluxos de dados para o Nuvem AWS (console) Este tutorial mostra como usar o AWS IoT console para configurar e implantar um AWS IoT Greengrass grupo com o gerenciador de stream ativado. O grupo contém uma função do Lambda definida pelo usuário que grava em um fluxo no gerenciador de fluxo e é exportado automaticamente para a Nuvem AWS. O gerenciador de fluxo torna mais eficientes e confiáveis a ingestão, o processamento e a exportação de fluxos de dados de alto volume. Neste tutorial, você criará uma função do Lambda `TransferStream` que consome dados de IoT. A função Lambda usa o SDK AWS IoT Greengrass principal para criar um stream no gerenciador de streams e depois ler e gravar nele. Em seguida, o gerenciador de fluxo exporta o fluxo para o Kinesis Data Streams. O diagrama a seguir mostra esse fluxo de trabalho. ![\[Diagrama do fluxo de trabalho do gerenciamento de fluxo.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/stream-manager-scenario.png) O foco deste tutorial é mostrar como as funções Lambda definidas pelo usuário usam `StreamManagerClient` o objeto no SDK principal para interagir com AWS IoT Greengrass o gerenciador de streams. Para simplificar, a função do Lambda em Python que você cria para este tutorial gera dados simulados do dispositivo. ## Pré-requisitos Para concluir este tutorial, é necessário: + Um grupo do Greengrass e um núcleo do Greengrass (versão 1.10 ou posterior). Para obter informações sobre como criar um grupo e um núcleo do Greengrass, consulte [Começando com AWS IoT Greengrass](gg-gs.md). O tutorial de introdução também inclui etapas para instalar o software AWS IoT Greengrass Core. **nota** O gerenciador de streams não é suportado em OpenWrt distribuições. + O Java 8 Runtime (JDK 8) instalado no dispositivo de núcleo. + Para distribuições com base em Debian (incluindo Raspbian) ou distribuições com base em Ubuntu, execute o comando a seguir: ``` sudo apt install openjdk-8-jdk ``` + Para distribuições com base em Red Hat (incluindo o Amazon Linux), execute o comando a seguir: ``` sudo yum install java-1.8.0-openjdk ``` Para obter mais informações, consulte [Como fazer download e instalar pacotes OpenJDK pré-compilados](https://openjdk.java.net/install/) na documentação do OpenJDK. + AWS IoT Greengrass SDK principal para Python v1.5.0 ou posterior. Para usar `StreamManagerClient` no SDK do AWS IoT Greengrass Core para Python, você deve: + Instalar o Python 3.7 ou posterior no dispositivo de núcleo. + Incluir o SDK e suas dependências em seu pacote de implantação da função do Lambda. As instruções são fornecidas neste tutorial. **dica** Você pode usar o `StreamManagerClient` com Java ou NodeJS. Por exemplo de código, consulte o [AWS IoT Greengrass Core SDK para](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 o Core SDK para](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) Node.js em. GitHub + Um stream de destino chamado **MyKinesisStream** criado no Amazon Kinesis Data Streams da mesma forma que seu grupo Região da AWS do Greengrass. Para obter mais informações, consulte [Criar um fluxo](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#create-stream) no *Guia do desenvolvedor do Amazon Kinesis*. **nota** Neste tutorial, o gerenciador de fluxo exporta dados para o Kinesis Data Streams, o que resulta em cobranças em sua Conta da AWS. Para obter informações sobre a definição de preços, consulte [Definição de preço do Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Para evitar incorrer em cobranças, você pode executar este tutorial sem criar um fluxo de dados do Kinesis. Nesse caso, verifique os logs para confirmar se o gerenciador de fluxo tentou exportar o fluxo para o Kinesis Data Streams. + Uma política do IAM adicionada à [Função do grupo do Greengrass.](group-role.md) que permite a ação `kinesis:PutRecords` no fluxo de dados de destino, conforme mostrado no exemplo a seguir: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kinesis:PutRecords" ], "Resource": [ "arn:aws:kinesis:us-east-1:123456789012:stream/MyKinesisStream" ] } ] } ``` ------ O tutorial contém as seguintes etapas de nível elevado: 1. [Crie um pacote de implantação para a função do Lambda](#stream-manager-console-create-deployment-package) 1. [Criar uma função do Lambda](#stream-manager-console-create-function) 1. [Adicionar uma função ao grupo](#stream-manager-console-create-gg-function) 1. [Habilitar o gerenciador de fluxo](#stream-manager-console-enable-stream-manager) 1. [Configurar o registro em log local](#stream-manager-console-configure-logging) 1. [Implantar o grupo](#stream-manager-console-create-deployment) 1. [Teste a aplicação](#stream-manager-console-test-application) O tutorial levará aproximadamente 20 minutos para ser concluído. ## Etapa 1: crie um pacote de implantação para a função do Lambda Nesta etapa, você cria um pacote de implantação da função do Lambda que contém o código e as dependências da função do Python. Faça upload desse pacote posteriormente, ao criar a função do Lambda no AWS Lambda. A função Lambda usa o SDK AWS IoT Greengrass principal para criar e interagir com fluxos locais. **nota** As funções do Lambda definidas pelo usuário devem usar o [SDK do AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks-core) para interagir com o gerenciador de fluxo. Para obter mais informações sobre os requisitos para o gerenciador de fluxo do Greengrass, consulte os [requisitos do gerenciador de fluxo do Greengrass](stream-manager.md#stream-manager-requirements). 1. Baixe o [SDK do AWS IoT Greengrass Core para Python](lambda-functions.md#lambda-sdks-core) v1.5.0 ou posterior. 1. Descompacte o pacote obtido por download para obter o SDK. O SDK é a pasta do `greengrasssdk`. 1. Instale as dependências do pacote para serem incluídas com o SDK no pacote de implantação da função do Lambda. 1. Navegue até o diretório SDK que contém o arquivo `requirements.txt`. Esse arquivo lista as dependências. 1. Instale as dependências do SDK. Por exemplo, execute o seguinte comando `pip` para instalar as dependências no diretório atual: ``` pip install --target . -r requirements.txt ``` 1. Salve a seguinte função do código Python em um arquivo local denominado `transfer_stream.py`. **dica** Por exemplo, código que usa Java e NodeJS, consulte [AWS IoT Greengrass o SDK principal para [AWS IoT Greengrass Java e](https://github.com/aws/aws-greengrass-core-sdk-js/blob/master/greengrassExamples/StreamManagerKinesis/index.js) o SDK principal](https://github.com/aws/aws-greengrass-core-sdk-java/blob/master/samples/StreamManagerKinesis/src/main/java/com/amazonaws/greengrass/examples/StreamManagerKinesis.java) para Node.js em. 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. Comprima os seguintes itens em um arquivo denominado `transfer_stream_python.zip`. Esse é o pacote de implantação de sua função do Lambda. + **transfer\$1stream.py**. Lógica do aplicativo. + **greengrasssdk**. Biblioteca necessária para funções Python do Lambda do Greengrass que publicam mensagens MQTT. As [operações do gerenciador de fluxo](work-with-streams.md) estão disponíveis na versão 1.5.0 ou posterior do SDK AWS IoT Greengrass Core para Python. + As dependências que você instalou para o SDK AWS IoT Greengrass principal para Python (por exemplo, os diretórios). `cbor2` Ao criar o arquivo `zip`, inclua apenas esses itens, não a pasta que contém os arquivos. ## Etapa 2: Criar uma função do Lambda Nesta etapa, você usa o AWS Lambda console para criar uma função Lambda e configurá-la para usar seu pacote de implantação. Depois, publique uma versão da função e crie um alias. 1. Primeiro, crie a função do Lambda. 1. No Console de gerenciamento da AWS, escolha **Serviços** e abra o AWS Lambda console. 1. Selecione **Criar função** e, em seguida, selecione **Criar do zero**. 1. Na seção **Basic information (Informações básicas)**, use os seguintes valores: + Em **Function name** (Nome da função), insira **TransferStream**. + Em **Runtime (Tempo de execução)**, selecione **Python 3.7**. + Em **Permissões**, mantenha a configuração padrão. Isso cria uma função de execução que concede permissões básicas do Lambda. Essa função não é usada por AWS IoT Greengrass. 1. Na parte inferior da página, selecione **Create function**. 1. Em seguida, registre o manipulador e faça upload do seu pacote de implantação da função do Lambda. 1. Na guia **Código**, em **Fonte do código**, selecione **Fazer upload a partir de**. No menu suspenso, selecione o **arquivo .zip**. ![\[O menu suspenso Fazer upload a partir de com o arquivo .zip destacado.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png) 1. Selecione **Upload** e, em seguida, selecione seu pacote de implantação `transfer_stream_python.zip`. Selecione **Salvar**. 1. Na guia **Código** da função, em **Configurações de runtime**, selecione **Editar** e insira os valores a seguir. + Em **Runtime (Tempo de execução)**, selecione **Python 3.7**. + Em **Handler (Manipulador)**, insira **transfer\$1stream.function\$1handler**. 1. Escolha **Salvar**. **nota** O botão **Testar** no AWS Lambda console não funciona com essa função. O SDK AWS IoT Greengrass principal não contém módulos necessários para executar suas funções do Greengrass Lambda de forma independente no console. AWS Lambda Esses módulos (por exemplo, `greengrass_common`) são fornecidos às funções depois de serem implantados no núcleo do Greengrass. 1. Agora, publique a primeira versão da sua função do Lambda e crie um [alias para a versão](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html). **nota** Os grupos do Greengrass podem fazer referência a uma função do Lambda por alias (recomendado) ou por versão. Usar um alias facilita o gerenciamento de atualizações de código porque você não precisa alterar a tabela de assinaturas nem a definição do grupo ao atualizar a função do código. Em vez disso, você pode simplesmente apontar o alias para a nova versão da função. 1. No menu **Actions**, selecione **Publish new version**. 1. Em **Version description (Descrição da versão)**, insira **First version** e, em seguida, selecione **Publish (Publicar)**. 1. Na página de configuração **TransferStream: 1**, no menu **Ações**, escolha **Criar alias**. 1. Na página **Create a new alias**, use os seguintes valores: + Em **Nome**, digite **GG\$1TransferStream**. + Em **Version**, selecione **1**. **nota** AWS IoT Greengrass **não oferece suporte a aliases Lambda para as versões \$1LATEST.** 1. Selecione **Create** (Criar). Agora você está pronto para adicionar a função do Lambda ao seu grupo do Greengrass. ## Etapa 3: Adicionar uma função do Lambda ao grupo do Greengrass Nesta etapa, você adiciona a função do Lambda ao grupo e configura o ciclo de vida e as variáveis de ambiente. Para obter mais informações, consulte [Controlar a execução de funções do Lambda do Greengrass usando a configuração específica do grupo](lambda-group-config.md). 1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1). 1. Selecione o grupo de destino. 1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**. 1. Em **Minhas funções do Lambda**, selecione **Adicionar**. 1. Na página **Adicionar função Lambda**, selecione a **função do Lambda** para sua função do Lambda. 1. **Para a **versão Lambda**, escolha Alias:gg\$1. TransferStream** Agora, configure propriedades que determinem o comportamento da função do Lambda no grupo do Greengrass. 1. Na seção **Configuração da função do Lambda**, faça as seguintes alterações: + Defina o **Memory limit (Limite de memória)** como 32 MB. + Para **Fixado**, selecione **Verdadeiro**. **nota** Uma função Lambda de *longa duração* (ou *fixada*) é iniciada automaticamente após o AWS IoT Greengrass início e continua sendo executada em seu próprio contêiner. Isso contrasta com uma função do Lambda *sob demanda*, que é iniciada quando invocada e interrompida quando não há tarefas a serem executadas. Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle). 1. Selecione **Adicionar função do Lambda**. ## Etapa 4: Habilitar o gerenciador de fluxo Nesta etapa, verifique se o gerenciador de fluxo está habilitado. 1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**. 1. Em **Funções do Lambda do sistema**, selecione **Gerenciador de fluxo** e verifique o status. Se estiver desabilitado, selecione **Edit (Editar)**. Em seguida, selecione **Enable (Habilitar)** e **Salvar**. Você pode usar as configurações de parâmetro padrão para este tutorial. Para obter mais informações, consulte [Configurar o gerenciador de AWS IoT Greengrass streams](configure-stream-manager.md). **nota** Quando você usa o console para habilitar o gerenciador de fluxo e implantar o grupo, o limite de memória para o gerenciador de fluxo é definido como 4194304 KB (4 GB), por padrão. É recomendável definir o tamanho da memória para pelo menos 128000 KB. ## Etapa 5: Configurar o registro em log local Nesta etapa, você configura componentes AWS IoT Greengrass do sistema, funções Lambda definidas pelo usuário e conectores no grupo para gravar registros no sistema de arquivos do dispositivo principal. Você pode usar logs para solucionar quaisquer problemas que possa encontrar. Para obter mais informações, consulte [Monitoramento com AWS IoT Greengrass registros](greengrass-logs-overview.md). 1. Em **Local logs configuration (Configuração dos logs locais)**, verifique se o log local está configurado. 1. Se os logs não estiverem configurados para os componentes do sistema do Greengrass ou as funções do Lambda definidas pelo usuário, selecione **Editar**. 1. Selecione **Nível de log das funções do Lambda** e o **Nível de log do sistema Greengrass**. 1. Mantenha os valores padrão para o nível de registro em log e o limite de espaço em disco e selecione **Salvar**. ## Etapa 6: Implantar o grupo do Greengrass Implante o grupo no dispositivo do núcleo. 1. Certifique-se de que o AWS IoT Greengrass núcleo esteja funcionando. Execute os seguintes comandos no seu terminal do Raspberry Pi, conforme necessário. 1. Para verificar se o daemon está em execução: ``` ps aux | grep -E 'greengrass.*daemon' ``` Se a saída contém uma entrada `root` para `/greengrass/ggc/packages/ggc-version/bin/daemon`, o daemon está em execução. **nota** A versão no caminho depende da versão do software AWS IoT Greengrass principal que está instalada em seu dispositivo principal. 1. Para iniciar o daemon: ``` cd /greengrass/ggc/core/ sudo ./greengrassd start ``` 1. Na página de configuração do grupo, selecione **Implantar**. 1. 1. Na guia **Funções do Lambda**, na seção **Funções do Lambda do sistema**, selecione **Detector de IP** e selecione **Editar**. 1. Na caixa de diálogo **Editar configurações do detector IP**, selecione **Detectar e substituir automaticamente os endpoints do corretor MQTT**. 1. Selecione **Salvar**. Isso permite que os dispositivos adquiram automaticamente as informações de conectividade para o núcleo, como endereço IP, DNS e o número da porta. A detecção automática é recomendada, mas AWS IoT Greengrass também oferece suporte a endpoints especificados manualmente. Você só é solicitado pelo método de descoberta na primeira vez em que o grupo for implantado. **nota** Se solicitado, conceda permissão para criar a função de [serviço do Greengrass](service-role.md) e associá-la à Conta da AWS sua na atual. Região da AWS Essa função permite AWS IoT Greengrass acessar seus recursos em AWS serviços. A página **Deployments** mostra a data e hora, ID de versão e status da implantação. Quando concluída, o status exibido para a implantação deve ser **Concluída**. Para obter ajuda sobre a solução de problemas, consulte [Solução de problemas AWS IoT Greengrass](gg-troubleshooting.md). ## Etapa 7: Testar o aplicativo A função do Lambda do `TransferStream` gera dados simulados do dispositivo. Ela grava dados em um fluxo que o gerenciador de fluxo exporta para o fluxo de dados do Kinesis de destino. 1. No console do Amazon Kinesis, em **Kinesis data** streams, escolha. **MyKinesisStream** **nota** Se você executou o tutorial sem um fluxo de dados do Kinesis de destino, [verifique o arquivo de log](stream-manager-cli.md#stream-manager-cli-logs) do gerenciador de fluxo (`GGStreamManager`). Se ele contiver `export stream MyKinesisStream doesn't exist` em uma mensagem de erro, o teste será bem-sucedido. Esse erro significa que o serviço tentou exportar para o fluxo, mas o fluxo não existe. 1. Na **MyKinesisStream**página, escolha **Monitoramento**. Se o teste for bem-sucedido, você verá os dados nos gráficos **Put Records (Inserir registros)** . Dependendo da sua conexão, pode demorar um minuto até que os dados sejam exibidos. **Importante** Ao terminar o teste, exclua o fluxo de dados do Kinesis para evitar mais cobranças. Ou execute o comando a seguir para interromper o daemon do Greengrass. Isso impedirá que o núcleo envie mensagens até que você esteja pronto para dar continuidade aos testes. ``` cd /greengrass/ggc/core/ sudo ./greengrassd stop ``` 1. Remova a função **TransferStream**Lambda do núcleo. 1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1). 1. Em **Grupos do Greengrass**, selecione seu grupo. 1. **Na página **Lambdas**, escolha as elipses (**...**) para a **TransferStream**função e, em seguida, escolha Remover função.** 1. Em **Actions (Ações)**, selecione **Deploy (Implantar)**. Para exibir informações de registro ou solucionar problemas com fluxos, verifique os logs das funções `TransferStream` e `GGStreamManager`. Você deve ter `root` permissões para ler AWS IoT Greengrass registros no sistema de arquivos. + `TransferStream` grava entradas de log em `greengrass-root/ggc/var/log/user/region/account-id/TransferStream.log`. + `GGStreamManager` grava entradas de log em `greengrass-root/ggc/var/log/system/GGStreamManager.log`. Se precisar de mais informações sobre a solução de problemas, você pode [definir o nível de registro](#stream-manager-console-configure-logging) dos **logs do usuário do Lambda** como **logs de depuração** e, em seguida, implantar o grupo novamente. ## Consulte também + [Gerencie fluxos de dados no núcleo AWS IoT Greengrass](stream-manager.md) + [Configurar o gerenciador de AWS IoT Greengrass streams](configure-stream-manager.md) + [Use StreamManagerClient para trabalhar com streams](work-with-streams.md) + [Configurações de exportação para destinos compatíveis Nuvem AWS](stream-export-configurations.md) + [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md)