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á.
# Módulo 6: Acessando outros AWS serviços
Este módulo avançado mostra como AWS IoT Greengrass os núcleos podem interagir com outros AWS serviços na nuvem. Ele se baseia no exemplo de semáforo fornecido no [Módulo 5](module5.md) e adiciona uma função do Lambda que processa estados de sombra e faz upload de um resumo em uma tabela do Amazon DynamoDB.
![\[AWS IoT conectado a um AWS IoT Greengrass núcleo, que é conectado a um dispositivo de interruptor de luz e a uma sombra de dispositivo de semáforo. A sombra do dispositivo de semáforo está conectada a uma função do Lambda, que está conectada a uma tabela do DynamoDB.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/gg-get-started-089.5.png)
Antes de começar, execute o script de [configuração do dispositivo do Greengrass](quick-start.md) ou conclua o [Módulo 1](module1.md) e o [Módulo 2](module2.md). Também é necessário concluir o [módulo 5](module5.md). Você não precisa de outros componentes ou dispositivos.
Este modulo levará aproximadamente 30 minutos para ser concluído.
**nota**
Este módulo cria e atualiza uma tabela no DynamoDB. Embora a maioria das operações seja pequena e se enquadre no Amazon Web Services Free Tier, executar algumas das etapas deste módulo pode resultar em cobranças na sua conta. Para obter informações sobre a definição de preços, consulte a [Documentação de definição de preços do DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
**Topics**
+ [Configurar a função do grupo](config-iam-roles.md)
+ [Crie e configure a função do Lambda](create-config-lambda.md)
+ [Configurar assinaturas](config_subs.md)
+ [Testar comunicações](comms-test.md)
# Configurar a função do grupo
A função do grupo é um [ perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que você cria e associa ao grupo do Greengrass. Essa função contém as permissões que as funções do Lambda implantadas (e AWS IoT Greengrass outros recursos) usam para AWS acessar os serviços. Para obter mais informações, consulte [Função do grupo do Greengrass.](group-role.md).
Use as seguintes etapas de alto nível para criar uma função de grupo no console do IAM.
1. Crie uma política que permita ou negue ações em um ou mais recursos.
1. Crie uma função que use o serviço do Greengrass como entidade confiável.
1. Anexe sua política à função.
Em seguida, no AWS IoT console, você adiciona a função ao grupo Greengrass.
**nota**
Um grupo do Greengrass tem uma função de grupo única. Se quiser adicionar permissões, você pode editar políticas anexadas ou anexar mais políticas.
Neste tutorial, você criará uma política de permissões que permita descrever, criar e atualizar ações em uma tabela do Amazon DynamoDB. Em seguida, você anexará a política a uma nova função e associará a função ao seu grupo do Greengrass.
Primeiramente, crie uma política gerenciada pelo cliente que conceda as permissões necessárias pela função do Lambda neste módulo.
1. No console do IAM no painel de navegação, selecione **Policies** e **Create policy**.
1. Na guia **JSON**, substitua o conteúdo do espaço reservado pela política a seguir. A função do Lambda neste módulo usa essas permissões para criar e atualizar uma tabela do DynamoDB chamada `CarStats`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PermissionsForModule6",
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:CreateTable",
"dynamodb:PutItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/CarStats"
}
]
}
```
------
1. Selecione **Próximo: Tags** e **Próximo: Revisar**. As tags não são usadas neste tutorial.
1. Em **Nome**, insira e **greengrass\$1CarStats\$1Table** e selecione **Create policy (Criar política)**.
Em seguida, crie uma função que use a nova política.
1. No painel de navegação, selecione **Funções** e **Create role** (Criar função).
1. Em **Tipo de entidade confiável**, selecione **Serviço da AWS **.
1. Em **Caso de uso**, **Casos de uso para outros AWS serviços**, selecione **Greengrass**, selecione **Greengrass** e, em seguida, selecione **Avançar**.
1. Em **Políticas de permissões**, selecione a nova política **greengrass\$1CarStats\$1Table** e selecione **Avançar**.
1. Em **Nome do perfil**, insira **Greengrass\$1Group\$1Role**.
1. Em **Descrição**, insira **Greengrass group role for connectors and user-defined Lambda functions**.
1. Selecione **Criar perfil**.
Agora, adicione a função ao seu grupo do Greengrass.
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. Selecione **Configurações** e, em seguida, **Associar função**.
1. Selecione **Greengrass\$1Group\$1Role** na sua lista de funções e, em seguida, selecione **Associar função**.
# Crie e configure a função do Lambda
Nesta etapa, você cria uma função do Lambda que monitora o número de carros que avançam o semáforo. Sempre que o estado da sombra `GG_TrafficLight` mudar para `G`, a função do Lambda simulará a passagem de um número aleatório de carros (de 1 a 20). Sempre que a terceira luz `G` mudar, a função do Lambda enviará estatísticas básicas, como mínimo e máximo, para uma tabela do DynamoDB.
1. No computador, crie uma pasta chamada `car_aggregator`.
1. Da pasta de [TrafficLight ](https://github.com/aws/aws-greengrass-core-sdk-python/tree/master/examples/TrafficLight)exemplos em diante GitHub, baixe o `carAggregator.py` arquivo para a `car_aggregator` pasta. Este é o código da função do Lambda.
**nota**
Esse exemplo de arquivo Python é armazenado no repositório do AWS IoT Greengrass Core SDK por conveniência, mas não usa o Core SDK. AWS IoT Greengrass
1. Se você não estiver trabalhando na região Leste dos EUA (Norte da Virgínia), abra `carAggregator.py` e altere `region_name` na linha a seguir para a Região da AWS que está atualmente selecionada no AWS IoT console. Para obter a lista de Região da AWS s compatíveis, consulte [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)no *Referência geral da Amazon Web Services*.
```
dynamodb = boto3.resource('dynamodb', region_name='us-east-1')
```
1. Execute o seguinte comando em uma janela da [linha de comando](https://en.wikipedia.org/wiki/Command-line_interface) para instalar o pacote [AWS SDK para Python (Boto3)](https://github.com/boto/boto3/blob/develop/README.rst) e suas dependências na pasta `car_aggregator`. As funções do Greengrass Lambda usam o AWS SDK para acessar outros serviços. AWS (Para o Windows, use um [prompt de comando elevado](https://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx).)
```
pip install boto3 -t path-to-car_aggregator-folder
```
Isso resultará em uma listagem de diretórios semelhante à seguinte:
![\[Captura de tela da listagem de diretórios mostrando "carAggregator.py".\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/gg-get-started-095.png)
1. Compacte o conteúdo da pasta `car_aggregator` em um arquivo `.zip` chamado `car_aggregator.zip`. (Compacte o conteúdo da pasta, e não a pasta.) Esse é o pacote de implantação de sua função do Lambda.
1. No console do Lambda, crie uma função chamada **GG\$1Car\$1Aggregator** e defina os campos restantes da seguinte maneira:
+ 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.
Selecione **Criar função**.
![\[A seção de informações básicas com nome de função definido como GG_Car_Aggregator e Runtime definido como Python 3.7.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/gg-get-started-095.5.png)
1. Faça upload do pacote de implantação da função 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, seu pacote de implantação `car_aggregator.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 **carAggregator.function\$1handler**.
1. Selecione **Salvar**.
1. Publique a função do Lambda e crie um alias para chamado **GG\$1CarAggregator**. Para step-by-step obter instruções, consulte as etapas para [publicar a função Lambda](create-lambda.md#publish-function-version) e [criar um alias](create-lambda.md#create-version-alias) no Módulo 3 (Parte 1).
1. No AWS IoT console, adicione a função Lambda que você acabou de criar ao seu AWS IoT Greengrass grupo:
1. Na página de configuração do grupo, selecione **Função do Lambda** e, em seguida, em **Minhas funções do Lambda**, selecione **Adicionar**.
1. Para a **Função do Lambda**, selecione **GG\$1Car\$1Aggregator**.
1. Em ** Versão da função do Lambda**, selecione o alias da versão que você publicou.
1. Em **Memory limit (Limite de memória)**, insira **64 MB**.
1. Para **Fixado**, selecione **Verdadeiro**.
1. Selecione **Adicionar função do Lambda**.
**nota**
Você pode remover outras funções do Lambda de módulos anteriores.
# Configurar assinaturas
Nesta etapa, você cria uma assinatura que permite que a TrafficLight sombra GG\$1 envie informações de estado atualizadas para a função Lambda GG\$1Car\$1Aggregator. Essa assinatura é adicionada às assinaturas que você criou no [Módulo 5](module5.md), que são todas exigidas por esse módulo.
1. Na página de configuração do grupo, selecione a guia **Inscrições** e, em seguida, selecione **Adicionar**.
1. Na página **Criar assinatura do evento**, faça o seguinte:
1. Em **Tipo de origem**, selecione **Serviço** e **Serviço de sombra local**.
1. Em **Tipo de destino**, escolha **Função Lambda** e, em seguida, escolha **GG\$1Car\$1Aggregator**.
1. Em **Topic filter (Filtro de tópicos)**, insira **\$1aws/things/GG\$1TrafficLight/shadow/update/documents**.
1. Selecione **Create subscription**.
Este módulo requer as novas assinaturas e as [assinaturas](config-dev-subs.md#module5-subscriptions) que você criou no Módulo 5.
1. Verifique se o daemon do Greengrass está em execução, como descrito em [Implantar configurações de nuvem em um dispositivo de núcleo](configs-core.md).
1. Na página de configuração do grupo, selecione **Implantar**.
# Testar comunicações
1. No computador, abra duas janelas [command-line](https://en.wikipedia.org/wiki/Command-line_interface). Assim como no [Módulo 5](module5.md), uma janela é para o dispositivo cliente GG\$1Switch e a outra é para o dispositivo cliente GG\$1TrafficLight . Você as usará para executar os mesmos comandos executados no Módulo 5.
Execute os seguintes comandos para o dispositivo cliente GG\$1Switch:
```
cd path-to-certs-folder
python lightController.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert switchCertId-certificate.pem.crt --key switchCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_Switch
```
Execute os seguintes comandos para o dispositivo TrafficLight cliente GG\$1:
```
cd path-to-certs-folder
python trafficLight.py --endpoint AWS_IOT_ENDPOINT --rootCA AmazonRootCA1.pem --cert lightCertId-certificate.pem.crt --key lightCertId-private.pem.key --thingName GG_TrafficLight --clientId GG_TrafficLight
```
A cada 20 segundos, o interruptor atualiza o estado da sombra para G, Y e R, e a luz exibe o novo estado.
1. O manipulador da função do Lambda é acionado a cada terceira luz verde (a cada três minutos), e um novo registro do DynamoDB é criado. `trafficLight.py`Depois `lightController.py` de executar por três minutos, acesse e abra o Console de gerenciamento da AWS console do DynamoDB.
1. Escolha **Leste dos EUA (Norte da Virgínia)** no Região da AWS menu. Esta é a região onde a função `GG_Car_Aggregator` cria a tabela.
1. No painel de navegação, escolha **Tabelas** e, em seguida, escolha a **CarStats**tabela.
1. Selecione **Exibir itens** para ver as entradas na tabela.
As entradas devem ser exibidas com estatísticas básicas sobre carros que passaram (uma entrada a cada três minutos). Talvez você precise escolher o botão de atualização para ver as atualizações feitas na tabela.
1. Se o teste não for bem-sucedido, você pode procurar informações sobre solução de problemas nos logs do Greengrass.
1. Alterne para o usuário raiz e navegue até o diretório `log`. O acesso aos AWS IoT Greengrass registros requer permissões de root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Verifique se há erros em `runtime.log`.
```
cat system/runtime.log | grep 'ERROR'
```
1. Verifique o log gerado pela função do Lambda.
```
cat user/region/account-id/GG_Car_Aggregator.log
```
Os scripts `lightController.py` e `trafficLight.py` armazenam informações de conexão na pasta `groupCA`, que é criada na mesma pasta que os scripts. Se você receber erros de conexão, certifique-se de que o endereço IP no arquivo `ggc-host` corresponde ao endpoint de endereço IP para seu núcleo.
Para obter mais informações, consulte [Solução de problemas AWS IoT Greengrass](gg-troubleshooting.md).
Este é o final do tutorial básico. Agora você deve entender o modelo de AWS IoT Greengrass programação e seus conceitos fundamentais, incluindo AWS IoT Greengrass núcleos, grupos, assinaturas, dispositivos cliente e o processo de implantação de funções Lambda executadas na borda.
Você pode excluir a tabela do DynamoDB e as funções e assinaturas do Lambda do Greengrass. Para interromper a comunicação entre o dispositivo AWS IoT Greengrass principal e a AWS IoT nuvem, abra um terminal no dispositivo principal e execute um dos seguintes comandos:
+ Para desligar o dispositivo AWS IoT Greengrass principal:
```
sudo halt
```
+ Para parar o AWS IoT Greengrass daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```