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 (CLI) Este tutorial mostra como usar o AWS CLI 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. Quando você usa a AWS IoT Greengrass API, que inclui os comandos do Greengrass no AWS CLI, para criar um grupo, o stream manager é desativado por padrão. Para habilitar o gerenciador de fluxo em seu núcleo, [crie uma versão de definição de função](#stream-manager-cli-create-function-definition) que inclua a função do Lambda do sistema `GGStreamManager` e uma versão de grupo que faça referência à nova versão de definição de função. Depois, implante o grupo. ## 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 AWS CLI instalado e configurado no seu computador. Para obter mais informações, consulte o [Instalando o AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) e [Configurando o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) no *Guia do usuário da AWS Command Line Interface *.   Os comandos de exemplo neste tutorial são gravados para Linux e outros sistemas baseados em Unix. Se você estiver usando o Windows, consulte [Especificação de valores de parâmetros para a interface de linha de AWS comando](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html) para obter mais informações sobre diferenças na sintaxe. Se o comando contém uma string JSON, o tutorial fornece um exemplo que tem o JSON em uma única linha. Em alguns sistemas, pode ser mais eficiente editar e executar comandos usando esse formato.   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-cli-create-deployment-package) 1. [Criar uma função do Lambda](#stream-manager-cli-create-function) 1. [Criar uma definição e uma versão de função](#stream-manager-cli-create-function-definition) 1. [Criar uma definição e versão do logger](#stream-manager-cli-create-logger-definition) 1. [Obter o ARN da sua versão de definição de núcleo](#stream-manager-cli-get-core-definition-version-arn) 1. [Criar uma versão de grupo](#stream-manager-cli-create-group-version) 1. [Crie um implantação do .](#stream-manager-cli-create-deployment) 1. [Teste a aplicação](#stream-manager-cli-test-application) O tutorial levará aproximadamente 30 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 AWS IoT Greengrass Core SDK 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 1. Crie um perfil do IAM para você transmitir no ARN da função ao criar a função. ------ #### [ 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 não usa essa função porque as permissões para suas funções do Lambda do Greengrass são especificadas na função de grupo do Greengrass. Neste tutorial, você cria uma função vazia. 1. Copie a `Arn` da saída. 1. Use a AWS Lambda API para criar a `TransferStream` função. O comando a seguir pressupõe que o arquivo zip esteja no diretório atual. + Substitua *role-arn* pelo `Arn` que você copiou. ``` 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. Publique uma versão da função. ``` aws lambda publish-version --function-name TransferStream --description 'First version' ``` 1. Crie um alias para a versão publicada. 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. ``` aws lambda create-alias --function-name TransferStream --name GG_TransferStream --function-version 1 ``` **nota** AWS IoT Greengrass **não oferece suporte a aliases Lambda para as versões \$1LATEST.** 1. Copie a `AliasArn` da saída. Você usa esse valor ao configurar a função para AWS IoT Greengrass. Agora você está pronto para configurar a função para AWS IoT Greengrass. ## Etapa 3: Criar uma definição e uma versão de função Essa etapa cria uma versão de definição de função que faz referência à função do Lambda do sistema `GGStreamManager` e à sua função do Lambda `TransferStream` definida pelo usuário. Para ativar o gerenciador de streams ao usar a AWS IoT Greengrass API, sua versão de definição de função deve incluir a `GGStreamManager` função. 1. Crie uma definição de função com uma versão inicial que contenha as funções do Lambda definidas pelo sistema e pelo usuário. A versão de definição a seguir ativa o gerenciador de fluxo com [configurações de parâmetros](configure-stream-manager.md) padrão. Para definir configurações personalizadas, você deve definir variáveis de ambiente para os parâmetros correspondentes do gerenciador de fluxo. Para obter um exemplo, consulte[Habilitar, desabilitar ou definir as configurações do gerenciador de fluxo (CLI)](configure-stream-manager.md#enable-stream-manager-cli). AWS IoT Greengrass usa configurações padrão para parâmetros que são omitidos. `MemorySize`deveria ser pelo menos`128000`. `Pinned`deve ser definido como`true`. **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). + *arbitrary-function-id*Substitua por um nome para a função, como**stream-manager**. + *alias-arn*Substitua pelo `AliasArn` que você copiou ao criar o alias para a função 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** O `Timeout` é exigido pela versão de definição de função, mas o `GGStreamManager` não o utiliza. Para obter mais informações sobre `Timeout` e outras configurações em nível de grupo, 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. Copie a `LatestVersionArn` da saída. Você usa esse valor para adicionar a versão de definição da função à versão de grupo que você implanta no núcleo. ## Etapa 4: Criar uma definição e versão do logger Defina as configurações de registro do grupo. Neste tutorial, você configura componentes AWS IoT Greengrass do sistema, funções Lambda definidas pelo usuário e conectores 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. Crie uma definição de logger que inclua uma versão inicial. ------ #### [ 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. Copie a `LatestVersionArn` da definição de logger da saída. Use esse valor para adicionar a versão de definição de logger à versão de grupo implantada no núcleo. ## Etapa 5: Obter o ARN da sua versão de definição de núcleo Obtenha o ARN da versão de definição de núcleo para adicionar à sua nova versão de grupo. Para implantar uma versão de grupo, ela deve fazer referência a uma versão de definição de núcleo que contenha exatamente um núcleo. 1. Obtenha a versão IDs do grupo-alvo do Greengrass e do grupo. Esse procedimento pressupõe que esse seja o grupo e a versão mais recente do grupo. A consulta a seguir retorna o grupo criado mais recentemente. ``` aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]" ``` Ou é possível consultar por nome. Os nomes de grupo não precisam ser exclusivos, portanto, vários grupos podem ser retornados. ``` aws greengrass list-groups --query "Groups[?Name=='MyGroup']" ``` **nota** Você também pode encontrar esses valores no AWS IoT console. O ID do grupo é exibido na página **Settings (Configurações)** do grupo. IDs As versões do grupo são exibidas na guia **Implantações** do grupo. 1. Copie da saída o `Id` do grupo de destino. Você usa isso para obter a versão de definição de núcleo e ao implantar o grupo. 1. Copie a `LatestVersion` da saída, que é o ID da última versão adicionada ao grupo. Você usa isso para obter a versão de definição do núcleo. 1. Obtenha o ARN da versão de definição de núcleo: 1. Obtenha a versão do grupo. + *group-id*Substitua pelo `Id` que você copiou para o grupo. + *group-version-id*Substitua pelo `LatestVersion` que você copiou para o grupo. ``` aws greengrass get-group-version \ --group-id group-id \ --group-version-id group-version-id ``` 1. Copie a `CoreDefinitionVersionArn` da saída. Use esse valor para adicionar a versão de definição à versão de grupo implantada no núcleo. ## Etapa 6: Criar uma versão de grupo Agora, você está pronto para criar uma versão de grupo que contém todas as entidades que você deseja implantar. Faça isso criando uma versão de grupo que faz referência à versão de destino de cada componente. Neste tutorial, você inclui uma versão de definição de núcleo, uma versão de definição de função e uma versão de definição de logger. 1. Criar uma versão de grupo. + *group-id*Substitua pelo `Id` que você copiou para o grupo. + *core-definition-version-arn*Substitua pelo `CoreDefinitionVersionArn` que você copiou para a versão de definição principal. + *function-definition-version-arn*Substitua pelo `LatestVersionArn` que você copiou para sua nova versão de definição de função. + *logger-definition-version-arn*Substitua pelo `LatestVersionArn` que você copiou para sua nova versão de definição do registrador. ``` 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. Copie a `Version` da saída. Este é o ID da nova versão do grupo. ## Etapa 7: Criar uma implantação 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. Crie um implantação do . + *group-id*Substitua pelo `Id` que você copiou para o grupo. + *group-version-id*Substitua pelo `Version` que você copiou para a nova versão do grupo. ``` aws greengrass create-deployment \ --deployment-type NewDeployment \ --group-id group-id \ --group-version-id group-version-id ``` 1. Copie a `DeploymentId` da saída. 1. Obtenha o status de implantação. + *group-id*Substitua pelo `Id` que você copiou para o grupo. + *deployment-id*Substitua pelo `DeploymentId` que você copiou para a implantação. ``` aws greengrass get-deployment-status \ --group-id group-id \ --deployment-id deployment-id ``` Se o status for `Success`, a implantação foi bem-sucedida. Para obter ajuda sobre a solução de problemas, consulte [Solução de problemas AWS IoT Greengrass](gg-troubleshooting.md). ## Etapa 8: 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-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. Siga [Etapa 6: Criar uma versão de grupo](#stream-manager-cli-create-group-version) para criar uma nova versão de grupo, mas remova a opção `--function-definition-version-arn` no comando `create-group-version`. Ou crie uma versão de definição de função que não inclua a função **TransferStream**Lambda. **nota** Ao omitir a função do Lambda do sistema `GGStreamManager` da versão do grupo implantado, desabilite o gerenciamento de fluxo no núcleo. 1. Siga [Etapa 7: Criar uma implantação](#stream-manager-cli-create-deployment) para implantar a nova versão do grupo. 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 resolução de problemas, você pode definir o nível de registro do `Lambda` como `DEBUG` e criar e implantar uma nova versão de grupo. ## Consulte também + [Gerencie fluxos de dados no núcleo AWS IoT Greengrass](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) + [Configurar o gerenciador de AWS IoT Greengrass streams](configure-stream-manager.md) + [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.md) + [AWS Identity and Access Management Comandos (IAM)](https://docs.aws.amazon.com/cli/latest/reference/iam) na *Referência de AWS CLI Comandos* + [AWS Lambda comandos](https://docs.aws.amazon.com/cli/latest/reference/lambda) na *Referência de AWS CLI Comandos* + [AWS IoT Greengrass comandos](https://docs.aws.amazon.com/cli/latest/reference/greengrass/index.html) na *Referência de AWS CLI Comandos*