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á.
# Implante segredos até o AWS IoT Greengrass âmago
Esse recurso está disponível para AWS IoT Greengrass Core v1.7 e versões posteriores.
AWS IoT Greengrass permite que você se autentique com serviços e aplicativos de dispositivos Greengrass sem codificar senhas, tokens ou outros segredos.
AWS Secrets Manager é um serviço que você pode usar para armazenar e gerenciar com segurança seus segredos na nuvem. AWS IoT Greengrass estende o Secrets Manager aos dispositivos principais do Greengrass, para que seus [conectores e](connectors.md) funções do Lambda possam usar segredos locais para interagir com serviços e aplicativos. Por exemplo, o conector Twilio Notifications usa um token de autenticação armazenado localmente.
Para integrar um segredo a um grupo do Greengrass, crie um recurso de grupo que faça referência ao segredo do Secrets Manager. Esse *recurso de segredo* faz referência ao segredo na nuvem pelo ARN. Para saber como criar, gerenciar e usar recursos de segredos, consulte [Como trabalhar com recursos de segredos](secrets-using.md).
AWS IoT Greengrass criptografa seus segredos enquanto estiver em trânsito e em repouso. Durante a implantação do grupo, AWS IoT Greengrass obtém o segredo do Secrets Manager e cria uma cópia local criptografada no núcleo do Greengrass. Após alternar os segredos na nuvem do Secrets Manager, implante o grupo novamente para propagar os valores atualizados para o núcleo.
O diagrama a seguir mostra o processo de alto nível de implantação de um segredo no núcleo. Os segredos são criptografados em repouso e em trânsito.
![\[AWS IoT Greengrass busca um segredo AWS Secrets Manager e o implanta como um recurso secreto no dispositivo principal, onde está disponível para conectores e funções Lambda.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/deploy-local-secret.png)
Usar AWS IoT Greengrass para armazenar seus segredos localmente oferece as seguintes vantagens:
+ **Dissociação do código (não codificado).** Oferece suporte a credenciais gerenciadas centralmente e ajuda a proteger dados confidenciais contra o risco de comprometimento.
+ **Disponível para cenários offline.** Conectores e funções podem acessar serviços e software locais com segurança quando desconectados da Internet.
+ **Acesso controlado a segredos.** Somente conectores e funções autorizados no grupo podem acessar seus segredos. O AWS IoT Greengrass usa criptografia de chave privada para proteger os segredos. Os segredos são criptografados em repouso e em trânsito. Para obter mais informações, consulte [Criptografia de segredos](#secrets-encryption).
+ **Alternância controlada.** Após alternar seus segredos no Secrets Manager, implante o grupo do Greengrass novamente para atualizar as cópias locais dos segredos. Para obter mais informações, consulte [Criar e gerenciar segredos](secrets-using.md#secrets-create-manage).
**Importante**
AWS IoT Greengrass não atualiza automaticamente os valores dos segredos locais após a rotação das versões na nuvem. Para atualizar valores locais, você deve implantar o grupo novamente.
## Criptografia de segredos
AWS IoT Greengrass criptografa segredos em trânsito e em repouso.
**Importante**
Certifique-se de que suas funções do Lambda definidas pelo usuário tratem os segredos com segurança e não registrem em log nenhum dado confidencial armazenado no segredo. Para obter mais informações, consulte [Mitigate the Risks of Logging and Debugging Your Lambda Function](https://docs.aws.amazon.com/secretsmanager/latest/userguide/best-practices.html#best-practice_lamda-debug-statements) no *Guia do usuário do AWS Secrets Manager *. Embora essa documentação se refira especificamente às funções de alternância, a recomendação também se aplica às funções do Lambda do Greengrass.
**Criptografia em trânsito**
AWS IoT Greengrass usa Transport Layer Security (TLS) para criptografar toda a comunicação pela Internet e pela rede local. Isso protege segredos em trânsito, o que ocorre quando segredos são recuperados do Secrets Manager e implantados no núcleo. Para pacotes de criptografia do TLS com suporte, consulte [Suporte a pacotes de criptografia TLS](gg-sec.md#gg-cipher-suites).
**Criptografia em repouso**
AWS IoT Greengrass usa a chave privada especificada em [`config.json`](gg-core.md#config-json)para criptografia dos segredos armazenados no núcleo. Por esse motivo, o armazenamento seguro da chave privada é essencial para proteger segredos locais. No [modelo de responsabilidade AWS compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/), é responsabilidade do cliente garantir o armazenamento seguro da chave privada no dispositivo principal.
AWS IoT Greengrass suporta dois modos de armazenamento de chaves privadas:
+ Uso dos módulos de segurança de hardware. Para obter mais informações, consulte [Integração de segurança de hardware](hardware-security.md).
**nota**
Atualmente, AWS IoT Greengrass suporta somente o mecanismo de preenchimento [PKCS \$11 v1.5](https://tools.ietf.org/html/rfc2313) para criptografia e decodificação de segredos locais ao usar chaves privadas baseadas em hardware. Se você estiver seguindo as instruções fornecidas pelo fornecedor para gerar manualmente chaves privadas baseadas em hardware, certifique-se de escolher PKCS \$11 v1.5. AWS IoT Greengrass não oferece suporte ao Optimal Asymmetric Encryption Padding (OAEP).
+ Uso de permissões do sistema de arquivos (padrão).
A chave privada é usada para proteger a chave de dados, que é usada para criptografar segredos locais. A chave de dados é alternada com cada grupo de implantação.
O AWS IoT Greengrass núcleo é a única entidade que tem acesso à chave privada. Os conectores do Greengrass ou funções do Lambda que são afiliados a um recurso de segredo obtêm o valor do segredo do núcleo.
## Requisitos
Estes são os requisitos para suporte de segredo local:
+ Você deve estar usando o AWS IoT Greengrass Core v1.7 ou posterior.
+ Para obter os valores dos segredos locais, suas funções Lambda definidas pelo usuário devem AWS IoT Greengrass usar o Core SDK v1.3.0 ou posterior.
+ A chave privada usada para criptografia de segredos locais deve ser especificada no arquivo de configuração do Greengrass. Por padrão, AWS IoT Greengrass usa a chave privada principal armazenada no sistema de arquivos. Para fornecer sua própria chave privada, consulte [Especificar a chave privada para criptografia de segredos](#secrets-config-private-key). Somente o tipo de chave RSA tem suporte.
**nota**
Atualmente, AWS IoT Greengrass suporta somente o mecanismo de preenchimento [PKCS \$11 v1.5](https://tools.ietf.org/html/rfc2313) para criptografia e decodificação de segredos locais ao usar chaves privadas baseadas em hardware. Se você estiver seguindo as instruções fornecidas pelo fornecedor para gerar manualmente chaves privadas baseadas em hardware, certifique-se de escolher PKCS \$11 v1.5. AWS IoT Greengrass não oferece suporte ao Optimal Asymmetric Encryption Padding (OAEP).
+ AWS IoT Greengrass deve receber permissão para obter seus valores secretos. Isso permite AWS IoT Greengrass buscar os valores durante a implantação do grupo. Se você estiver usando a função de serviço padrão do Greengrass, então AWS IoT Greengrass já tem acesso a segredos com nomes que começam com *greengrass* -. Para personalizar o acesso, consulte [AWS IoT Greengrass Permitir obter valores secretos](#secrets-config-service-role).
**nota**
Recomendamos que você use essa convenção de nomenclatura para identificar os segredos que AWS IoT Greengrass podem ser acessados, mesmo que você personalize as permissões. O console usa permissões diferentes para ler seus segredos, então é possível que você possa selecionar segredos no console que AWS IoT Greengrass não tenham permissão para buscá-los. O uso de uma convenção de nomenclatura pode ajudar a evitar um conflito de permissões, resultando em um erro de implantação.
## Especificar a chave privada para criptografia de segredos
Neste procedimento, você fornece o caminho para uma chave privada que é usada para criptografia de segredos locais. Essa deve ser uma chave RSA com tamanho mínimo de 2048 bits. Para obter mais informações sobre chaves privadas usadas no AWS IoT Greengrass núcleo, consulte[AWS IoT Greengrass princípios básicos de segurança](gg-sec.md#gg-principals).
AWS IoT Greengrass suporta dois modos de armazenamento de chave privada: baseado em hardware ou baseado em sistema de arquivos (padrão). Para obter mais informações, consulte [Criptografia de segredos](#secrets-encryption).
**Siga este procedimento somente** se você deseja alterar a configuração padrão, que usa a chave privada do núcleo no sistema de arquivos. Estas etapas foram criadas pressupondo que você criou seu grupo e núcleo, conforme descrito no [Módulo 2](module2.md) do tutorial Conceitos básicos.
1. Abra o arquivo [`config.json`](gg-core.md#config-json) que está localizado no diretório `/greengrass-root/config`.
**nota**
*greengrass-root*representa o caminho em que o software AWS IoT Greengrass Core está instalado em seu dispositivo. Normalmente, esse é o diretório `/greengrass`.
1. No objeto `crypto.principals.SecretsManager`, para a propriedade `privateKeyPath`, insira o caminho da chave privada:
+ Se a chave privada estiver armazenada no sistema de arquivos, especifique o caminho absoluto para a chave . Por exemplo:
```
"SecretsManager" : {
"privateKeyPath" : "file:///somepath/hash.private.key"
}
```
+ Se a chave privada for armazenada em um módulo de segurança de hardware (HSM), especifique o caminho usando o esquema de URI [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512). Por exemplo:
```
"SecretsManager" : {
"privateKeyPath" : "pkcs11:object=private-key-label;type=private"
}
```
Para obter mais informações, consulte [Configuração de segurança de hardware para um AWS IoT Greengrass núcleo](hardware-security.md#configure-hardware-security).
**nota**
Atualmente, AWS IoT Greengrass suporta somente o mecanismo de preenchimento [PKCS \$11 v1.5](https://tools.ietf.org/html/rfc2313) para criptografia e decodificação de segredos locais ao usar chaves privadas baseadas em hardware. Se você estiver seguindo as instruções fornecidas pelo fornecedor para gerar manualmente chaves privadas baseadas em hardware, certifique-se de escolher PKCS \$11 v1.5. AWS IoT Greengrass não oferece suporte ao Optimal Asymmetric Encryption Padding (OAEP).
## AWS IoT Greengrass Permitir obter valores secretos
Neste procedimento, você adiciona uma política em linha à função de serviço do Greengrass que AWS IoT Greengrass permite obter os valores de seus segredos.
**Siga esse procedimento somente** se quiser conceder permissões AWS IoT Greengrass personalizadas aos seus segredos ou se sua função de serviço do Greengrass não incluir a política `AWSGreengrassResourceAccessRolePolicy` gerenciada. `AWSGreengrassResourceAccessRolePolicy`concede acesso a segredos com nomes que começam com *greengrass-.*
1. Execute o seguinte comando da CLI para obter o ARN da função de serviço do Greengrass:
```
aws greengrass get-service-role-for-account --region region
```
O ARN retornado contém o nome da função.
```
{
"AssociatedAt": "time-stamp",
"RoleArn": "arn:aws:iam::account-id:role/service-role/role-name"
}
```
Você usará o ARN ou nome na etapa a seguir.
1. Adicione uma política em linha que permita a ação `secretsmanager:GetSecretValue`. Para obter informações, consulte [Adicionar e remover 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*.
Você pode conceder acesso granular listando segredos explicitamente ou usando um esquema de nomenclatura do caractere curinga `*` ou você pode conceder acesso condicional a segredos marcados ou versionados. Por exemplo, a política a seguir AWS IoT Greengrass permite ler somente os segredos especificados.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:greengrass-SecretA-abc",
"arn:aws:secretsmanager:us-east-1:123456789012:secret:greengrass-SecretB-xyz"
]
}
]
}
```
------
**nota**
Se você usa uma AWS KMS chave gerenciada pelo cliente para criptografar segredos, sua função de serviço do Greengrass também deve permitir a ação. `kms:Decrypt`
Para obter mais informações sobre políticas do IAM para o Secrets Manager, consulte [Controle de acesso e autenticação para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access.html) e [Ações, recursos e chaves de contexto que podem ser usados em uma política do IAM ou em uma política de segredos para o AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html) no *Guia do usuário do AWS Secrets Manager *.
## Consulte também
+ [O que AWS Secrets Manageré](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) no *Guia do AWS Secrets Manager usuário*
+ [PKCS \$11: RSA Encryption versão 1.5](https://tools.ietf.org/html/rfc2313)
# Como trabalhar com recursos de segredos
AWS IoT Greengrass usa *recursos secretos* para integrar segredos de AWS Secrets Manager um grupo do Greengrass. Um recurso de segredo é uma referência a um segredo do Secrets Manager. Para obter mais informações, consulte [Implante segredos até o AWS IoT Greengrass âmago](secrets.md).
No dispositivo AWS IoT Greengrass principal, os conectores e as funções Lambda podem usar o recurso secreto para se autenticar com serviços e aplicativos, sem codificar senhas, tokens ou outras credenciais.
## Criar e gerenciar segredos
Em um grupo do Greengrass, um recurso de segredo faz referência ao ARN de um segredo do Secrets Manager. Quando o recurso de segredo é implantado no núcleo, o valor do segredo é criptografado e disponibilizado para conectores e funções do Lambda afiliados. Para obter mais informações, consulte [Criptografia de segredos](secrets.md#secrets-encryption).
Você pode usar o Secrets Manager para criar e gerenciar as versões na nuvem de seus segredos. Você usa AWS IoT Greengrass para criar, gerenciar e implantar seus recursos secretos.
**Importante**
Recomendamos que você siga a melhor prática de alternar seus segredos no Secrets Manager. Em seguida, implante o grupo do Greengrass para atualizar as cópias locais dos seus segredos. Para obter mais informações, consulte Como [girar seus AWS Secrets Manager segredos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html) no *Guia do AWS Secrets Manager usuário*.
**Para disponibilizar um segredo no núcleo do Greengrass**
1. Crie um segredo no Secrets Manager. Essa é a versão na nuvem de seu segredo, que é armazenado e gerenciado centralmente no Secrets Manager. As tarefas de gerenciamento incluem a alternância de valores de segredos e a aplicação de políticas de recursos.
1. Crie um recurso secreto em AWS IoT Greengrass. Esse grupo é um tipo de recurso de grupo que faz referência ao segredo na nuvem pelo ARN. Você pode fazer referência a um segredo somente uma vez por grupo.
1. Configure seu conector ou sua função do Lambda. Você deve afiliar o recurso a uma função ou a um conector especificando parâmetros ou propriedades correspondentes. Isso permite que o usuário obtenha o valor do recurso de segredo implantado localmente. Para obter mais informações, consulte [Usar segredos locais em conectores e funções do Lambda](#secrets-access).
1. Implante o grupo do Greengrass. Durante a implantação, o AWS IoT Greengrass obtém o valor do segredo na nuvem e cria (ou atualiza) o segredo local no núcleo.
O Secrets Manager registra um evento AWS CloudTrail cada vez que AWS IoT Greengrass recupera um valor secreto. AWS IoT Greengrass não registra nenhum evento relacionado à implantação ou ao uso de segredos locais. Para obter mais informações sobre o registro do Secrets Manager, consulte [Monitore o uso de seus AWS Secrets Manager segredos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html) no *Guia AWS Secrets Manager do Usuário*.
### Incluir rótulos de preparação em recursos de segredos
O Secrets Manager usa rótulos de preparação para identificar versões específicas de um valor de segredo. Os rótulos de teste podem ser definidos pelo sistema ou pelo usuário. O Secrets Manager atribui o rótulo `AWSCURRENT` à versão mais recente do valor do segredo. Os rótulos de preparação geralmente são usados para gerenciar a alternância de segredos. Para obter mais informações sobre o versionamento de segredos do Secrets Manager, consulte [Termos e conceitos importantes do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html) no *Guia do usuário do AWS Secrets Manager *.
Os recursos de segredos sempre incluem o rótulo de preparação `AWSCURRENT` e podem incluir outros rótulos de preparação se necessários para uma função do Lambda ou um conector. Durante a implantação do grupo, AWS IoT Greengrass recupera os valores dos rótulos de teste referenciados no grupo e, em seguida, cria ou atualiza os valores correspondentes no núcleo.
### Criar e gerenciar recursos de segredos (console)
#### Criar recursos de segredos (console)
No AWS IoT Greengrass console, você cria e gerencia recursos secretos na guia **Segredos** na página **Recursos** do grupo. Para obter tutoriais que criam um recurso de segredo e o adicionam a um grupo, consulte [Como criar um recurso de segredo (console)](secrets-console.md) e [Conceitos básicos de conectores do Greengrass (console)](connectors-console.md).
![\[Um recurso de segredo na guia Segredo na página Recursos.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/connectors/secret-resource-twilio-auth-token.png)
**nota**
Como alternativa, o console permite que você crie um segredo e um recurso de segredo ao configurar um conector ou uma função do Lambda. Você pode fazer isso na página **Configurar parâmetros** do conector ou na página **Recursos** da função do Lambda.
#### Gerenciar um recurso de segredo (console)
As tarefas de gerenciamento dos recursos de segredos em seu grupo do Greengrass incluem adicionar recursos de segredos ao grupo, remover recursos de segredos do grupo e alterar o conjunto de [rótulos de preparação](#secret-resources-labels) incluídos em um recurso de segredo.
Se você apontar para um segredo diferente do Secrets Manager, também deverá editar conectores que usem o segredo:
1. Na página de configuração do grupo, selecione **Connectors (Conectores)**.
1. No menu de contexto do conector, selecione **Edit (Editar)**.
1. A página **Edit parameters (Editar parâmetros)** exibe uma mensagem para informá-lo de que o ARN do segredo foi alterado. Para confirmar a alteração, selecione **Save (Salvar)**.
Se você excluir um segredo no Secrets Manager, remova o recurso de segredode segredo correspondente do grupo e dos conectores e funções do Lambda que fazem referência a ele. Caso contrário, durante a implantação do grupo, AWS IoT Greengrass retornará um erro informando que o segredo não pode ser encontrado. Além disso, atualize o código da função do Lambda conforme necessário.
### Criar e gerenciar recursos de segredos (CLI)
#### Criar recursos de segredos (CLI)
Na AWS IoT Greengrass API, um segredo é um tipo de recurso de grupo. O exemplo a seguir cria uma definição de recurso com uma versão inicial que inclui um recurso de segredo chamado `MySecretResource`. Para obter um tutorial que cria um recurso de segredo e o adiciona a uma versão de grupo, consulte [Conceitos básicos de conectores do Greengrass (CLI)](connectors-cli.md).
O recurso de segredo faz referência ao ARN do segredo do Secrets Manager correspondente e inclui dois rótulos de preparação, além de `AWSCURRENT`, que é sempre incluído.
```
aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{
"Resources": [
{
"Id": "my-resource-id",
"Name": "MySecretResource",
"ResourceDataContainer": {
"SecretsManagerSecretResourceData": {
"ARN": "arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-SomeSecret-KUj89s",
"AdditionalStagingLabelsToDownload": [
"Label1",
"Label2"
]
}
}
}
]
}'
```
#### Gerenciar recursos de segredos (CLI)
As tarefas de gerenciamento dos recursos de segredos em seu grupo do Greengrass incluem adicionar recursos de segredos ao grupo, remover recursos de segredos do grupo e alterar o conjunto de [rótulos de preparação](#secret-resources-labels) incluídos em um recurso de segredo.
Na AWS IoT Greengrass API, essas alterações são implementadas usando versões.
A AWS IoT Greengrass API usa versões para gerenciar grupos. As versões são imutáveis, portanto, para adicionar ou alterar componentes do grupo — por exemplo, os dispositivos cliente, as funções e os recursos do grupo — você deve criar versões de componentes novos ou atualizados. Em seguida, crie e implante uma versão do grupo que contenha a versão de destino de cada componente. Para saber mais sobre os grupos, consulte [AWS IoT Greengrass grupos](what-is-gg.md#gg-group).
Por exemplo, para alterar o conjunto de rótulos de preparação para um recurso de segredo:
1. Crie uma versão de definição de recurso que contenha o recurso de segredo atualizado. O exemplo a seguir adiciona um terceiro rótulo de preparação ao recurso de segredo da seção anterior.
**nota**
Para adicionar mais recursos à versão, inclua-os na matriz `Resources`.
```
aws greengrass create-resource-definition --name MyGreengrassResources --initial-version '{
"Resources": [
{
"Id": "my-resource-id",
"Name": "MySecretResource",
"ResourceDataContainer": {
"SecretsManagerSecretResourceData": {
"ARN": "arn:aws:secretsmanager:us-west-2:123456789012:secret:greengrass-SomeSecret-KUj89s",
"AdditionalStagingLabelsToDownload": [
"Label1",
"Label2",
"Label3"
]
}
}
}
]
}'
```
1. Se o ID do recurso de segredo for alterado, atualize os conectores e as funções que usam o recurso de segredo. Nas novas versões, atualize o parâmetro ou a propriedade que corresponde ao ID de recurso. Se o ARN do segredo for alterado, você também deverá atualizar o parâmetro correspondente para quaisquer conectores que usem o segredo.
**nota**
O ID do recurso é um identificador arbitrário fornecido pelo cliente.
1. Crie um grupo de destino que contenha a versão de destino de cada componente que você deseja enviar para o núcleo.
1. Implante a versão de grupo.
Para obter um tutorial que mostra como criar e implantar recursos de segredos, conectores e funções, consulte [Conceitos básicos de conectores do Greengrass (CLI)](connectors-cli.md).
Se você excluir um segredo no Secrets Manager, remova o recurso de segredode segredo correspondente do grupo e dos conectores e funções do Lambda que fazem referência a ele. Caso contrário, durante a implantação do grupo, AWS IoT Greengrass retornará um erro informando que o segredo não pode ser encontrado. Além disso, atualize o código da função do Lambda conforme necessário. Você pode remover um segredo local implantando uma versão de definição de recurso que não contenha o recurso de segredo correspondente.
## Usar segredos locais em conectores e funções do Lambda
As funções do Lambda e os conectores do Greengrass usam segredos locais para interagir com serviços e aplicativos. O valor `AWSCURRENT` é usado por padrão, mas os valores dos outros [ rótulos de preparação](#secret-resources-labels) incluídos no recurso de segredo também estão disponíveis.
Conectores e funções devem ser configurados para que possam acessar segredos locais. Isso afilia o recurso de segredo ao conector ou à função.
**Conectores**
Se um conector exige acesso a um segredo local, ele fornece parâmetros que você configura com as informações necessárias para acessar o segredo.
+ Para saber como fazer isso no AWS IoT Greengrass console, consulte[Conceitos básicos de conectores do Greengrass (console)](connectors-console.md).
+ Para saber como fazer isso com a AWS IoT Greengrass CLI, consulte. [Conceitos básicos de conectores do Greengrass (CLI)](connectors-cli.md)
Para obter informações sobre os requisitos para conectores individuais, consulte [Conectores do Greengrass fornecidos pela AWS](connectors-list.md).
A lógica para acessar e usar o segredo está integrada ao conector.
**Funções do Lambda**
Para permitir que uma função do Lambda do Greengrass acesse um segredo local, configure as propriedades da função.
+ Para saber como fazer isso no AWS IoT Greengrass console, consulte[Como criar um recurso de segredo (console)](secrets-console.md).
+ Para fazer isso na AWS IoT Greengrass API, você fornece as seguintes informações na `ResourceAccessPolicies` propriedade.
+ `ResourceId`: o ID do recurso de segredo no grupo do Greengrass. Esse é o recurso que faz referência ao ARN do segredo do Secrets Manager correspondente.
+ `Permission`: o tipo de acesso que a função tem ao recurso. Somente a permissão `ro` (somente leitura) tem suporte para recursos de segredos.
O exemplo a seguir cria uma função do Lambda que pode acessar o recurso de segredo `MyApiKey`.
```
aws greengrass create-function-definition --name MyGreengrassFunctions --initial-version '{
"Functions": [
{
"Id": "MyLambdaFunction",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:myFunction:1",
"FunctionConfiguration": {
"Pinned": false,
"MemorySize": 16384,
"Timeout": 10,
"Environment": {
"ResourceAccessPolicies": [
{
"ResourceId": "MyApiKey",
"Permission": "ro"
}
],
"AccessSysfs": true
}
}
}
]
}'
```
Para acessar segredos locais em tempo de execução, as funções do Greengrass Lambda chamam a `get_secret_value` função do `secretsmanager` cliente no SDK AWS IoT Greengrass principal (v1.3.0 ou posterior).
O exemplo a seguir mostra como usar o SDK AWS IoT Greengrass principal para Python para obter um segredo. Ele transmite o nome do segredo para a função `get_secret_value`. O `SecretId` pode ser o nome ou o ARN do segredo do Secrets Manager (e não o recurso de segredo).
```
import greengrasssdk
secrets_client = greengrasssdk.client("secretsmanager")
secret_name = "greengrass-MySecret-abc"
def function_handler(event, context):
response = secrets_client.get_secret_value(SecretId=secret_name)
secret = response.get("SecretString")
```
Para segredos do tipo texto, a função `get_secret_value` retorna uma string. Para segredos do tipo binário, ela retorna uma string codificada em base64.
**Importante**
Certifique-se de que suas funções do Lambda definidas pelo usuário tratem os segredos com segurança e não registrem em log nenhum dado confidencial armazenado no segredo. Para obter mais informações, consulte [Mitigate the Risks of Logging and Debugging Your Lambda Function](https://docs.aws.amazon.com/secretsmanager/latest/userguide/best-practices.html#best-practice_lamda-debug-statements) no *Guia do usuário do AWS Secrets Manager *. Embora essa documentação se refira especificamente às funções de alternância, a recomendação também se aplica às funções do Lambda do Greengrass.
O valor atual do segredo é retornado por padrão. Essa é a versão à qual o rótulo de preparação `AWSCURRENT` está anexado. Para acessar uma versão diferente, transmita o nome do rótulo de preparação correspondente para o argumento `VersionStage` opcional. Por exemplo:
```
import greengrasssdk
secrets_client = greengrasssdk.client("secretsmanager")
secret_name = "greengrass-TestSecret"
secret_version = "MyTargetLabel"
# Get the value of a specific secret version
def function_handler(event, context):
response = secrets_client.get_secret_value(
SecretId=secret_name, VersionStage=secret_version
)
secret = response.get("SecretString")
```
Para obter outro exemplo de função que chame `get_secret_value`, consulte [Crie um pacote de implantação para a função do Lambda](secrets-console.md#secrets-console-create-deployment-package).
# Como criar um recurso de segredo (console)
Esse recurso está disponível para AWS IoT Greengrass Core v1.7 e versões posteriores.
Este tutorial mostra como usar o Console de gerenciamento da AWS para adicionar um *recurso secreto* a um grupo do Greengrass. Um recurso secreto é uma referência a um formulário secreto AWS Secrets Manager. Para obter mais informações, consulte [Implante segredos até o AWS IoT Greengrass âmago](secrets.md).
No dispositivo AWS IoT Greengrass principal, os conectores e as funções Lambda podem usar o recurso secreto para se autenticar com serviços e aplicativos, sem codificar senhas, tokens ou outras credenciais.
Neste tutorial, você começa criando um segredo no AWS Secrets Manager console. Em seguida, no console do AWS IoT Greengrass , você adiciona um recurso de segredo a um grupo do Greengrass na página **Recursos** do grupo. Esse recurso de segredo faz referência ao segredo do Secrets Manager. Posteriormente, você anexará o recurso de segredode segredo a uma função do Lambda, o que permite à função obter o valor do segredo local.
**nota**
Como alternativa, o console permite que você crie um segredo e um recurso de segredo ao configurar um conector ou uma função do Lambda. Você pode fazer isso na página **Configurar parâmetros** do conector ou na página **Recursos** da função do Lambda.
Somente os conectores que contêm parâmetros para segredos podem acessar segredos. Para obter um tutorial que mostra como o conector de notificações Twilio usa um token de autenticação armazenamento localmente, consulte [Conceitos básicos de conectores do Greengrass (console)](connectors-console.md).
O tutorial contém as seguintes etapas de nível elevado:
1. [Crie um segredo do Secrets Manager](#secrets-console-create-secret)
1. [Adicionar um recurso de segredo a um grupo](#secrets-console-create-resource)
1. [Crie um pacote de implantação para a função do Lambda](#secrets-console-create-deployment-package)
1. [Criar uma função do Lambda](#secrets-console-create-function)
1. [Adicionar a função ao grupo](#secrets-console-create-gg-function)
1. [Anexar o recurso de segredo à função](#secrets-console-affiliate-gg-function)
1. [Adicionar assinaturas ao grupo](#secrets-console-create-subscription)
1. [Implantar o grupo](#secrets-console-create-deployment)
1. [Testar a função do Lambda](#secrets-console-test-solution)
O tutorial levará aproximadamente 20 minutos para ser concluído.
## Pré-requisitos
Para concluir este tutorial, é necessário:
+ Um grupo do Greengrass e um núcleo do Greengrass (versão 1.7 ou posterior). Para saber como criar um grupo e núcleo 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.
+ AWS IoT Greengrass deve ser configurado para oferecer suporte a segredos locais. Para obter mais informações, consulte os [Requisitos de segredos](secrets.md#secrets-reqs).
**nota**
Este requisito inclui permitir o acesso aos seus segredos do Secrets Manager. Se você estiver usando a função de serviço padrão do Greengrass, o Greengrass terá permissão para obter os valores de segredos com nomes que começam com *greengrass-*.
+ Para obter os valores dos segredos locais, suas funções Lambda definidas pelo usuário devem AWS IoT Greengrass usar o Core SDK v1.3.0 ou posterior.
## Etapa 1: Criar um segredo do Secrets Manager
Nesta etapa, você usa o AWS Secrets Manager console para criar um segredo.
1. Faça login no [console do AWS Secrets Manager](https://console.aws.amazon.com/secretsmanager/).
**nota**
Para obter mais informações sobre esse processo, consulte [Etapa 1: Criar e armazenar seu segredo no AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html) no *Guia do usuário do AWS Secrets Manager *.
1. Selecione **Armazenar um novo segredo**.
1. Em **Escolher tipo de segredo**, selecione **Outro tipo de segredo**.
1. Em **Specify the key/value pairs to be stored for this secret (Especificar os pares de chave/valor a serem armazenados para este segredo)**:
+ Em **Chave**, digite **test**.
+ Em **Valor**, insira **abcdefghi**.
1. Mantenha **aws/secretsmanager** selecionado para a chave de criptografia e selecione **Avançar**.
**nota**
Você não será cobrado AWS KMS se usar a chave AWS gerenciada padrão que o Secrets Manager cria em sua conta.
1. Em **Secret name**, digite **greengrass-TestSecret** e selecione **Next**.
**nota**
Por padrão, a função de serviço do Greengrass permite AWS IoT Greengrass obter o valor de segredos com nomes que começam com *greengrass* -. Para obter mais informações, consulte os [requisitos de segredos](secrets.md#secrets-reqs).
1. A alternância não é necessária neste tutorial, portanto, selecione Desabilitar a alternância automática e, em seguida, **Avançar**.
1. Na página **Review (Revisar)**, revise as configurações e selecione **Store (Armazenar)**.
Em seguida, crie um recurso de segredo no seu grupo do Greengrass que faz referência ao segredo.
## Etapa 2: Adicionar um recurso de segredo a um grupo do Greengrass
Nesta etapa, você configura um recurso de grupo que faz referência ao segredo do Secrets Manager.
1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1).
1. Selecione o grupo ao qual você deseja adicionar o recurso de segredo.
1. Na página de configuração do grupo, selecione a guia **Recursos** e, em seguida, role para baixo até a seção **Segredos**. A seção **Segredos** exibe os recursos de segredos que pertencem ao grupo. Você pode adicionar, editar e remover recursos de segredos nessa seção.
**nota**
Como alternativa, o console permite que você crie um segredo e um recurso de segredo ao configurar um conector ou uma função do Lambda. Você pode fazer isso na página **Configurar parâmetros** do conector ou na página **Recursos** da função do Lambda.
1. Selecione **Adicionar** na seção **Segredos**.
1. Na página **Adicionar um recurso de segredo**, insira **MyTestSecret** em **Nome do recurso**.
1. Em **Segredo**, escolha **greengrass-. TestSecret**
1. Na seção **Selecionar rótulos (opcional)**, o rótulo AWSCURRENT intermediário representa a versão mais recente do segredo. Esse rótulo é sempre incluído em um recurso de segredo.
**nota**
Este tutorial requer somente o AWSCURRENT rótulo. Você também pode incluir rótulos que a função do Lambda ou o connector exige.
1. Selecione **Adicionar recurso**.
## Etapa 3: crie um pacote de implantação para a função do Lambda
Para criar uma função do Lambda, você deve, primeiro, criar um *pacote de implantação* da função do Lambda que contenha o código da função e as dependências. As funções do Lambda do Greengrass exigem o [ SDK do AWS IoT Greengrass Core](lambda-functions.md#lambda-sdks-core) para tarefas como comunicação com mensagens MQTT no ambiente de núcleo e acesso a segredos locais. Este tutorial cria uma função Python, então você usa a versão Python do SDK no pacote de implantação.
**nota**
Para obter os valores dos segredos locais, suas funções Lambda definidas pelo usuário devem AWS IoT Greengrass usar o Core SDK v1.3.0 ou posterior.
1. Na página de downloads do [AWS IoT Greengrass Core SDK](what-is-gg.md#gg-core-sdk-download), baixe o AWS IoT Greengrass Core SDK para Python em seu computador.
1. Descompacte o pacote obtido por download para obter o SDK. O SDK é a pasta do `greengrasssdk`.
1. Salve a seguinte função do código Python em um arquivo local denominado `secret_test.py`.
```
import greengrasssdk
secrets_client = greengrasssdk.client("secretsmanager")
iot_client = greengrasssdk.client("iot-data")
secret_name = "greengrass-TestSecret"
send_topic = "secrets/output"
def function_handler(event, context):
"""
Gets a secret and publishes a message to indicate whether the secret was
successfully retrieved.
"""
response = secrets_client.get_secret_value(SecretId=secret_name)
secret_value = response.get("SecretString")
message = (
f"Failed to retrieve secret {secret_name}."
if secret_value is None
else f"Successfully retrieved secret {secret_name}."
)
iot_client.publish(topic=send_topic, payload=message)
print("Published: " + message)
```
A função `get_secret_value` oferece suporte ao nome ou ARN do segredo do Secrets Manager para o valor `SecretId`. Esse exemplo usa o nome do segredo. Para este exemplo de segredo, AWS IoT Greengrass retorna o par de valores-chave:. `{"test":"abcdefghi"}`
**Importante**
Certifique-se de que suas funções do Lambda definidas pelo usuário tratem os segredos com segurança e não registrem em log nenhum dado confidencial armazenado no segredo. Para obter mais informações, consulte [Mitigate the Risks of Logging and Debugging Your Lambda Function](https://docs.aws.amazon.com/secretsmanager/latest/userguide/best-practices.html#best-practice_lamda-debug-statements) no *Guia do usuário do AWS Secrets Manager *. Embora essa documentação se refira especificamente às funções de alternância, a recomendação também se aplica às funções do Lambda do Greengrass.
1. Comprima os seguintes itens em um arquivo denominado `secret_test_python.zip`. Quando você criar o arquivo ZIP, inclua apenas o código e suas dependências, e não a pasta que contém os arquivos.
+ **secret\$1test.py**. Lógica do aplicativo.
+ **greengrasssdk**. Biblioteca necessária para todas as funções Python do Lambda do Greengrass.
Esse é o pacote de implantação de sua função do Lambda.
## Etapa 4: 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 **SecretTest**.
+ 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 `secret_test_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 **secret\$1test.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 **SecretTest: 1**, no menu **Ações**, escolha **Criar alias**.
1. Na página **Create a new alias**, use os seguintes valores:
+ Em **Nome**, digite **GG\$1SecretTest**.
+ 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 e anexar o recurso de segredo.
## Etapa 5: adicionar a função do Lambda ao grupo do Greengrass
Nesta etapa, você adiciona a função do Lambda ao grupo do Greengrass no console do AWS IoT .
1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**.
1. Na seção **Minhas funções do Lambda**, selecione **Adicionar**.
1. Para a **função Lambda, escolha**. **SecretTest**
1. Para a **Versão da função do Lambda**, selecione o alias para a versão que você publicou.
Em seguida, configure o ciclo de vida da função do Lambda.
1. Na seção **configuração da função do Lambda**, faça as atualizações a seguir.
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
+ Em **Parâmetro adicional**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Para **Usuário e grupo do sistema**, selecione **Usar padrão de grupo**.
+ Para **Conteinerização da função do Lambda**, selecione **Usar padrão de grupo**.
+ Em **Memory limit (Limite de memória)**, insira **1024 MB**.
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. Selecione **Adicionar função do Lambda**.
Em seguida, associe o recurso de segredo à função.
## Etapa 6: anexar o recurso de segredo à função do Lambda
Nesta etapa, você associa o recurso de segredo à função do função do Lambda em seu grupo do Greengrass. Isso associa o recurso à função, o que permite à função obter o valor do segredo local.
1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**.
1. Escolha a **SecretTest**função.
1. Na página de detalhes da função, selecione **Recursos**.
1. Role até a seção **Segredos** e selecione **Associar**.
1. Escolha e **MyTestSecret**, em seguida, escolha **Associar**.
## Etapa 7: Adicionar assinaturas ao grupo do Greengrass
Nesta etapa, você adiciona assinaturas que permitem AWS IoT e a função Lambda para trocar mensagens. Uma assinatura permite AWS IoT invocar a função e outra permite que a função envie dados de saída para AWS IoT.
1. Na página de configuração do grupo, selecione a guia **Assinaturas** e, em seguida, **Adicionar assinatura**.
1. Crie uma assinatura que AWS IoT permita publicar mensagens na função.
Na página de configuração do grupo, selecione a guia **Assinaturas** e, em seguida, **Adicionar assinatura**.
1. Na página **Criar uma assinatura**, configure a origem e o destino, da seguinte forma:
1. Em **Tipo de origem**, selecione **Função do Lambda** e, em seguida, selecione **IoT Cloud**.
1. Em **Tipo de destino**, escolha **Serviço** e, em seguida, escolha **SecretTest**.
1. Em **Filtro de tópicos**, insira **secrets/input** e, em seguida, selecione **Criar assinatura**.
1. Adicione uma segunda assinatura. Selecione a guia **Assinaturas**, selecione **Adicionar assinatura** e configure a origem e o destino, da seguinte forma:
1. Em **Tipo de origem**, escolha **Serviços** e, em seguida, escolha **SecretTest**.
1. Em **Tipo de destino**, selecione **Função do Lambda** e, em seguida, selecione **IoT Cloud**.
1. Em **Filtro de tópicos**, insira **secrets/output** e, em seguida, selecione **Criar assinatura**.
## Etapa 8: Implantar o grupo do Greengrass
Implante o grupo no dispositivo do núcleo. Durante a implantação, AWS IoT Greengrass obtém o valor do segredo no Secrets Manager e cria uma cópia local criptografada no 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).
## Testar a função do Lambda
1. Na página inicial do AWS IoT console, escolha **Testar**.
1. Em **Inscrever-se no tópico**, use os seguintes valores e, em seguida, selecione **Inscrever-se**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/secrets-console.html)
1. Para **Publicar no tópico**, use os valores a seguir e, em seguida selecione **Publicar** para invocar a função.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/secrets-console.html)
Se for bem-sucedida, a função publicará uma mensagem de "Êxito".
## Consulte também
+ [Implante segredos até o AWS IoT Greengrass âmago](secrets.md)