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á.
# Gerencie fluxos de dados no núcleo AWS IoT Greengrass
AWS IoT Greengrass O gerenciador de fluxo torna mais fácil e confiável transferir dados de IoT de alto volume para o. Nuvem AWS O gerenciador de fluxo processa fluxos de dados localmente e os exporta para o Nuvem AWS automaticamente. Esse recurso se integra a cenários de ponta comuns, como inferência de aprendizado de máquina (ML), em que os dados são processados e analisados localmente antes de serem exportados para os destinos de armazenamento Nuvem AWS ou locais.
O gerenciador de fluxo simplifica o desenvolvimento de aplicativos. Seus aplicativos para IoT podem usar um mecanismo padronizado para processar fluxos de alto volume e gerenciar políticas de retenção de dados locais em vez de criar uma funcionalidade personalizada do gerenciamento de fluxo. Os aplicativos para IoT podem ler e gravar em fluxos. Eles podem definir políticas para o tipo de armazenamento, tamanho e retenção de dados por estilhaço para controlar como o gerenciador de fluxo processa e exporta fluxos.
O gerenciador de fluxo foi projetado para funcionar em ambientes de conectividade intermitente ou limitada. Você pode definir o uso da largura de banda, o comportamento de tempo limite e como os dados do fluxo são manipulados quando o núcleo é conectado ou desconectado. Para dados críticos, você pode definir prioridades a fim de controlar a ordem em que os fluxos são exportados para a Nuvem AWS.
Você pode configurar exportações automáticas Nuvem AWS para armazenamento ou processamento e análise adicionais. O Stream Manager suporta a exportação para os seguintes Nuvem AWS destinos.
+ Canais em AWS IoT Analytics. AWS IoT Analytics permite realizar análises avançadas em seus dados para ajudar a tomar decisões comerciais e melhorar os modelos de aprendizado de máquina. Para obter mais informações, consulte [O que é AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) no *Guia do AWS IoT Analytics usuário*.
+ Fluxos no Kinesis Data Streams. O Kinesis Data Streams é comumente usado para agregar dados de alto volume e carregá-los em um data warehouse ou cluster de redução de mapas. Para obter mais informações, consulte [O que é o Amazon Kinesis Data Streams?](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) no *Guia do desenvolvedor do Amazon Kinesis*.
+ Propriedades de ativos em AWS IoT SiteWise. AWS IoT SiteWise permite coletar, organizar e analisar dados de equipamentos industriais em grande escala. Para obter mais informações, consulte [O que é AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) no *Guia do AWS IoT SiteWise usuário*.
+ Objetos no Amazon S3. Você pode utilizar o Amazon S3 para armazenar e recuperar grandes volumes de dados. Para obter mais informações, consulte [O que é o Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) no *Guia do desenvolvedor do Amazon Simple Storage Service*.
## Fluxo de trabalho do gerenciamento de streams
Seus aplicativos de IoT interagem com o gerenciador de streams por meio do SDK AWS IoT Greengrass principal. Em um fluxo de trabalho simples, uma função do Lambda definida pelo usuário em execução no núcleo do Greengrass consome dados da IoT, como métricas de temperatura e pressão de séries temporais. A função Lambda pode filtrar ou compactar os dados e, em seguida, chamar o SDK AWS IoT Greengrass principal para gravar os dados em um stream no stream manager. O gerenciador de fluxo pode exportar o fluxo para a Nuvem AWS automaticamente, com base nas políticas definidas para o fluxo. As funções do Lambda definidas pelo usuário também podem enviar dados diretamente para bancos de dados locais ou repositórios de armazenamento.
Os aplicativos para IoT podem incluir várias funções do Lambda definidas pelo usuário para leitura e gravação em fluxos. Essas funções locais do Lambda podem ler e gravar fluxos de modo a filtrar, agregar e analisar dados localmente. Isso torna possível responder rapidamente a eventos locais e extrair informações valiosas antes que os dados sejam transferidos do núcleo para destinos locais ou na nuvem.
Um fluxo de trabalho de exemplo é mostrado no diagrama a seguir.
![\[Diagrama do fluxo de trabalho do gerenciador de fluxo.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/stream-manager-architecture.png)
Para usar o gerenciador de fluxo, comece configurando os parâmetros do gerenciador de fluxo para definir as configurações de runtime em nível de grupo que se aplicam a todos os fluxos no núcleo do Greengrass. Essas configurações personalizáveis permitem controlar como o gerenciador de fluxo armazena, processa e exporta fluxos com base nas necessidades do seu negócios e nas restrições do ambiente. Para obter mais informações, consulte [Configurar o gerenciador de AWS IoT Greengrass streams](configure-stream-manager.md).
Depois de configurar o gerenciador de fluxo, você pode criar e implantar seus aplicativos de IoT. Normalmente, essas são funções Lambda definidas pelo usuário que são `StreamManagerClient` usadas AWS IoT Greengrass no SDK principal para criar e interagir com fluxos. Durante a criação do fluxo, a função do Lambda define políticas por fluxo, como destinos de exportação, prioridade e persistência. Para obter mais informações, incluindo trechos de código para operações `StreamManagerClient`, consulte [Use StreamManagerClient para trabalhar com streams](work-with-streams.md).
Para tutoriais que configuram um fluxo de trabalho simples, consulte [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.md) ou [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md).
## Requisitos
Os seguintes requisitos são aplicados para usar o gerenciador de fluxo:
+ Você deve usar o software AWS IoT Greengrass Core v1.10 ou posterior, com o gerenciador de streams ativado. Para obter mais informações, consulte [Configurar o gerenciador de AWS IoT Greengrass streams](configure-stream-manager.md).
O gerenciador de streaming não é suportado em OpenWrt distribuições.
+ O Java 8 Runtime (JDK 8) deve ser instalado no 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.
+ O gerenciador de streaming requer um mínimo de 70 MB de RAM, além do software AWS IoT Greengrass Core básico. O requisito de memória total depende da sua workload.
+ 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. O SDK AWS IoT Greengrass principal está disponível em vários idiomas, mas somente as versões a seguir oferecem suporte às operações do gerenciador de stream:
+ SDK do Java (v1.4.0 ou posterior)
+ SDK do Python (v1.5.0 ou posterior)
+ SDK do Node.js (v1.6.0 ou posterior)
Faça download da versão do SDK que corresponde ao runtime da função do Lambda e a inclua no pacote de implantação da função do Lambda.
**nota**
O SDK AWS IoT Greengrass principal para Python requer o Python 3.7 ou posterior e tem outras dependências de pacotes. Para obter mais informações, consulte [Crie um pacote de implantação da função do Lambda (console)](stream-manager-console.md#stream-manager-console-create-deployment-package) ou [Crie um pacote de implantação da função do Lambda (CLI)](stream-manager-cli.md#stream-manager-cli-create-deployment-package).
+ Se você definir destinos de Nuvem AWS exportação para um stream, deverá criar seus destinos de exportação e conceder permissões de acesso na função de grupo do Greengrass. Dependendo do destino, outros requisitos também podem ser aplicados. Para obter mais informações, consulte:
+ [AWS IoT Analytics canais](stream-export-configurations.md#export-to-iot-analytics)
+ [Amazon Kinesis Data Streams](stream-export-configurations.md#export-to-kinesis)
+ [AWS IoT SiteWise propriedades do ativo](stream-export-configurations.md#export-to-iot-sitewise)
+ [Objetos do Amazon S3](stream-export-configurations.md#export-to-s3)
Você é responsável pela manutenção desses Nuvem AWS recursos.
## Segurança de dados
Ao usar o gerenciador de fluxo, esteja ciente das seguintes considerações de segurança.
### Segurança de dados locais
AWS IoT Greengrass não criptografa dados de fluxo em repouso ou em trânsito localmente entre os componentes no dispositivo principal.
+ **Dados em repouso**. Os dados de fluxo são armazenados localmente em um diretório de armazenamento o núcleo do Greengrass. Para segurança de dados, AWS IoT Greengrass depende de permissões de arquivo Unix e criptografia de disco completo, se habilitada. Você pode usar o parâmetro [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) opcional para especificar o diretório de armazenamento. Se você alterar esse parâmetro posteriormente para usar um diretório de armazenamento diferente, AWS IoT Greengrass não excluirá o diretório de armazenamento anterior nem seu conteúdo.
+ **Dados em trânsito localmente**. AWS IoT Greengrass não criptografa dados de fluxo em trânsito local no núcleo entre fontes de dados, funções Lambda, o SDK principal e AWS IoT Greengrass o gerenciador de fluxo.
+ **Dados em trânsito para Nuvem AWS** o. Os fluxos de dados exportados pelo gerenciador de fluxo para o Nuvem AWS usam criptografia de cliente de AWS serviço padrão com Transport Layer Security (TLS).
Para obter mais informações, consulte [Criptografia de dados](data-encryption.md).
### Autenticação de cliente
Os clientes do gerenciador de fluxo usam o SDK AWS IoT Greengrass principal para se comunicar com o gerenciador de fluxo. Quando a autenticação do cliente está ativada, apenas as funções do Lambda no grupo do Greengrass podem interagir com fluxos no gerenciador de fluxo. Quando a autenticação do cliente está desabilitada, qualquer processo em execução no núcleo do Greengrass (como [contêineres do Docker](docker-app-connector.md)) pode interagir com fluxos no gerenciador de fluxo. Você só deve desabilitar a autenticação se o seu caso de negócios exigir.
Use o parâmetro [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT) para definir o modo de autenticação do cliente. Você pode configurar esse parâmetro no console ou na AWS IoT Greengrass API. As alterações entrarão em vigor após a implantação do grupo.
****
| | Habilitada | Desabilitado |
| --- | --- | --- |
| Valor do parâmetro | `true` (padrão e recomendado) | `false` |
| Clientes permitidos | Funções do Lambda definidas pelo usuário no grupo do Greengrass | Funções do Lambda definidas pelo usuário no grupo do Greengrass Outros processos em execução no dispositivo de núcleo do Greengrass |
## Consulte também
+ [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 (console)](stream-manager-console.md)
+ [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md)
# Configurar o gerenciador de AWS IoT Greengrass streams
No AWS IoT Greengrass núcleo, o gerenciador de streams pode armazenar, processar e exportar dados de dispositivos de IoT. O gerenciador de fluxo fornece parâmetros que você usa para definir configurações de tempo de execução no nível do grupo. Essas configurações se aplicam a todos os streams no núcleo do Greengrass. Você pode usar o AWS IoT console ou a AWS IoT Greengrass API para definir as configurações do gerenciador de streams. As alterações entrarão em vigor após a implantação do grupo.
**nota**
Após configurar o gerenciador de fluxo, você pode criar e implantar aplicativos de IoT que são executados no núcleo do Greengrass e interagem com o gerenciador de fluxo. Esses aplicativos de IoT geralmente são funções do Lambda definidas pelo usuário. Para obter mais informações, consulte [Use StreamManagerClient para trabalhar com streams](work-with-streams.md).
## Parâmetros do gerenciador de fluxo
O gerenciador de fluxo fornece os seguintes parâmetros que permitem definir configurações no nível do grupo. Todos os parâmetros são opcionais.
**Diretório de armazenamento**
Nome do parâmetro: `STREAM_MANAGER_STORE_ROOT_DIR`
O caminho absoluto do diretório local usado para armazenar fluxos. Esse valor deve começar com uma barra (por exemplo, `/data`).
Para obter informações sobre como proteger dados de fluxo, consulte [Segurança de dados locais](stream-manager.md#stream-manager-security-stream-data).
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Porta do servidor**
Nome do parâmetro: `STREAM_MANAGER_SERVER_PORT`
O número da porta local usado para se comunicar com o gerenciador de fluxo. O padrão é `8088`.
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Autenticar cliente**
Nome do parâmetro: `STREAM_MANAGER_AUTHENTICATE_CLIENT`
Indica se os clientes devem ser autenticados de modo a interagir com o gerenciador de fluxo. Toda interação entre clientes e o gerenciador de streams é controlada pelo SDK AWS IoT Greengrass principal. Esse parâmetro determina quais clientes podem chamar o SDK do AWS IoT Greengrass Core para trabalhar com fluxos. Para obter mais informações, consulte [Autenticação de cliente](stream-manager.md#stream-manager-security-client-authentication).
Os valores válidos são `true` ou `false`. O padrão é `true` (recomendado).
+ `true`. Permite apenas funções do Lambda do Greengrass como clientes. Os clientes da função Lambda usam protocolos AWS IoT Greengrass principais internos para se autenticar com o AWS IoT Greengrass SDK principal.
+ `false`. Permite que qualquer processo executado no AWS IoT Greengrass núcleo seja um cliente. Não defina como `false` a menos que seu caso de negócios exija. Por exemplo, defina esse valor como `false` somente se os processos que não são do dispositivo central precisarem se comunicar diretamente com o gerenciador de fluxo, como [contêineres do Docker](docker-app-connector.md) em execução no núcleo.
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Largura máxima de banda**
Nome do parâmetro: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH`
A média da largura máxima de banda (em kilobits por segundo) que pode ser usada para exportar dados. O padrão permite o uso ilimitado da largura de banda disponível.
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Tamanho do grupo de threads**
Nome do parâmetro: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE`
O número máximo de threads ativos que podem ser usados para exportar dados. O padrão é `5`.
O tamanho ideal depende do hardware, do volume do fluxo e do número planejado de fluxos de exportação. Se a velocidade de exportação for lenta, será possível ajustar essa configuração para encontrar o tamanho ideal para seu hardware e caso de negócios. A CPU e a memória do hardware do dispositivo de núcleo são fatores limitantes. Para iniciar, você pode tentar definir esse valor igual ao número de núcleos do processador no dispositivo.
Tenha cuidado para não definir um tamanho superior ao que o seu hardware pode suportar. Cada fluxo consome recursos de hardware, portanto, você deve tentar limitar o número de fluxos de exportação em dispositivos restritos.
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Argumentos JVM**
Nome do parâmetro: `JVM_ARGS`
Argumentos personalizados da Java Virtual Machine para passar para o gerenciador de fluxo na startup. Se houver vários argumentos, separe-os por espaços.
Só use esse parâmetro quando precisar substituir as configurações padrão usadas pela JVM. Por exemplo, talvez seja necessário aumentar o tamanho do heap padrão caso você planeje exportar um grande número de fluxos.
Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
**Diretórios de arquivos de entrada somente leitura**
Nome do parâmetro: `STREAM_MANAGER_READ_ONLY_DIRS`
Uma lista separada por vírgulas de caminhos absolutos para os diretórios fora do sistema de arquivos raiz que armazenam arquivos de entrada. O gerenciador de fluxo lê e carrega os arquivos no Amazon S3 e monta os diretórios como somente leitura. Para obter mais informações, sobre como exportar para o Amazon S3, consulte [Objetos do Amazon S3](stream-export-configurations.md#export-to-s3).
Use esse parâmetro somente se as condições a seguir forem verdadeiras:
+ O diretório de arquivos de entrada de um fluxo que exporta para o Amazon S3 está em um dos seguintes locais:
+ Uma partição diferente do sistema de arquivos raiz.
+ Em `/tmp` no sistema de arquivos raiz.
+ A [conteinerização padrão](lambda-group-config.md#lambda-containerization-groupsettings) do grupo Greengrass é o **contêiner Greengrass**.
Valor de exemplo: `/mnt/directory-1,/mnt/directory-2,/tmp`
Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
**Tamanho mínimo para upload de várias partes**
Nome do parâmetro: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES`
O tamanho mínimo (em bytes) de uma parte em um upload multiparte para o Amazon S3. O gerenciador de fluxo usa essa configuração e o tamanho do arquivo de entrada para determinar como agrupar dados em lote em uma solicitação PUT de várias partes. O valor mínimo e padrão é de `5242880` bytes (5 MB).
O gerenciador de fluxo usa a propriedade `sizeThresholdForMultipartUploadBytes` do fluxo para determinar se deve exportar para o Amazon S3 como um upload de uma ou várias partes. As funções do Lambda definidas pelo usuário definem esse limite quando criam um fluxo que exporta para o Amazon S3. O limite padrão é 5 MB.
Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
## Definir configurações do gerenciador de fluxo (console)
Você pode usar o AWS IoT console para as seguintes tarefas de gerenciamento:
+ [Verificar se o gerenciador de fluxo está habilitado](#check-stream-manager-console)
+ [Habilitar ou desabilitar o gerenciador de fluxo durante a criação do grupo](#enable-stream-manager-console-new-group)
+ [Habilitar ou desabilitar o gerenciador de fluxo para um grupo existente](#enable-stream-manager-console-existing-group)
+ [Alterar configurações do gerenciador de fluxo](#change-stream-manager-console)
As alterações entram em vigor após a implantação do grupo do Greengrass. Para ver um tutorial que mostra como implantar um grupo do Greengrass que contém uma função do Lambda que interage com o gerenciador de fluxo, consulte [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.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.
### Para verificar se o gerenciador de fluxo está habilitado (console)
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. Selecione a guia **Funções do Lambda**.
1. Em **Funções do Lambda do sistema**, selecione **Gerenciador de fluxo** e selecione **Editar**.
1. Verifique o status ativado ou desativado. Todas as configurações personalizadas do gerenciador de fluxo que estão definidas também são exibidas.
### Para habilitar ou desabilitar o gerenciador de fluxo durante a criação do grupo (console)
1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1).
1. Selecione **Create Group**. Sua selecione na próxima página determina a configuração do gerenciador de fluxo para o grupo.
1. Vá até a seção **Nomeie seu grupo** e selecione as páginas de **Núcleo do Greengrass**.
1. Selecione **Criar grupo**.
1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**, selecione **Gerenciador de fluxo** e selecione **Editar**.
+ Para habilitar o gerenciador de fluxo com configurações padrão, selecione **Habilitar com definições padrão**.
+ Para habilitar o gerenciador de fluxo com configurações personalizadas, selecione **Customize settings (Personalizar configurações)**.
1. Na página **Configurar gerenciador de fluxo**, selecione **Habilitar**.
1. Em **Custom settings (Configurações personalizadas)**, insira os valores para os parâmetros do gerenciador de fluxo. Para obter mais informações, consulte [Parâmetros do gerenciador de fluxo](#stream-manager-parameters). Deixe os campos vazios para AWS IoT Greengrass permitir o uso de seus valores padrão.
+ Para desativar o gerenciador de fluxo, selecione **Desativar**.
1. Na página **Configure stream manager (Configurar gerenciador de fluxo)** selecione **Disable (Desabilitar)**.
1. Selecione **Salvar**.
1. Continue nas páginas restantes para criar seu grupo.
1. Na página **Dispositivos cliente**, faça download dos recursos de segurança, reveja as informações e, em seguida selecione **Concluir**.
**nota**
Quando o gerenciador de fluxo estiver habilitado, [instale o Java 8 Runtime](stream-manager.md#stream-manager-requirements) no dispositivo de núcleo antes de implantar o grupo.
### Para habilitar ou desabilitar o gerenciador de fluxo para um grupo existente (console)
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. Selecione a guia **Funções do Lambda**.
1. Em **Funções do Lambda do sistema**, selecione **Gerenciador de fluxo** e selecione **Editar**.
1. Verifique o status ativado ou desativado. Todas as configurações personalizadas do gerenciador de fluxo que estão definidas também são exibidas.
### Para alterar as configurações do gerenciador de fluxo (console)
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. Selecione a guia **Funções do Lambda**.
1. Em **Funções do Lambda do sistema**, selecione **Gerenciador de fluxo** e selecione **Editar**.
1. Verifique o status ativado ou desativado. Todas as configurações personalizadas do gerenciador de fluxo que estão definidas também são exibidas.
1. Selecione **Salvar**.
## Definir configurações do gerenciador de fluxo (CLI)
No AWS CLI, use a função `GGStreamManager` Lambda do sistema para configurar o gerenciador de streams. As funções do System Lambda são componentes do software AWS IoT Greengrass Core. Para o gerenciador de fluxo e algumas outras funções do Lambda do sistema, você pode configurar a funcionalidade do Greengrass gerenciando os objetos `Function` e `FunctionDefinitionVersion` correspondentes no grupo Greengrass. Para obter mais informações, consulte [Visão geral do modelo de objeto de AWS IoT Greengrass grupo](deployments.md#api-overview).
É possível usar a API para as seguintes tarefas de gerenciamento. Os exemplos nesta seção mostram como usar o AWS CLI, mas você também pode chamar a AWS IoT Greengrass API diretamente ou usar um AWS SDK.
+ [Verificar se o gerenciador de fluxo está habilitado](#check-stream-manager-cli)
+ [Habilitar, desabilitar ou definir configurações do gerenciador de fluxo](#enable-stream-manager-cli)
As alterações entrarão em vigor após a implantação do grupo. Para ver um tutorial que mostra como implantar um grupo do Greengrass com uma função do Lambda que interage com o gerenciador de fluxo, consulte [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md).
**dica**
Para analisar se o gerenciador de fluxo está habilitado e em execução, você pode executar o comando a seguir em um terminal no seu dispositivo de núcleo.
```
ps aux | grep -i 'streammanager'
```
### Para verificar se o gerenciador de fluxo está habilitado (CLI)
O gerenciador de fluxo será habilitado se a versão de definição de função implantada incluir a função do Lambda do sistema `GGStreamManager`. Para verificar, faça o seguinte;
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 os valores `Id` e `LatestVersion` do grupo de destino na saída.
1. Obtenha a versão do grupo mais recente.
+ Substitua *group-id* pelo `Id` que você copiou.
+ Substitua *latest-group-version-id* pelo `LatestVersion` que você copiou.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. `FunctionDefinitionVersionArn`Na saída, obtenha a definição IDs da função e a versão da definição da função.
+ O ID de definição de função é o GUID que segue o segmento `functions` no nome do recurso da Amazon (ARN).
+ O ID de versão de definição de função é o GUID que segue o segmento `versions` no ARN.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/function-definition-id/versions/function-definition-version-id
```
1. Obtenha o ID da versão de definição de função.
+ *function-definition-id*Substitua pelo ID da definição da função.
+ *function-definition-version-id*Substitua pelo ID da versão da definição da função.
```
aws greengrass get-function-definition-version \
--function-definition-id function-definition-id \
--function-definition-version-id function-definition-version-id
```
Se a matriz `functions` na saída incluir a função `GGStreamManager`, o gerenciador de fluxo será habilitado. Quaisquer variáveis de ambiente definidas para a função representam configurações personalizadas para o gerenciador de fluxo.
### Habilitar, desabilitar ou definir as configurações do gerenciador de fluxo (CLI)
No AWS CLI, use a função `GGStreamManager` Lambda do sistema para configurar o gerenciador de streams. As alterações entrarão em vigor após a implantação do grupo.
+ Para habilitar o gerenciador de fluxo, inclua `GGStreamManager` na matriz `functions` da sua versão de definição de função. Para definir configurações personalizadas, defina variáveis de ambiente para os [parâmetros correspondentes do gerenciador de fluxo](#stream-manager-parameters).
+ Para desabilitar o gerenciador de fluxo, remova `GGStreamManager` da matriz `functions` da sua versão de definição de função.
** gerenciador de fluxo com configurações padrão**
O exemplo de configuração a seguir habilita o gerenciador de fluxo com configurações padrão. Ele define o ID da função arbitrária como `streamManager`.
```
{
"FunctionArn": "arn:aws:lambda:::function:GGStreamManager:1",
"FunctionConfiguration": {
"MemorySize": 4194304,
"Pinned": true,
"Timeout": 3
},
"Id": "streamManager"
}
```
Para as propriedades `FunctionConfiguration`, talvez você saiba o seguinte:
+ `MemorySize` está definido para 4194304 KB (4 GB) com as configurações padrão. Sempre há a possibilidade de alterar esse valor. É recomendável definir o `MemorySize` para pelo menos 128000 KB.
+ `Pinned` deve ser definido como `true`.
+ O `Timeout` é exigido pela versão de definição de função, mas o `GGStreamManager` não o utiliza.
** gerenciador de fluxo com configurações personalizadas**
O exemplo de configuração a seguir habilita o gerenciador de fluxo com os valores personalizados para o diretório de armazenamento, a porta do servidor e os parâmetros de tamanho do grupo de threads.
```
{
"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 usa valores padrão para [parâmetros do gerenciador de fluxo](#stream-manager-parameters) que não são especificados como variáveis de ambiente.
**Gerenciador de fluxo com configurações personalizadas para exportações do Amazon S3**
O exemplo de configuração a seguir habilita o gerenciador de fluxo com valores personalizados para o diretório de upload e com parâmetros mínimos de tamanho de upload de várias partes.
```
{
"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"
}
```
**Habilitar, desabilitar ou definir as configurações do gerenciador de fluxo (CLI)**
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 os valores `Id` e `LatestVersion` do grupo de destino na saída.
1. Obtenha a versão do grupo mais recente.
+ Substitua *group-id* pelo `Id` que você copiou.
+ Substitua *latest-group-version-id* pelo `LatestVersion` que você copiou.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Copie a `CoreDefinitionVersionArn` e todas as outras versões ARNs da saída, exceto`FunctionDefinitionVersionArn`. Você usa esses valores ao criar uma nova versão do grupo.
1. No `FunctionDefinitionVersionArn` na saída, copie o ID da definição de função. O ID é o GUID que segue o segmento `functions` no ARN, conforme mostrado no exemplo a seguir.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**nota**
Ou você pode criar uma definição de função executando o comando [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) e copiar o ID da saída.
1. Adicione uma versão de definição de função à definição da função.
+ *function-definition-id*Substitua pelo `Id` que você copiou para a definição da função.
+ Na matriz `functions`, inclua todas as outras funções que você deseja disponibilizar no núcleo do Greengrass. Você pode usar o comando `get-function-definition-version` para obter a lista de funções existentes.
**Habilitar o gerenciador de fluxo com configurações padrão**
O exemplo a seguir habilita o gerenciador de fluxo, incluindo a função `GGStreamManager`, na matriz `functions`. Este exemplo usa valores padrão para os [parâmetros do gerenciador de fluxo](#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
]
}'
```
A função `myLambdaFunction` nos exemplos representa uma de suas funções do Lambda definidas pelo usuário.
**Habilitar o gerenciador de fluxo com configurações personalizadas**
O exemplo a seguir habilita o gerenciador de fluxo, incluindo a função `GGStreamManager`, na matriz `functions`. Todas as configurações do gerenciador de fluxo são opcionais, a menos que você queira alterar os valores padrão. Este exemplo mostra como usar variáveis de ambiente para definir valores personalizados.
```
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
]
}'
```
Para as propriedades `FunctionConfiguration`, talvez você saiba o seguinte:
+ `MemorySize` está definido para 4194304 KB (4 GB) com as configurações padrão. Sempre há a possibilidade de alterar esse valor. É recomendável definir o `MemorySize` para pelo menos 128000 KB.
+ `Pinned` deve ser definido como `true`.
+ O `Timeout` é exigido pela versão de definição de função, mas o `GGStreamManager` não o utiliza.
**Desabilitar o gerenciador de fluxo**
O exemplo a seguir omite a função `GGStreamManager`, que desabilita o gerenciador de fluxo.
```
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 não quiser implantar nenhuma função do Lambda, você poderá omitir completamente a versão de definição de função.
1. Copie o `Arn` da versão da definição de função da saída.
1. Crie uma versão do grupo que contém a função do Lambda definida pelo sistema.
+ *group-id*Substitua `Id` pelo para o grupo.
+ *core-definition-version-arn*Substitua pelo `CoreDefinitionVersionArn` que você copiou da versão mais recente do grupo.
+ *function-definition-version-arn*Substitua pelo `Arn` que você copiou para a nova versão de definição de função.
+ Substitua o ARNs por outros componentes do grupo (por exemplo, `SubscriptionDefinitionVersionArn` ou`DeviceDefinitionVersionArn`) que você copiou da versão mais recente do grupo.
+ Remova todos os parâmetros inutilizados. Por exemplo, remova a versão `--resource-definition-version-arn` caso a versão do grupo não contenha recursos.
```
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. Copie a `Version` da saída. Este é o ID da nova versão do grupo.
1. Implante o grupo com a nova versão do grupo.
+ *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 \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Siga este procedimento se quiser editar as configurações do gerenciador de fluxo posteriormente. Assegure-se de criar uma versão de definição de função que inclua a função do `GGStreamManager` com a configuração atualizada. A versão do grupo deve fazer referência a todas as versões do componente ARNs que você deseja implantar no núcleo. As alterações entrarão em vigor após a implantação do 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)
+ [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.md)
+ [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md)
# Use StreamManagerClient para trabalhar com streams
As funções Lambda definidas pelo usuário em execução no AWS IoT Greengrass núcleo podem usar `StreamManagerClient` o objeto no SDK [principal para criar fluxos AWS IoT Greengrass no](lambda-functions.md#lambda-sdks) gerenciador de fluxos e, [em seguida, interagir](stream-manager.md) com os fluxos. Quando uma função Lambda cria um fluxo, ela define os Nuvem AWS destinos, a priorização e outras políticas de exportação e retenção de dados para o fluxo. Para enviar dados para o gerenciador de fluxo, as funções do Lambda anexam os dados ao fluxo. Se um destino de exportação for definido para o fluxo, o gerenciador de fluxo exportará o fluxo automaticamente.
**nota**
Normalmente, os clientes do gerenciador de fluxo são funções do Lambda definidas pelo usuário. Se o seu caso de negócios exigir, você também pode permitir que os processos não Lambda sendo executados no núcleo do Greengrass (por exemplo, um contêiner do Docker) interajam com o gerenciador de fluxo. Para obter mais informações, consulte [Autenticação de cliente](stream-manager.md#stream-manager-security-client-authentication).
Os snippets neste tópico mostram como os clientes chamam o `StreamManagerClient` para trabalhar com fluxos. Para obter detalhes de implementação sobre os métodos e seus argumentos, use os links para a referência do SDK listada após cada snippet. Para tutoriais que incluem uma função do Lambda em Python completa, consulte [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.md) ou [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md).
Você deve instanciar sua função do Lambda `StreamManagerClient` fora do manipulador de funções. Se instanciado no manipulador, a função cria um `client` e uma conexão para o gerenciador de fluxo sempre que for invocado.
**nota**
Se você instanciar `StreamManagerClient` no manipulador, você deve chamar explicitamente o método `close()` quando o `client` concluir seu trabalho. Caso contrário, o `client` mantém a conexão aberta e outro thread em execução até que o script seja encerrado.
`StreamManagerClient` comporta as operações a seguir:
+ [Criar stream de mensagens](#streammanagerclient-create-message-stream)
+ [Anexar mensagem](#streammanagerclient-append-message)
+ [Ler Mensagens](#streammanagerclient-read-messages)
+ [Listar fluxos](#streammanagerclient-list-streams)
+ [Descrever stream de mensagens](#streammanagerclient-describe-message-stream)
+ [Atualize o fluxo de mensagens](#streammanagerclient-update-message-stream)
+ [Excluir stream de mensagens](#streammanagerclient-delete-message-stream)
## Criar stream de mensagens
Para criar um fluxo, uma função do Lambda definida pelo usuário chama o método create e passa em um objeto `MessageStreamDefinition`. Esse objeto especifica o nome exclusivo do fluxo e define como o gerenciador de fluxo deve lidar com novos dados quando o tamanho máximo do fluxo for atingido. Você pode usar `MessageStreamDefinition` e os tipos de dados (como `ExportDefinition`, `StrategyOnFull` e `Persistence`) para definir outras propriedades de fluxo. Isso inclui:
+ O destino AWS IoT Analytics, Kinesis Data AWS IoT SiteWise Streams e Amazon S3, destinos para exportações automáticas. Para obter mais informações, consulte [Configurações de exportação para destinos compatíveis Nuvem AWS](stream-export-configurations.md).
+ Prioridade da exportação. O gerenciador de fluxo exporta fluxos de prioridade mais alta antes de fluxos de prioridade mais baixa.
+ Tamanho máximo do lote e intervalo de lote para AWS IoT Analytics Kinesis Data Streams e destinos AWS IoT SiteWise . O gerenciador de fluxo exporta mensagens quando qualquer condição é atendida.
+ Time-to-live (TTL). O tempo necessário para garantir que os dados de fluxo estejam disponíveis para processamento. Você deve certificar-se de que os dados podem ser consumidos nesse período de tempo. Esta não é uma política de exclusão. Os dados podem não ser excluídos imediatamente após o período de TTL.
+ Persistência do fluxo. Selecione salvar fluxos no sistema de arquivos para persistir os dados nas reinicializações do núcleo ou salve os fluxos na memória.
+ Número de sequência inicial. Especifique o número de sequência da mensagem a ser usada como mensagem inicial na exportação.
Para obter mais informações sobre `MessageStreamDefinition`, consulte a referência do SDK para a sua linguagem de destino:
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)no Java SDK
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)no SDK do Node.js
+ [MessageStreamDefinition](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.MessageStreamDefinition)no SDK do Python
**nota**
O `StreamManagerClient` também fornece um destino alvo que você pode usar para exportar fluxos para um servidor HTTP. Este destino deve ser usado apenas para fins de teste. Ele não é estável e nem compatível para uso em ambientes de produção.
Depois que um fluxo é criado, suas funções do Lambda podem [anexar mensagens](#streammanagerclient-append-message) ao fluxo para enviar dados para exportação e [ler mensagens](#streammanagerclient-append-message) do fluxo para processamento local. O número de fluxos criados depende dos seus recursos de hardware e caso de negócios. Uma estratégia é criar um stream para cada canal de destino no stream AWS IoT Analytics de dados do Kinesis, embora você possa definir vários destinos para um stream. Um fluxo tem longa duração.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**nota**
A criação de streams com um destino de exportação AWS IoT SiteWise ou do Amazon S3 tem os seguintes requisitos:
Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Exemplos
O snippet a seguir cria um fluxo chamado `StreamName`. Ele define as propriedades de fluxo em `MessageStreamDefinition` e nos tipos de dados subordinados.
------
#### [ 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 Nuvem 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.
```
[Referência do SDK do 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 Nuvem AWS.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3TaskExecutor(null)
)
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Referência do SDK Java: \$1 [createMessageStream[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#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)
------
#### [ 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 Nuvem 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.
});
```
Referência do SDK do 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)
------
Para obter mais informações sobre como configurar destinos de exportação, consulte [Configurações de exportação para destinos compatíveis Nuvem AWS](stream-export-configurations.md).
## Anexar mensagem
Para enviar dados ao gerenciador de fluxo para exportação, suas funções do Lambda anexam os dados ao fluxo de destino. O destino da exportação determina o tipo de dados a ser passado para esse método.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
**nota**
Anexar mensagens a um destino de exportação AWS IoT SiteWise ou ao Amazon S3 tem os seguintes requisitos:
Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Exemplos
#### AWS IoT Analytics ou destinos de exportação do Kinesis Data Streams
O snippet a seguir anexa uma mensagem ao fluxo chamado `StreamName`. Para AWS IoT Analytics nossos destinos do Kinesis Data Streams, suas funções Lambda acrescentam um blob de dados.
Esse snippet tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: 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.
```
Referência do SDK em Python: [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.
}
```
Referência do SDK em Java: [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.
});
```
Referência do SDK em Node.js: [appendMessage](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### AWS IoT SiteWise destinos de exportação
O snippet a seguir anexa uma mensagem ao fluxo chamado `StreamName`. Para AWS IoT SiteWise destinos, suas funções do Lambda acrescentam um objeto serializado. `PutAssetPropertyValueEntry` Para obter mais informações, consulte [Exportando para AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise).
**nota**
Quando você envia dados para AWS IoT SiteWise, seus dados devem atender aos requisitos da `BatchPutAssetPropertyValue` ação. Para obter mais informações, consulte [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) na *Referência de APIs do AWS IoT SiteWise *.
Esse snippet tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
+ Versão mínima AWS IoT Greengrass do SDK principal: 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.
```
[Referência do SDK do 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.
}
```
Referência do SDK Java: [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.
});
```
Referência do SDK do 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)
------
#### Destinos de exportação do Amazon S3
O snippet a seguir anexa uma tarefa de exportação ao fluxo chamada `StreamName`. Para destinos do Amazon S3, suas funções do Lambda anexam um objeto `S3ExportTaskDefinition` serializado que contém informações sobre o arquivo de entrada de origem e o objeto do Amazon S3 de destino. Se o objeto especificado não existir, o gerenciador de fluxo criará o objeto para você. Para obter mais informações, consulte [Exportar para o Amazon S3](stream-export-configurations.md#export-streams-to-s3).
Esse snippet tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
+ Versão mínima AWS IoT Greengrass do SDK principal: 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.
}
```
[Referência do SDK Java: [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.
});
```
[Referência do SDK do 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)
------
## Ler Mensagens
Ler mensagens de um fluxo.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Exemplos
O snippet a seguir lê mensagens do fluxo chamado `StreamName`. O método de leitura usa um objeto `ReadMessagesOptions` opcional que especifica o número de sequência a partir do qual começar a ler, os números mínimo e máximo a ler e um tempo limite para ler mensagens.
------
#### [ 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.
```
[Referência do SDK do 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.
}
```
Referência do SDK Java: [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.
});
```
Referência do SDK do 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)
------
## Listar fluxos
Obtenha a lista de fluxos no gerenciador de fluxos.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Exemplos
O snippet a seguir obtém uma lista dos fluxos (por nome) no gerenciador de fluxo.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_names = client.list_streams()
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Referência do SDK em 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.
}
```
Referência do SDK em Java: [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.
});
```
Referência do SDK em Node.js: [listStreams](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams)
------
## Descrever stream de mensagens
Obtenha metadados sobre um fluxo, incluindo a definição, o tamanho e o status de exportação do fluxo.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Exemplos
O snippet a seguir obtém metadados sobre o fluxo chamado `StreamName`, incluindo a definição, o tamanho e o status do exportador do fluxo.
------
#### [ 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.
```
Referência do SDK em 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.
}
```
Referência do 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.
});
```
Referência do SDK do Node.js: [describeMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream)
------
## Atualize o fluxo de mensagens
Atualize as propriedades de um fluxo existente. Talvez você queira atualizar um fluxo se seus requisitos mudarem após a criação do fluxo. Por exemplo:
+ Adicione uma nova [configuração de exportação](stream-export-configurations.md) para um Nuvem AWS destino.
+ Aumente o tamanho máximo de um fluxo para alterar a forma como os dados são exportados ou retidos. Por exemplo, o tamanho do fluxo em combinação com sua estratégia em configurações completas pode resultar na exclusão ou rejeição dos dados antes que o gerenciador de fluxo possa processá-los.
+ Pause e retome as exportações; por exemplo, se as tarefas de exportação forem demoradas e você quiser racionar seus dados de upload.
Suas funções do Lambda seguem esse processo de alto nível para atualizar um fluxo:
1. [Obter a descrição do fluxo.](#streammanagerclient-describe-message-stream)
1. Atualizar as propriedades de destino nos objetos correspondentes `MessageStreamDefinition` e subordinados.
1. Passar o atualizado `MessageStreamDefinition`. Certifique-se de incluir as definições completas do objeto para o fluxo atualizado. As propriedades indefinidas revertem para os valores padrão.
Você pode especificar o número de sequência da mensagem a ser usada como mensagem inicial na exportação.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.11.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.6.0 \$1 Java: 1.5.0 \$1 Node.js: 1.7.0
### Exemplos
O snippet a seguir atualiza o fluxo chamado `StreamName`. Ele atualiza várias propriedades de um fluxo que é exportado para o 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.
```
Referência do SDK do Python: \$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 Nuvem 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.
}
```
Referência do SDK Java: [update\$1message\$1stream](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$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 {
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 Nuvem 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.
});
```
Referência do SDK do Node.js: \$1 [updateMessageStream[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#updateMessageStream)
------
### Restrições para a atualização de fluxos
As restrições a seguir se aplicam ao atualizar fluxos. A menos que indicado na lista a seguir, as atualizações entrarão em vigor imediatamente.
+ Não é possível atualizar a persistência de um fluxo. Para alterar esse comportamento, [exclua o fluxo](#streammanagerclient-delete-message-stream) e [crie um fluxo](#streammanagerclient-create-message-stream) que defina a nova política de persistência.
+ Você só pode atualizar o tamanho máximo de um fluxo sob as seguintes condições:
+ O tamanho máximo deve ser maior que o tamanho atual do fluxo. Para encontrar essas informações, [descreva o fluxo](#streammanagerclient-describe-message-stream) e, em seguida, verifique o status de armazenamento do objeto `MessageStreamInfo` retornado.
+ O tamanho máximo deve ser maior ou igual ao tamanho do segmento do fluxo.
+ Você pode atualizar o tamanho do segmento do fluxo para um valor menor que o tamanho máximo do fluxo. A configuração atualizada se aplica aos novos segmentos.
+ As atualizações da propriedade tempo de vida (TTL) se aplicam às novas operações de anexação. Se você diminuir esse valor, o gerenciador de fluxo também poderá excluir segmentos existentes que excedam o TTL.
+ As atualizações da estratégia em toda a propriedade se aplicam às novas operações de anexação. Se você definir a estratégia para substituir os dados mais antigos, o gerenciador de fluxo também poderá substituir os segmentos existentes com base na nova configuração.
+ As atualizações na propriedade “descartar após gravação” se aplicam às novas mensagens.
+ As atualizações nas configurações de exportação se aplicam às novas exportações. A solicitação de atualização deve incluir todas as configurações de exportação às quais você deseja oferecer suporte. Caso contrário, o gerenciador de fluxo as excluirá.
+ Ao atualizar uma configuração de exportação, especifique o identificador da configuração de exportação de destino.
+ Para adicionar uma configuração de exportação, especifique um identificador exclusivo para a nova configuração de exportação.
+ Para excluir uma configuração de exportação, omita a configuração de exportação.
+ Para [atualizar](#streammanagerclient-update-message-stream) o número da sequência inicial de uma configuração de exportação em um fluxo, você deve especificar um valor menor que o número de sequência mais recente. Para encontrar essas informações, [descreva o fluxo](#streammanagerclient-describe-message-stream) e, em seguida, verifique o status de armazenamento do objeto `MessageStreamInfo` retornado.
## Excluir stream de mensagens
Exclui um fluxo. Quando você exclui um fluxo, todos os dados armazenados para o fluxo são excluídos do disco.
### Requisitos
Essa operação tem os seguintes requisitos:
+ Versão mínima AWS IoT Greengrass do núcleo: 1.10.0
+ Versão mínima AWS IoT Greengrass do SDK principal: Python: 1.5.0 \$1 Java: 1.4.0 \$1 Node.js: 1.6.0
### Exemplos
O snippet a seguir exclui o fluxo chamado `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.
```
Referência do SDK do 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.
}
```
Referência do SDK em Java: [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.
});
```
Referência do SDK do Node.js: [deleteMessageStream](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream)
------
## 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)
+ [Configurações de exportação para destinos compatíveis Nuvem AWS](stream-export-configurations.md)
+ [Exportar fluxos de dados para o Nuvem AWS (console)](stream-manager-console.md)
+ [Exportar fluxos de dados para o Nuvem AWS (CLI)](stream-manager-cli.md)
+ `StreamManagerClient`na referência do SDK AWS IoT Greengrass principal:
+ [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)
# Configurações de exportação para destinos compatíveis Nuvem AWS
As funções Lambda definidas pelo usuário são `StreamManagerClient` usadas no SDK principal para interagir com AWS IoT Greengrass o gerenciador de streams. Quando uma função do Lambda [cria um fluxo](work-with-streams.md#streammanagerclient-create-message-stream) ou [atualiza um fluxo](work-with-streams.md#streammanagerclient-create-message-stream), ela passa um objeto `MessageStreamDefinition` que representa as propriedades do fluxo, incluindo a definição de exportação. O objeto `ExportDefinition` contém as configurações de exportação definidas para o fluxo. O gerenciador de fluxo usa essas configurações de exportação para determinar onde e como exportar o fluxo.
![\[Diagrama do modelo de objeto do tipo de ExportDefinition propriedade.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/stream-manager-exportconfigs.png)
É possível definir zero ou mais configurações de exportação em um fluxo, incluindo várias configurações de exportação para um único tipo de destino. Por exemplo, você pode exportar um fluxo para dois canais do AWS IoT Analytics e um fluxo de dados do Kinesis.
Para tentativas de exportação malsucedidas, o gerenciador de fluxo tenta continuamente exportar dados para a Nuvem AWS em intervalos de até cinco minutos. Não há um limite máximo para o número de novas tentativas.
**nota**
O `StreamManagerClient` também fornece um destino alvo que você pode usar para exportar fluxos para um servidor HTTP. Este destino deve ser usado apenas para fins de teste. Ele não é estável e nem compatível para uso em ambientes de produção.
**Topics**
+ [AWS IoT Analytics canais](#export-to-iot-analytics)
+ [Amazon Kinesis Data Streams](#export-to-kinesis)
+ [AWS IoT SiteWise propriedades do ativo](#export-to-iot-sitewise)
+ [Objetos do Amazon S3](#export-to-s3)
Você é responsável pela manutenção desses Nuvem AWS recursos.
## AWS IoT Analytics canais
O gerenciador de fluxo suporta exportações automáticas para AWS IoT Analytics. AWS IoT Analytics permite realizar análises avançadas em seus dados para ajudar a tomar decisões comerciais e melhorar os modelos de aprendizado de máquina. Para obter mais informações, consulte [O que é AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) no *Guia do AWS IoT Analytics usuário*.
No SDK AWS IoT Greengrass principal, suas funções do Lambda usam `IoTAnalyticsConfig` o para definir a configuração de exportação para esse tipo de destino. Para mais informações, consulte a referência do SDK para seu idioma de destino:
+ [Io TAnalytics Config no SDK](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTAnalyticsConfig) do Python
+ [Io TAnalytics Config no Java](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) SDK
+ [Io TAnalytics Config no SDK](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) do Node.js
### Requisitos
Esse destino de exportação tem os seguintes requisitos:
+ Os canais-alvo AWS IoT Analytics devem estar no mesmo Conta da AWS grupo e Região da AWS no grupo Greengrass.
+ O [Função do grupo do Greengrass.](group-role.md) deve conceder a permissão `iotanalytics:BatchPutMessage` para os canais de destino. Por exemplo:
------
#### [ 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"
]
}
]
}
```
------
É possível conceder acesso granular ou condicional aos recursos, por exemplo, usando um esquema de nomeação `*` curinga. Para obter mais informações, consulte [Adicionando e removendo políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.
### Exportando para AWS IoT Analytics
Para criar um fluxo que exporta para AWS IoT Analytics, suas funções do Lambda [criam um fluxo](work-with-streams.md#streammanagerclient-create-message-stream) com uma definição de exportação que inclui um ou mais `IoTAnalyticsConfig` objetos. Esse objeto define as configurações de exportação, como canal de destino, tamanho do lote, intervalo do lote e prioridade.
Quando suas funções do Lambda recebem dados de dispositivos, elas [acrescentam mensagens](work-with-streams.md#streammanagerclient-append-message) que contêm um blob de dados ao fluxo de destino.
Em seguida, o gerenciador de fluxo exporta os dados com base nas configurações de lote e na prioridade definidas nas configurações de exportação do fluxo.
## Amazon Kinesis Data Streams
O gerenciador de fluxos é compatível com exportações automáticas para o Amazon Kinesis Data Streams. O Kinesis Data Streams é comumente usado para agregar dados de alto volume e carregá-los em um data warehouse ou cluster de redução de mapas. Para obter mais informações, consulte [O que é o Amazon Kinesis Data Streams?](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) no *Guia do desenvolvedor do Amazon Kinesis*.
No SDK AWS IoT Greengrass principal, suas funções do Lambda usam `KinesisConfig` o para definir a configuração de exportação para esse tipo de destino. Para mais informações, consulte a referência do SDK para seu idioma de destino:
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.KinesisConfig)no SDK do Python
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)no Java SDK
+ [KinesisConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)no SDK do Node.js
### Requisitos
Esse destino de exportação tem os seguintes requisitos:
+ Os streams de destino no Kinesis Data Streams devem estar no mesmo grupo Conta da AWS e no grupo Greengrass Região da AWS .
+ O [Função do grupo do Greengrass.](group-role.md) deve conceder a permissão `kinesis:PutRecords` para os fluxos de dados de destino. Por exemplo:
------
#### [ 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"
]
}
]
}
```
------
É possível conceder acesso granular ou condicional aos recursos, por exemplo, usando um esquema de nomeação `*` curinga. Para obter mais informações, consulte [Adicionando e removendo políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.
### Exportação do Kinesis Data Streams
Para criar um fluxo que exporte para o Kinesis Data Streams, suas funções do Lambda [criam um fluxo](work-with-streams.md#streammanagerclient-create-message-stream) com uma definição de exportação que inclui um ou mais objetos `KinesisConfig`. Esse objeto define as configurações de exportação, como fluxo de dados, tamanho do lote, intervalo do lote e prioridade.
Quando suas funções do Lambda recebem dados de dispositivos, elas [acrescentam mensagens](work-with-streams.md#streammanagerclient-append-message) que contêm um blob de dados ao fluxo de destino. Em seguida, o gerenciador de fluxo exporta os dados com base nas configurações de lote e na prioridade definidas nas configurações de exportação do fluxo.
O gerenciador de fluxo gera uma UUID exclusiva e aleatória como chave de partição para cada registro carregado no Amazon Kinesis.
## AWS IoT SiteWise propriedades do ativo
O gerenciador de fluxo suporta exportações automáticas para AWS IoT SiteWise. AWS IoT SiteWise permite coletar, organizar e analisar dados de equipamentos industriais em grande escala. Para obter mais informações, consulte [O que é AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) no *Guia do AWS IoT SiteWise usuário*.
No SDK AWS IoT Greengrass principal, suas funções do Lambda usam `IoTSiteWiseConfig` o para definir a configuração de exportação para esse tipo de destino. Para mais informações, consulte a referência do SDK para seu idioma de destino:
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.IoTSiteWiseConfig) no SDK do Python
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) no Java SDK
+ [Io TSite WiseConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) no SDK do Node.js
**nota**
AWS também fornece o[Conector IoT SiteWise](iot-sitewise-connector.md), que é uma solução pré-construída que você pode usar com fontes OPC-UA.
### Requisitos
Esse destino de exportação tem os seguintes requisitos:
+ As propriedades do ativo alvo em AWS IoT SiteWise devem estar no mesmo Conta da AWS grupo e Região da AWS no grupo Greengrass.
**nota**
Para ver a lista de regiões que AWS IoT SiteWise oferecem suporte, consulte [AWS IoT SiteWise endpoints e cotas](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region) na Referência *AWS geral*.
+ O [Função do grupo do Greengrass.](group-role.md) deve conceder a permissão `iotsitewise:BatchPutAssetPropertyValue` para as propriedades do ativo do destino. O exemplo de política a seguir usa a chave de condição `iotsitewise:assetHierarchyPath` para conceder acesso a um ativo raiz de destino e seus ativos secundários. Você pode remover o `Condition` da política para permitir o acesso a todos os seus AWS IoT SiteWise ativos ou especificar ARNs ativos individuais.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
É possível conceder acesso granular ou condicional aos recursos, por exemplo, usando um esquema de nomeação `*` curinga. Para obter mais informações, consulte [Adicionando e removendo políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.
Para obter informações de segurança importantes, consulte a [ BatchPutAssetPropertyValue autorização](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) no *Guia AWS IoT SiteWise do usuário*.
### Exportando para AWS IoT SiteWise
Para criar um fluxo que exporta para AWS IoT SiteWise, suas funções do Lambda [criam um fluxo](work-with-streams.md#streammanagerclient-create-message-stream) com uma definição de exportação que inclui um ou mais `IoTSiteWiseConfig` objetos. Esse objeto define as configurações de exportação, como tamanho do lote, intervalo do lote e prioridade.
Quando suas funções do Lambda recebem dados de propriedades de ativos de dispositivos, elas anexam mensagens que contêm os dados ao fluxo de destino. As mensagens são objetos `PutAssetPropertyValueEntry` serializados em JSON que contêm valores de propriedade para uma ou mais propriedades de ativos. Para obter mais informações, consulte [Anexar mensagem](work-with-streams.md#streammanagerclient-append-message-sitewise) para destinos de exportação do AWS IoT SiteWise .
**nota**
Quando você envia dados para AWS IoT SiteWise, seus dados devem atender aos requisitos da `BatchPutAssetPropertyValue` ação. Para obter mais informações, consulte [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) na *Referência de APIs do AWS IoT SiteWise *.
Em seguida, o gerenciador de fluxo exporta os dados com base nas configurações de lote e na prioridade definidas nas configurações de exportação do fluxo.
Você pode ajustar as configurações do gerenciador de fluxo e a lógica da função do Lambda para criar sua estratégia de exportação. Por exemplo:
+ Para exportações quase em tempo real, defina configurações baixas de tamanho de lote e intervalo e anexe os dados ao fluxo quando forem recebidos.
+ Para otimizar o agrupamento em lotes, mitigar as restrições de largura de banda ou minimizar os custos, suas funções do Lambda podem agrupar os pontos de dados timestamp-quality-value (TQV) recebidos para uma única propriedade do ativo antes de anexar os dados ao stream. Uma estratégia é agrupar entradas para até 10 (dez) combinações diferentes de propriedade e ativo, ou aliases de propriedade, em uma mensagem, em vez de enviar mais de uma entrada para a mesma propriedade. Isso ajuda o gerenciador de fluxo a permanecer dentro das [cotas do AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html).
## Objetos do Amazon S3
O gerenciador de fluxo é compatível com exportações automáticas para o Amazon S3. É possível utilizar o Amazon S3 para armazenar e recuperar grandes volumes de dados. Para obter mais informações, consulte [O que é o Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) no *Guia do desenvolvedor do Amazon Simple Storage Service*.
No SDK AWS IoT Greengrass principal, suas funções do Lambda usam `S3ExportTaskExecutorConfig` o para definir a configuração de exportação para esse tipo de destino. Para mais informações, consulte a referência do SDK para seu idioma de destino:
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-python/_apidoc/greengrasssdk.stream_manager.data.html#greengrasssdk.stream_manager.data.S3ExportTaskExecutorConfig) no SDK do Python
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) no Java SDK
+ [S3 ExportTaskExecutorConfig](https://aws.github.io/aws-greengrass-core-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) no SDK do Node.js
### Requisitos
Esse destino de exportação tem os seguintes requisitos:
+ Os buckets do Amazon S3 de destino devem estar no mesmo grupo Conta da AWS do Greengrass.
+ Se a [conteinerização padrão](lambda-group-config.md#lambda-containerization-groupsettings) para o grupo do Greengrass for **contêiner do Greengrass**, você deverá definir o parâmetro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories) para usar um diretório de arquivos de entrada que esteja sob `/tmp` ou não faça parte do sistema de arquivos raiz.
+ Se uma função do Lambda em execução no modo de **contêiner do Greengrass** gravar arquivos de entrada no diretório de arquivos de entrada, você deverá criar um recurso de volume local para o diretório e montar o diretório no contêiner com permissões de gravação. Isso garante que os arquivos sejam gravados no sistema de arquivos raiz e sejam visíveis fora do contêiner. Para obter mais informações, consulte [Acesso aos recursos locais com funções e conectores do Lambda](access-local-resources.md).
+ O [Função do grupo do Greengrass.](group-role.md) deve conceder as permissões a seguir para os buckets de destino. Por exemplo:
------
#### [ 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/*"
]
}
]
}
```
------
É possível conceder acesso granular ou condicional aos recursos, por exemplo, usando um esquema de nomeação `*` curinga. Para obter mais informações, consulte [Adicionando e removendo políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.
### Exportar para o Amazon S3
Para criar um fluxo que exporte para o Amazon S3, suas funções do Lambda usam o objeto `S3ExportTaskExecutorConfig` para configurar a política de exportação. A política define as configurações de exportação, como o limite e a prioridade de upload em várias partes. Para exportações do Amazon S3, o gerenciador de fluxo carrega dados que ele lê de arquivos locais no dispositivo principal. Para iniciar um upload, suas funções do Lambda anexam uma tarefa de exportação ao fluxo de destino. A tarefa de exportação contém informações sobre o arquivo de entrada e o objeto de destino do Amazon S3. O gerenciador de fluxo executa tarefas na sequência em que elas são anexadas ao fluxo.
**nota**
O bucket de destino já deve existir no seu Conta da AWS. Se um objeto para a chave especificada não existir, o gerenciador de fluxo criará o objeto para você.
Esse fluxo de alto nível é mostrado no diagrama a seguir.
![\[Diagrama do fluxo de trabalho do gerenciador de fluxo para exportações do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/stream-manager-s3.png)
O gerenciador de fluxo usa a propriedade de limite de upload de várias partes, a configuração do [tamanho mínimo das partes](configure-stream-manager.md#stream-manager-minimum-part-size) e o tamanho do arquivo de entrada para determinar como fazer upload dos dados. O limite de upload de várias partes deve ser maior que o tamanho mínimo das partes. Se você quiser fazer upload de dados em paralelo, pode criar vários fluxos.
As chaves que especificam seus objetos de destino do Amazon S3 podem incluir DateTimeFormatter cadeias de caracteres [Java](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) válidas em espaços reservados. `!{timestamp:value}` É possível usar esses espaços reservados de data e hora para particionar dados no Amazon S3 com base na hora em que os dados do arquivo de entrada foram carregados. Por exemplo, o nome da chave a seguir é resolvido para um valor como `my-key/2020/12/31/data.txt`.
```
my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt
```
**nota**
Se você quiser monitorar o status de exportação de um fluxo, primeiro crie um fluxo de status e, em seguida, configure o fluxo de exportação para usá-lo. Para obter mais informações, consulte [Monitorar tarefas de exportação](#monitor-export-status-s3).
#### Gerenciar dados de entrada
Você pode criar códigos que os aplicativos de IoT usam para gerenciar o ciclo de vida dos dados de entrada. O exemplo de fluxo de trabalho a seguir mostra como você pode usar as funções do Lambda para gerenciar esses dados.
1. Um processo local recebe dados de dispositivos ou periféricos e, em seguida, grava os dados em arquivos em um diretório no dispositivo principal. Esses são os arquivos de entrada para o gerenciador de fluxo.
**nota**
Para determinar se você deve configurar o acesso ao diretório de arquivos de entrada, consulte o parâmetro [STREAM\$1MANAGER\$1READ\$1ONLY\$1DIRS](configure-stream-manager.md#stream-manager-read-only-directories).
O processo no qual o gerenciador de fluxo é executado herda todas as permissões do sistema de arquivos da [identidade de acesso padrão](lambda-group-config.md#lambda-access-identity-groupsettings) do grupo. O gerenciador de fluxo deve ter permissão para acessar os arquivos de entrada. Você pode usar o comando `chmod(1)` para alterar a permissão dos arquivos, se necessário.
1. Uma função do Lambda verifica o diretório e [anexa uma tarefa de exportação](work-with-streams.md#streammanagerclient-append-message-export-task) ao fluxo de destino quando um novo arquivo é criado. A tarefa é um objeto `S3ExportTaskDefinition` serializado em JSON que especifica a URL do arquivo de entrada, o bucket e a chave do Amazon S3 de destino, além dos metadados opcionais do usuário.
1. O gerenciador de fluxo lê o arquivo de entrada e exporta os dados para o Amazon S3 na ordem das tarefas anexadas. O bucket de destino já deve existir no seu Conta da AWS. Se um objeto para a chave especificada não existir, o gerenciador de fluxo criará o objeto para você.
1. A função do Lambda [lê mensagens](work-with-streams.md#streammanagerclient-read-messages) de um fluxo de status para monitorar o status da exportação. Depois que as tarefas de exportação forem concluídas, a função do Lambda poderá excluir os arquivos de entrada correspondentes. Para obter mais informações, consulte [Monitorar tarefas de exportação](#monitor-export-status-s3).
### Monitorar tarefas de exportação
Você pode criar códigos que os aplicativos de IoT usam para monitorar o status das suas exportações do Amazon S3. Suas funções do Lambda devem criar um fluxo de status e, em seguida, configurar o fluxo de exportação para gravar atualizações de status no fluxo de status. Um único fluxo de status pode receber atualizações de status de vários fluxos que são exportados para o Amazon S3.
Primeiro, [crie um fluxo](work-with-streams.md#streammanagerclient-create-message-stream) para usar como fluxo de status. É possível configurar as políticas de tamanho e retenção do fluxo para controlar a vida útil das mensagens de status. Por exemplo:
+ Defina `Persistence` como `Memory` se você não quiser armazenar as mensagens de status.
+ Defina `StrategyOnFull` como `OverwriteOldestData` para que as novas mensagens de status não sejam perdidas.
Em seguida, crie ou atualize o fluxo de exportação para usar o fluxo de status. Especificamente, defina a propriedade de configuração de status da configuração de exportação `S3ExportTaskExecutorConfig` do fluxo. Isso faz com que o gerenciador de fluxo grave mensagens de status sobre as tarefas de exportação para o fluxo de status. No objeto `StatusConfig`, especifique o nome do fluxo de status e o nível de detalhe. Os valores com suporte a seguir variam do menos detalhado (`ERROR`) ao mais detalhado (`TRACE`). O padrão é `INFO`.
+ `ERROR`
+ `WARN`
+ `INFO`
+ `DEBUG`
+ `TRACE`
O exemplo de fluxo de trabalho a seguir mostra como as funções do Lambda podem usar um fluxo de status para monitorar o status de exportação.
1. Conforme descrito no fluxo de trabalho anterior, uma função do Lambda [anexa uma tarefa de exportação](work-with-streams.md#streammanagerclient-append-message-export-task) a um fluxo configurado para gravar mensagens de status sobre tarefas de exportação em um fluxo de status. A operação de append retorna um número de sequência que representa a ID da tarefa.
1. Uma função do Lambda [lê mensagens](work-with-streams.md#streammanagerclient-read-messages) sequencialmente do fluxo de status e, em seguida, filtra as mensagens com base no nome do fluxo e na ID da tarefa ou com base em uma propriedade da tarefa de exportação do contexto da mensagem. Por exemplo, a função do Lambda pode filtrar pela URL do arquivo de entrada da tarefa de exportação, que é representada pelo objeto `S3ExportTaskDefinition` no contexto da mensagem.
Os códigos de status a seguir indicam que uma tarefa de exportação atingiu um estado concluído:
+ `Success`. O upload foi concluído com êxito.
+ `Failure`. O gerenciador de fluxo encontrou um erro, por exemplo, o bucket especificado não existe. Depois de resolver o problema, você pode reanexar a tarefa de exportação ao fluxo.
+ `Canceled`. A tarefa foi abortada porque a definição de fluxo ou exportação foi excluída ou o período time-to-live (TTL) da tarefa expirou.
**nota**
A tarefa também pode ter um status de `InProgress` ou `Warning`. O gerenciador de fluxo emite avisos quando um evento retorna um erro que não afeta a execução da tarefa. Por exemplo, uma falha na limpeza de um upload parcial interrompido retorna um aviso.
1. Depois que as tarefas de exportação forem concluídas, a função do Lambda poderá excluir os arquivos de entrada correspondentes.
O exemplo a seguir mostra como uma função do Lambda pode ler e processar mensagens de status.
------
#### [ 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.
```
[Referência do SDK do 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.
}
```
Referência do SDK Java: [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.
});
```
Referência do SDK do 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)
------
# 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)
# 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*