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á.
# Função do Lambda de alternância
Para muitos tipos de segredos, o Secrets Manager usa uma AWS Lambda função para atualizar o segredo e o banco de dados ou serviço. Para obter mais informações sobre os custos do uso de uma função do Lambda, consulte [Preços](intro.md#asm_pricing).
Para alguns [Segredos gerenciados por outros serviços](service-linked-secrets.md), você usa *alternância gerenciada*. Para usar [Alternância gerenciada](rotate-secrets_managed.md), primeiro você cria o segredo por meio do serviço de gerenciamento.
Durante a alternância, o Secrets Manager registra eventos de logs que indicam o estado de alternância. Para obter mais informações, consulte [AWS Secrets Manager Registre eventos com AWS CloudTrail](monitoring-cloudtrail.md).
Para alternar um segredo, o Secrets Manager chama uma [função do Lambda](rotate-secrets_lambda-functions.md) de acordo com a programação de alternância que você configurou. Se você também atualizar manualmente seu valor secreto enquanto a alternância automática estiver configurada, o Secrets Manager considerará essa alternância válida ao calcular a próxima data de alternância.
Durante a alternância, o Secrets Manager chama a mesma função várias vezes, cada vez com parâmetros diferentes. O Secrets Manager invoca a função com a seguinte estrutura de parâmetros de solicitação JSON:
```
{
"Step" : "request.type",
"SecretId" : "string",
"ClientRequestToken" : "string",
"RotationToken" : "string"
}
```
**Parâmetros:**
+ **Etapa**: a etapa de alternância: `create_secret`, `set_secret`, `test_secret` ou `finish_secret`. Para obter mais informações, consulte [Quatro etapas em uma função de alternância](rotate-secrets_lambda-functions.md#rotate-secrets_lambda-functions-code).
+ **SecretId**— O ARN do segredo para girar.
+ **ClientRequestToken**— Um identificador exclusivo para a nova versão do segredo. Esse valor ajuda a garantir a idempotência. Para obter mais informações, consulte [PutSecretValue: ClientRequestToken](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_PutSecretValue.html#SecretsManager-PutSecretValue-request-ClientRequestToken) na *Referência AWS Secrets Manager da API*.
+ **RotationToken**— Um identificador exclusivo que indica a origem da solicitação. Necessário para alternância de segredos usando um perfil assumido ou alternância entre contas, na qual você alterna um segredo em uma conta usando uma função de alternância do Lambda em outra conta. Em ambos os casos, a função de alternância assume um perfil do IAM para chamar o Secrets Manager e, em seguida, o Secrets Manager usa o token de alternância para validar a identidade do perfil do IAM.
Se alguma etapa de alternância falhar, o Secrets Manager tentará novamente todo o processo de alternância várias vezes.
**Topics**
+ [Alternância automática para segredos de banco de dados (console)](rotate-secrets_turn-on-for-db.md)
+ [Alternância automática para segredos não de banco de dados (console)](rotate-secrets_turn-on-for-other.md)
+ [Alternância automática (AWS CLI)](rotate-secrets_turn-on-cli.md)
+ [
# Estratégias de alternância da função do Lambda
](rotation-strategy.md)
+ [
# Função de alternância do Lambda
](rotate-secrets_lambda-functions.md)
+ [Modelos de função de alternância](reference_available-rotation-templates.md)
+ [Permissões para alternância](rotating-secrets-required-permissions-function.md)
+ [
# Acesso à rede para função AWS Lambda de rotação
](rotation-function-network-access.md)
+ [Solucionar problemas de alternância](troubleshoot_rotation.md)
# Configure a alternância automática para segredos do Amazon RDS, do Amazon Aurora, do Amazon Redshift ou do Amazon DocumentDB
Este tutorial descreve como configurar [Função do Lambda de alternância](rotate-secrets_lambda.md) para segredos de banco de dados. Alternância é o processo de atualizar periodicamente um segredo. Quando o Secrets Manager alterna um segredo, você atualiza as credenciais tanto no segredo como no banco de dados. No Secrets Manager, é possível configurar a alternância automática para seus segredos de banco de dados.
Para configurar a alternância usando o console, você precisa primeiro escolher uma estratégia de alternância. Em seguida, você configura o segredo para a alternância, o qual cria uma função de alternância do Lambda, caso você ainda não tenha uma. O console também define permissões para a função de execução da função do Lambda. A última etapa é garantir que a função de alternância do Lambda possa acessar o Secrets Manager e seu banco de dados utilizando a rede.
**Atenção**
Para ativar a alternância automática, é necessário ter permissão para criar um perfil de execução do IAM para a função de alternância do Lambda e anexar uma política de permissão a ela. Ambas as permissões `iam:CreateRole` e `iam:AttachRolePolicy` são necessárias. Conceder essas permissões permite que uma identidade conceda a ela mesma quaisquer permissões.
**Topics**
+ [
## Etapa 1: escolher uma estratégia de alternância e (opcionalmente) criar um segredo de superusuário
](#rotate-secrets_turn-on-for-db_step1)
+ [
## Etapa 2: configurar a alternância e criar uma função de alternância
](#rotate-secrets_turn-on-for-db_step2)
+ [
## Etapa 3: (Opcional) Defina condições de permissões adicionais na função de alternância
](#rotate-secrets_turn-on-for-db_step3)
+ [
## Etapa 4: configurar acesso à rede para a função de alternância
](#rotate-secrets_turn-on-for-db_step4)
+ [
## Próximas etapas
](#rotate-secrets_turn-on-for-db_stepnext)
## Etapa 1: escolher uma estratégia de alternância e (opcionalmente) criar um segredo de superusuário
Para obter informações sobre as estratégias oferecidas pelo Secrets Manager, consulte [Estratégias de alternância da função do Lambda](rotation-strategy.md).
Se você escolher a *estratégia de usuários alternados*, deverá [Criar segredos](create_secret.md) e armazenar nele as credenciais de superusuário do banco de dados. É necessário um segredo com credenciais de superusuário porque a alternância clona o primeiro usuário e a maioria dos usuários não tem essa permissão. Observe que o Amazon RDS Proxy não oferece suporte à estratégia de usuários alternados.
## Etapa 2: configurar a alternância e criar uma função de alternância
**Para ativar a alternância para um segredo do Amazon RDS, do Amazon DocumentDB ou do Amazon Redshift**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Na página **Secrets** (Segredos), escolha o segredo.
1. Na página **Secret details (Detalhes do segredo)**, na seção **Rotation configuration (Configuração da alternância)**, escolha **Edit rotation (Editar alternância)**.
1. Na caixa de diálogo **Edit rotation configuration** (Editar configuração da alternância), siga estas etapas:
1. Ative a **Automatic rotation** (Alternância automática).
1. Em **Rotation schedule** (Programação da alternância), insira sua programação no fuso horário UTC no **Schedule expression builder** (Desenvolvedor de expressão programada) ou como uma **Schedule expression** (Expressão programada). O Secrets Manager armazena sua programação como uma expressão `rate()` ou `cron()`. A janela de alternância começa automaticamente à 0h, a menos que você especifique um **horário de início**. É possível alternar um segredo com intervalos a partir de quatro horas. Para obter mais informações, consulte [Programação de alternância](rotate-secrets_schedule.md).
1. (Opcional) Em **Window duration** (Duração da janela), escolha a duração da janela em que deseja que o Secrets Manager alterne o seu segredo, por exemplo, **3h**, por uma janela de três horas. A janela não pode se estender até a próxima janela de alternância. Se você não especificar **Window duration** (Duração da janela) para uma programação de alternância em horas, a janela será automaticamente encerrada após uma hora. Para uma programação de alternância em dias, a janela terminará automaticamente no final do dia.
1. (Opcional) Escolha **Rotate immediately when the secret is stored** (Alternar imediatamente quando o segredo for armazenado) para alternar o seu segredo assim que as suas alterações forem salvas. Se você desmarcar a caixa de seleção, a primeira alternância começará no cronograma definido.
Se a alternância falhar, por exemplo, porque as etapas 3 e 4 ainda não foram concluídas, o Secrets Manager repetirá o processo de alternância várias vezes.
1. Em **Rotation function** (Função de alternância), execute uma das ações a seguir:
+ Selecione **Criar uma nova função do Lambda** e insira um nome para sua nova função. O Secrets Manager adiciona `SecretsManager` ao início do nome da função. O Secrets Manager cria a função com base no [modelo](reference_available-rotation-templates.md) apropriado e define as [permissões](rotating-secrets-required-permissions-function.md) necessárias para a função de execução do Lambda.
+ Escolha **Usar uma função do Lambda existente** para reutilizar uma função de alternância usada para outro segredo. As funções de alternância listadas em **Recommended VPC configurations** (Configurações de VPC recomendadas) têm a mesma VPC e o mesmo grupo de segurança que o banco de dados, o que ajuda a função a acessar o banco de dados.
1. Em **Estratégia de alternância**, escolha a estratégia de **Usuário único** ou de **Usuários alternados**. Para obter mais informações, consulte [Etapa 1: escolher uma estratégia de alternância e (opcionalmente) criar um segredo de superusuário](#rotate-secrets_turn-on-for-db_step1).
1. Escolha **Salvar**.
## Etapa 3: (Opcional) Defina condições de permissões adicionais na função de alternância
Na política de recursos para sua função de alternância, recomendamos incluir a chave de contexto [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) para ajudar a evitar que o Lambda seja usado como um [confused deputy](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). Para alguns AWS serviços, para evitar o cenário confuso de substituto, AWS recomenda que você use as chaves de condição [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)e as chaves de condição [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)globais. No entanto, se você incluir a condição `aws:SourceArn` em sua política de função de alternância, a função de alternância só poderá ser usada para alternar o segredo especificado por esse ARN. Recomendamos que inclua apenas a chave de contexto `aws:SourceAccount`, de modo que possa usar a função de alternância para vários segredos.
**Para atualizar sua política de recursos da função de alternância**
1. No console do Secrets Manager, escolha seu segredo e, em seguida, na página de detalhes, em **Rotation configuration** (Configuração de alternância), escolha a função de alternância do Lambda. Abra o console do Lambda.
1. Siga as instruções em [Usar políticas baseadas em recursos para o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) para adicionar uma condição `aws:sourceAccount`.
```
"Condition": {
"StringEquals": {
"AWS:SourceAccount": "123456789012"
}
},
```
Se o segredo for criptografado com uma chave KMS diferente da Chave gerenciada pela AWS `aws/secretsmanager`, o Secrets Manager concede permissão à função de execução do Lambda para usar a chave. Você pode usar o [contexto de criptografia SecretARN](security-encryption.md#security-encryption-encryption-context) para limitar o uso da função de descriptografia, de modo que a função de alternância tenha acesso apenas para descriptografar o segredo que é responsável pela alternância.
**Para atualizar o papel de execução da função de alternância**
1. Na função de alternância do Lambda, escolha **Configuração** e, em **Função de execução**, escolha o **Nome da função**.
1. Siga as instruções em [Modifying a role permissions policy (Modificar uma política de permissões de função)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) para adicionar uma condição `kms:EncryptionContext:SecretARN`.
```
"Condition": {
"StringEquals": {
"kms:EncryptionContext:SecretARN": "SecretARN"
}
},
```
## Etapa 4: configurar acesso à rede para a função de alternância
Para obter mais informações, consulte [Acesso à rede para função AWS Lambda de rotação](rotation-function-network-access.md).
## Próximas etapas
Consulte [Solucionar problemas de rotação AWS Secrets Manager](troubleshoot_rotation.md).
# Configure a rotação automática para segredos que não sejam do banco de dados AWS Secrets Manager
Este tutorial descreve como configurar [Função do Lambda de alternância](rotate-secrets_lambda.md) para segredos não de banco de dados. Alternância é o processo de atualizar periodicamente um segredo. Ao alternar um segredo, você atualiza as credenciais no segredo e no banco de dados ou serviço para o qual o segredo se destina.
Para obter informações sobre segredos do banco de dados, consulte [Alternância automática para segredos de banco de dados (console)](rotate-secrets_turn-on-for-db.md).
**Atenção**
Para ativar a alternância automática, é necessário ter permissão para criar um perfil de execução do IAM para a função de alternância do Lambda e anexar uma política de permissão a ela. Ambas as permissões `iam:CreateRole` e `iam:AttachRolePolicy` são necessárias. Conceder essas permissões permite que uma identidade conceda a ela mesma quaisquer permissões.
**Topics**
+ [
## Etapa 1: criar uma função de alternância genérica
](#rotate-secrets_turn-on-for-other_create)
+ [
## Etapa 2: programar o código da função de alternância
](#rotate-secrets_turn-on-for-other_write)
+ [
## Etapa 3: configurar o segredo para alternância
](#rotate-secrets_turn-on-for-other_configure)
+ [
## Etapa 4: permitir que a função de alternância acesse o Secrets Manager e seu banco de dados ou serviço
](#rotate-secrets_turn-on-for-other_perms)
+ [
## Etapa 5: permitir que o Secrets Manager invoque a função de alternância
](#rotate-secrets_turn-on-for-other_perms2)
+ [
## Etapa 6: configurar acesso à rede para a função de alternância
](#rotate-secrets_turn-on-for-other_network)
+ [
## Próximas etapas
](#rotate-secrets_turn-on-for-other_stepnext)
## Etapa 1: criar uma função de alternância genérica
Para começar, crie uma função de alternância do Lambda. Ela não terá o código dentro dela para alternar seu segredo, então você escreverá isso em uma etapa posterior. Para obter informações sobre como uma função de alternância funciona, consulte [Função de alternância do Lambda](rotate-secrets_lambda-functions.md).
Nas regiões suportadas, você pode usar AWS Serverless Application Repository para criar a função a partir de um modelo. Para obter uma lista de regiões compatíveis, consulte [AWS Serverless Application Repository FAQs](https://aws.amazon.com/serverless/serverlessrepo/faqs/). Em outras regiões, você cria a função do zero e copia o código do modelo na função.
**Para criar uma função de alternância genérica**
1. Para determinar se AWS Serverless Application Repository é compatível com sua região, consulte [AWS Serverless Application Repository endpoints e cotas](https://docs.aws.amazon.com/general/latest/gr/serverlessrepo.html) na Referência *AWS geral*.
1. Execute um destes procedimentos:
+ Se AWS Serverless Application Repository houver suporte em sua região:
1. No console do Lamba, escolha **Aplicações** e, em seguida, **Criar aplicação**.
1. Na página **Criar aplicação**, escolha a guia **Aplicativo com tecnologia sem servidor**.
1. Na caixa de pesquisa, em **Aplicações públicas**, insira **SecretsManagerRotationTemplate**.
1. Selecione **Mostrar aplicações que criam perfis do IAM ou políticas de recursos personalizados**.
1. Selecione o bloco **SecretsManagerRotationTemplate**.
1. Na página **Analisar, configurar e implantar**, no quadro **Configurações da aplicação**, preencha os campos obrigatórios.
+ Em **endpoint**, insira o endpoint da sua região, incluindo **https://**. Para uma lista de endpoints , consulte [AWS Secrets Manager endpoints](asm_access.md#endpoints).
+ **Para colocar a função Lambda em uma VPC, inclua Ids e. vpcSecurityGroup **vpcSubnetIds****
1. Escolha **Implantar**.
+ Se AWS Serverless Application Repository não for compatível com sua região:
1. No console do Lambda, selecione **Funções** e, em seguida, **Criar função**.
1. Na página **Create function (Criar função)**, faça o seguinte:
1. Escolha **Criar do zero**.
1. Em **Function name** (Nome da função), insira um nome para sua função de alternância.
1. Em **Runtime**, escolha **Python 3.10**.
1. Escolha a opção **Criar função**.
## Etapa 2: programar o código da função de alternância
Nesta etapa, você escreve o código que atualiza o segredo e o serviço ou banco de dados para o qual o segredo se destina. Para obter informações sobre o que uma função de alternância faz, incluindo dicas sobre como escrever sua própria função de alternância, consulte [Função de alternância do Lambda](rotate-secrets_lambda-functions.md). É possível utilizar [Modelos de função de alternância](reference_available-rotation-templates.md) como referência.
## Etapa 3: configurar o segredo para alternância
Nesta etapa, você define uma programação de alternância para seu segredo e conecta a função de alternância para o segredo.
**Para configurar a alternância e criar uma função de alternância em branco**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Na página **Secrets** (Segredos), escolha o segredo.
1. Na página **Secret details (Detalhes do segredo)**, na seção **Rotation configuration (Configuração da alternância)**, escolha **Edit rotation (Editar alternância)**. Na caixa de diálogo **Edit rotation configuration** (Editar configuração da alternância), siga estas etapas:
1. Ative a **Automatic rotation** (Alternância automática).
1. Em **Rotation schedule** (Programação da alternância), insira sua programação no fuso horário UTC no **Schedule expression builder** (Desenvolvedor de expressão programada) ou como uma **Schedule expression** (Expressão programada). O Secrets Manager armazena sua programação como uma expressão `rate()` ou `cron()`. A janela de alternância começa automaticamente à 0h, a menos que você especifique um **horário de início**. É possível alternar um segredo com intervalos a partir de quatro horas. Para obter mais informações, consulte [Programação de alternância](rotate-secrets_schedule.md).
1. (Opcional) Em **Window duration** (Duração da janela), escolha a duração da janela em que deseja que o Secrets Manager alterne o seu segredo, por exemplo, **3h**, por uma janela de três horas. A janela não pode se estender até a próxima janela de alternância. Se você não especificar **Window duration** (Duração da janela) para uma programação de alternância em horas, a janela será automaticamente encerrada após uma hora. Para uma programação de alternância em dias, a janela terminará automaticamente no final do dia.
1. (Opcional) Escolha **Rotate immediately when the secret is stored** (Alternar imediatamente quando o segredo for armazenado) para alternar o seu segredo assim que as suas alterações forem salvas. Se você desmarcar a caixa de seleção, a primeira alternância começará no cronograma definido.
1. Em **Função de alternância**, escolha a função do Lambda criada na etapa 1.
1. Escolha **Salvar**.
## Etapa 4: permitir que a função de alternância acesse o Secrets Manager e seu banco de dados ou serviço
A função de alternância do Lambda necessita de permissão para acessar o segredo no Secrets Manager e precisa de permissão para acessar seu banco de dados ou serviço. Nesta etapa, você concede essas permissões à função de execução do Lambda. Se o segredo for criptografado com uma chave KMS diferente da Chave gerenciada pela AWS `aws/secretsmanager`, será necessário conceder à função de execução do Lambda permissão para usar a chave. É possível usar o [contexto de criptografia SecretARN](security-encryption.md#security-encryption-encryption-context) para limitar o uso da função de descriptografia, para que a função de alternância tenha acesso apenas para descriptografar o segredo que é responsável pela alternância. Para obter exemplos de políticas, consulte [Permissões para alternância](rotating-secrets-required-permissions-function.md).
Para obter instruções, consulte [Função de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) no *Guia do desenvolvedor do AWS Lambda *.
## Etapa 5: permitir que o Secrets Manager invoque a função de alternância
Para permitir que o Secrets Manager invoque a função de alternância na programação de alternância que você configurou, você precisa conceder a permissão `lambda:InvokeFunction` à entidade principal do serviço Secrets Manager na política de recursos da função do Lambda.
Na política de recursos para sua função de alternância, recomendamos incluir a chave de contexto [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) para ajudar a evitar que o Lambda seja usado como um [confused deputy](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). Para alguns AWS serviços, para evitar o cenário confuso de substituto, AWS recomenda que você use as chaves de condição [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)e as chaves de condição [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)globais. No entanto, se você incluir a condição `aws:SourceArn` em sua política de função de alternância, a função de alternância só poderá ser usada para alternar o segredo especificado por esse ARN. Recomendamos que inclua apenas a chave de contexto `aws:SourceAccount`, de modo que possa usar a função de alternância para vários segredos.
Para anexar uma política de recursos a uma função do Lambda, consulte [Usar políticas baseadas em recursos para o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html).
A política a seguir permite que o Secrets Manager invoque uma função do Lambda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "default",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "secretsmanager.amazonaws.com"
},
"Action": "lambda:InvokeFunction",
"Condition": {
"StringEquals": {
"AWS:SourceAccount": "123456789012"
}
},
"Resource": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
}
]
}
```
------
## Etapa 6: configurar acesso à rede para a função de alternância
Nesta etapa, você permite que a função de alternância se conecte ao Secrets Manager e ao serviço ou banco de dados ao qual o segredo se destina. A função de alternância deve ser capaz de acessar ambos para ser capaz de alternar o segredo. Consulte [Acesso à rede para função AWS Lambda de rotação](rotation-function-network-access.md).
## Próximas etapas
Ao configurar a alternância na Etapa 3, você define uma programação para a alternância do segredo. Se a alternância falhar quando estiver programada, o Secrets Manager tentará a alternância várias vezes. Você também pode iniciar uma alternância imediatamente seguindo as instruções em [Alternar um segredo imediatamente](rotate-secrets_now.md).
Se a alternância falhar, consulte [Solucionar problemas de alternância](troubleshoot_rotation.md).
# Configure a rotação automática usando o AWS CLI
Este tutorial descreve como configurar [Função do Lambda de alternância](rotate-secrets_lambda.md) usando AWS CLI o. Ao alternar um segredo, você atualiza as credenciais no segredo e no banco de dados ou serviço para o qual o segredo se destina.
Você também pode usar o console para configurar a alternância. Para obter informações sobre segredos do banco de dados, consulte [Alternância automática para segredos de banco de dados (console)](rotate-secrets_turn-on-for-db.md). Para todos os outros tipos de segredos, consulte [Alternância automática para segredos não de banco de dados (console)](rotate-secrets_turn-on-for-other.md).
Para configurar a rotação usando o AWS CLI, se você estiver rotacionando um segredo de banco de dados, primeiro você precisa escolher uma estratégia de rotação. Se você escolher a estratégia de usuários alternados, deverá armazenar um segredo separado com credenciais para um superusuário do banco de dados. Em seguida, você programa o código da função de alternância. O Secrets Manager fornece modelos nos quais você pode basear sua função. Em seguida, você cria uma função Lambda com seu código e define permissões para a função Lambda e para a função de execução do Lambda. A próxima etapa é garantir que a função do Lambda possa acessar o Secrets Manager e seu banco de dados ou serviço utilizando a rede. Por fim, você configura o segredo para a alternância.
**Topics**
+ [
## Pré-requisito para segredos de banco de dados: escolha uma estratégia de alternância
](#rotate-secrets_turn-on-cli_step1)
+ [
## Etapa 1: escrever o código da função de alternância
](#rotate-secrets_turn-on-cli_write)
+ [
## Etapa 2: criar a função do Lambda
](#w2aac21c11c25c15)
+ [
## Etapa 3: configurar o acesso à rede
](#w2aac21c11c25c17)
+ [
## Etapa 4: configurar o segredo para alternância
](#w2aac21c11c25c19)
+ [
## Próximas etapas
](#w2aac21c11c25c21)
## Pré-requisito para segredos de banco de dados: escolha uma estratégia de alternância
Para obter informações sobre as estratégias oferecidas pelo Secrets Manager, consulte [Estratégias de alternância da função do Lambda](rotation-strategy.md).
### Opção 1: estratégia de usuário único
Se você escolher a *estratégia de usuário único*, poderá continuar com a Etapa 1.
### Opção 2: estratégia de usuários alternados
Se você escolher a *estratégia de usuários alternados*, deverá:
+ [Criar um segredo](create_secret.md#create_secret_cli) e armazenar nele as credenciais de superusuário do banco de dados. Você precisa de um segredo com credenciais de superusuário porque a rotação da alternância de usuários clona o primeiro usuário e a maioria dos usuários não tem essa permissão.
+ Adicionar o ARN do segredo do superusuário ao segredo original. Para obter mais informações, consulte [Estrutura JSON de segredos AWS Secrets Manager](reference_secret_json_structure.md).
Observe que o Amazon RDS Proxy não oferece suporte à estratégia de usuários alternados.
## Etapa 1: escrever o código da função de alternância
Para alternar um segredo, você precisa de uma função de alternância. Uma função de alternância corresponde a uma função Lambda a qual o Secrets Manager chama para alternar o segredo. Para obter mais informações, consulte [Função do Lambda de alternância](rotate-secrets_lambda.md). Nesta etapa, você escreve o código que atualiza o segredo e o serviço ou banco de dados para o qual o segredo se destina.
O Secrets Manager fornece modelos para segredos de banco de dados do Amazon RDS, Amazon Aurora, Amazon Redshift e Amazon DocumentDB em [Modelos de função de alternância](reference_available-rotation-templates.md).
**Para escrever o código da função de alternância**
1. Execute um destes procedimentos:
+ Verifique a lista de [modelos de função de alternância](reference_available-rotation-templates.md). Se houver um que corresponda à sua estratégia de serviço e alternância, copie o código.
+ Para outros tipos de segredos, você escreve sua própria função de alternância. Para instruções, consulte [Função de alternância do Lambda](rotate-secrets_lambda-functions.md).
1. Salve o arquivo em um arquivo ZIP *my-function.zip* junto com todas as dependências necessárias.
## Etapa 2: criar a função do Lambda
Nesta etapa, você cria a função do Lambda usando o arquivo ZIP criado na Etapa 1. Você também define o [perfil de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), que é o perfil que o Lambda assume quando a função é invocada.
**Para criar uma função de alternância e uma função de execução do Lambda**
1. Crie uma política de confiança para a função de execução do Lambda e salve-a como um arquivo JSON. Para obter mais informações e exemplos, consulte [Permissões da função de execução da função de rotação Lambda para AWS Secrets Manager](rotating-secrets-required-permissions-function.md). A política deve:
+ Permitir que a função chame as operações do Secrets Manager no segredo.
+ Permita que o perfil chame o serviço para o qual o segredo se destina, por exemplo, para criar uma nova senha.
1. Crie o perfil de execução do Lambda e aplique a política de confiança criada na etapa anterior chamando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html).
```
aws iam create-role \
--role-name rotation-lambda-role \
--assume-role-policy-document file://trust-policy.json
```
1. Crie a função Lambda do arquivo ZIP chamando [https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html).
```
aws lambda create-function \
--function-name my-rotation-function \
--runtime python3.7 \
--zip-file fileb://my-function.zip \
--handler .handler \
--role arn:aws:iam::123456789012:role/service-role/rotation-lambda-role
```
1. Defina uma política de recursos na função Lambda para permitir que o Secrets Manager a invoque chamando [https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html).
```
aws lambda add-permission \
--function-name my-rotation-function \
--action lambda:InvokeFunction \
--statement-id SecretsManager \
--principal secretsmanager.amazonaws.com \
--source-account 123456789012
```
## Etapa 3: configurar o acesso à rede
Para obter mais informações, consulte [Acesso à rede para função AWS Lambda de rotação](rotation-function-network-access.md).
## Etapa 4: configurar o segredo para alternância
Para ativar a alternância automática do seu segredo, determine [https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/rotate-secret.html](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/rotate-secret.html). Você pode definir uma programação de alternância com uma expressão de programação `cron()` ou `rate()` e pode definir a duração da janela de alternância. Para obter mais informações, consulte [Programação de alternância](rotate-secrets_schedule.md).
```
aws secretsmanager rotate-secret \
--secret-id MySecret \
--rotation-lambda-arn arn:aws:lambda:Region:123456789012:function:my-rotation-function \
--rotation-rules "{\"ScheduleExpression\": \"cron(0 16 1,15 * ? *)\", \"Duration\": \"2h\"}"
```
## Próximas etapas
Consulte [Solucionar problemas de rotação AWS Secrets Manager](troubleshoot_rotation.md).
# Estratégias de alternância da função do Lambda
Em [Função do Lambda de alternância](rotate-secrets_lambda.md), para segredos de bancos de dados, o Secrets Manager oferece duas estratégias de alternância.
## Estratégia de alternância: usuário único
Essa estratégia atualiza as credenciais de um único usuário em um segredo. Para instâncias do Db2 do Amazon RDS, como os usuários não podem alterar suas próprias senhas, é necessário fornecer credenciais de administrador em outro segredo. **Essa é a estratégia de alternância mais simples, e é apropriada para a maioria dos casos de uso.** Em particular, recomendamos que você use essa estratégia para obter credenciais para usuários únicos (ad hoc) ou interativos.
Quando o segredo é alternado, as conexões de banco de dados abertas não são descartadas. Enquanto a alternância acontece, há um curto período entre a alteração da senha no banco de dados e a atualização do segredo. Durante esse período, há um baixo risco de o banco de dados recusar chamadas que usam as credenciais alternadas. É possível mitigar esse risco com uma [estratégia de nova tentativa apropriada](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/). Após a alternância, as novas conexões usam as novas credenciais.
## Estratégia de alternância: usuários alternados
Essa estratégia atualiza as credenciais de dois usuários em um segredo. Você cria o primeiro usuário e, durante a primeira alternância, a função de alternância o clona para criar o segundo usuário. Toda vez que o segredo é alternado, a função de alternância alterna a senha do usuário que ela atualiza. Como a maioria dos usuários não tem permissão para se clonar, é necessário fornecer as credenciais para um `superuser` em outro segredo. Recomendamos o uso da estratégia de alternância de usuário único quando os usuários clonados em seu banco de dados não tiverem as mesmas permissões que o usuário original, e para credenciais de usuários únicos (ad hoc) ou interativos.
Essa estratégia é apropriada para bancos de dados com modelos de permissão em que uma função possui as tabelas de banco de dados e uma segunda função tem permissão para acessar as tabelas de banco de dados. Ela também é apropriada para aplicações que requerem alta disponibilidade. Se uma aplicação recuperar o segredo durante a alternância, a aplicação ainda obterá um conjunto válido de credenciais. Após a alternância, as credenciais do `user` e do `user_clone` são válidas. Há ainda menos chances de aplicações serem recusadas durante esse tipo de alternância em comparação com a alternância de usuário único. Se o banco de dados estiver hospedado em um farm de servidores em que a alteração de senha demora algum tempo para se propagar para todos os servidores, existe o risco de o banco de dados recusar chamadas que usam as novas credenciais. É possível mitigar esse risco com uma [estratégia de nova tentativa apropriada](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/).
O Secrets Manager cria o usuário clonado com as mesmas permissões do usuário original. Se você alterar as permissões do usuário original após a criação do clone, também deverá alterar as permissões do usuário clonado.
Por exemplo, se você criar um segredo com as credenciais de um usuário do banco de dados, o segredo conterá uma versão com essas credenciais.
![\[The secret contains one secret version labeled AWSCURRENT. The username for the AWSCURRENT version is MyUser.\]](http://docs.aws.amazon.com/pt_br/secretsmanager/latest/userguide/images/AlternatingUsers1.png)
**Primeira alternância**: a função de alternância cria um clone do seu usuário com uma senha gerada e essas credenciais se tornam a versão do segredo atual.
![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser_clone.\]](http://docs.aws.amazon.com/pt_br/secretsmanager/latest/userguide/images/AlternatingUsers2.png)
**Segunda alternância**: a função de alternância atualiza a senha do usuário original.
![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser.\]](http://docs.aws.amazon.com/pt_br/secretsmanager/latest/userguide/images/AlternatingUsers3.png)
**Terceira alternância**: a função de alternância atualiza a senha do usuário clonado.
![\[The secret contains two secret versions, one labeled AWSCURRENT and one labeled AWSPREVIOUS. The username for the AWSCURRENT version is MyUser_clone.\]](http://docs.aws.amazon.com/pt_br/secretsmanager/latest/userguide/images/AlternatingUsers4.png)
# Função de alternância do Lambda
Em[Função do Lambda de alternância](rotate-secrets_lambda.md), uma AWS Lambda função gira o segredo. AWS Secrets Manager usa [rótulos de teste](whats-in-a-secret.md) para identificar versões secretas durante a rotação.
Se AWS Secrets Manager não fornecer um [modelo de função de rotação](reference_available-rotation-templates.md) para seu tipo de segredo, você pode criar uma função de rotação personalizada. Siga estas diretrizes ao escrever sua função de alternância:
**Práticas recomendadas para funções de alternância personalizadas**
+ Use o [modelo de alternância genérico](reference_available-rotation-templates.md#OTHER_rotation_templates) como ponto de partida.
+ Tenha cuidado com as instruções de depuração ou registro em log. Eles podem gravar informações no Amazon CloudWatch Logs. Certifique-se de que os logs não contenham informações confidenciais.
Para exemplos de instruções de log, consulte o código-fonte dos [AWS Secrets Manager modelos de função de rotação](reference_available-rotation-templates.md).
+ Por segurança, permite AWS Secrets Manager apenas que uma função de rotação Lambda gire o segredo diretamente. A função de alternância não pode chamar uma outra função do Lambda para alternar o segredo.
+ Para orientações sobre depuração, consulte [Teste e depuração de aplicações com tecnologia sem servidor](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-test-and-debug.html).
+ Se você usar binários e bibliotecas externas, por exemplo, para se conectar a um recurso, será responsável pela aplicação de patches e atualizações.
+ Package sua função de rotação e quaisquer dependências em um arquivo ZIP, como*my-function.zip*.
**Atenção**
Definir o parâmetro de simultaneidade provisionado como um valor menor que 10 pode causar limitação devido à insuficiência de threads de execução para a função do Lambda. Para obter mais informações, consulte [Noções básicas sobre simultaneidade reservada e simultaneidade provisionada](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned) no Guia do desenvolvedor do AWS Lambda AWS Lambda .
## Quatro etapas em uma função de alternância
**Topics**
+ [
### `createSecret`: criar uma nova versão do segredo
](#w2aac21c11c29c11b5)
+ [
### **setSecret**: alterar as credenciais no banco de dados ou serviço
](#w2aac21c11c29c11b7)
+ [
### **testSecret**: testar a nova versão do segredo
](#w2aac21c11c29c11b9)
+ [
### **finishSecret**: concluir a alternância
](#w2aac21c11c29c11c11)
### `createSecret`: criar uma nova versão do segredo
O método `createSecret` primeiro verifica se existe um segredo chamando [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_secret_value](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_secret_value) com o `ClientRequestToken` aprovado. Se não houver segredo, ele cria um novo segredo com [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.create_secret](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.create_secret) e o token como `VersionId`. Em seguida, ele gera um novo valor de segredo com [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_random_password](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_random_password). Depois ele chama [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.put_secret_value](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.put_secret_value) para armazená-lo com o rótulo de preparação `AWSPENDING`. Armazenar o novo valor do segredo em `AWSPENDING` ajuda a garantir a idempotência. Se a alternância falhar por qualquer motivo, será possível consultar esse valor de segredo em chamadas subsequentes. Consulte [Como torno minha função do Lambda idempotente?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
**Dicas para escrever sua própria função de alternância**
+ Certifique-se de que o novo valor do segredo inclua apenas caracteres válidos para o banco de dados ou serviço. Exclua caracteres usando o parâmetro `ExcludeCharacters`.
+ Ao testar sua função, use o AWS CLI para ver os estágios da versão: chame [https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html)e examine`VersionIdsToStages`.
+ Para o Amazon RDS MySQL, o Secrets Manager cria um usuário clonado com um nome de no máximo 16 caracteres no rodízio de usuários em alternância. É possível modificar a função de rodízio para permitir nomes de usuário mais longos. A versão 5.7 e superior do MySQL é compatível com nomes de usuário de até 32 caracteres. No entanto, o Secrets Manager acrescenta “\$1clone” (seis caracteres) ao final do nome de usuário, portanto, é necessário manter o nome de usuário com no máximo 26 caracteres.
### **setSecret**: alterar as credenciais no banco de dados ou serviço
O método `setSecret` altera a credencial no banco de dados ou serviço para corresponder ao novo valor do segredo na versão `AWSPENDING` do segredo.
**Dicas para escrever sua própria função de alternância**
+ Se você transmitir instruções para um serviço que interprete instruções, como um banco de dados, use a parametrização de consulta. Para obter mais informações, consulte a [Folha de dicas de parametrização de consultas](https://cheatsheetseries.owasp.org/cheatsheets/Query_Parameterization_Cheat_Sheet.html) no *site da OWASP*.
+ A função de alternância é um representante privilegiado que tem autorização para acessar e modificar as credenciais do cliente no segredo do Secrets Manager e no recurso de destino. Para evitar um possível [ataque “confused deputy”](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html), você precisa garantir que um invasor não possa usar a função para acessar outros recursos. Antes de atualizar a credencial:
+ Verifique se a credencial na versão `AWSCURRENT` do segredo é válida. Se a credencial `AWSCURRENT` não for válida, abandone a tentativa de alternância.
+ Verifique se os valores dos segredos `AWSCURRENT` e `AWSPENDING` são para o mesmo recurso. Para obter um nome de usuário e uma senha, verifique se os nomes de usuário `AWSCURRENT` e `AWSPENDING` são os mesmos.
+ Verifique se o recurso do serviço de destino é o mesmo. Para um banco de dados, verifique se os nomes de host `AWSCURRENT` e `AWSPENDING` são os mesmos.
+ Em casos raros, talvez você queira personalizar a função de alternância existente para um banco de dados. Por exemplo, com o rodízio de usuários em alternância, o Secrets Manager cria o usuário clonado copiando os [parâmetros de configuração de runtime](https://www.postgresql.org/docs/8.0/runtime-config.html) do primeiro usuário. Se você quiser incluir mais atributos ou alterar quais são concedidos ao usuário clonado, é necessário atualizar o código na função `set_secret`.
### **testSecret**: testar a nova versão do segredo
Em seguida, a função de alternância do Lambda testará a versão `AWSPENDING` do segredo usando-a para acessar o banco de dados ou serviço. As funções de alternância baseadas em [Modelos de função de alternância](reference_available-rotation-templates.md) testam o novo segredo usando o acesso de leitura.
### **finishSecret**: concluir a alternância
Por fim, a função de alternância do Lambda move o rótulo `AWSCURRENT` da versão anterior do segredo para a atual, o que também remove o rótulo `AWSPENDING` na mesma chamada de API. O Secrets Manager adiciona o rótulo de preparação prévia `AWSPREVIOUS` na versão anterior, para que você retenha a última versão boa conhecida do segredo.
O método **finish\$1secret** usa [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.update_secret_version_stage](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.update_secret_version_stage) para mover o rótulo de preparação `AWSCURRENT` da versão do segredo anterior para a nova versão do segredo. O Secrets Manager adiciona automaticamente o rótulo de preparação `AWSPREVIOUS` à versão anterior para reter a última versão válida do segredo.
**Dicas para escrever sua própria função de alternância**
+ Não remova `AWSPENDING` antes desse ponto, e não remova-o por meio de uma chamada de API distinta. Isso pode indicar ao Secrets Manager que a alternância não foi concluída com êxito. O Secrets Manager adiciona o rótulo de preparação prévia `AWSPREVIOUS` na versão anterior, para que você retenha a última versão boa conhecida do segredo.
Quando a alternância for bem-sucedida, talvez o rótulo de preparação de `AWSPENDING` seja anexado à mesma versão da versão `AWSCURRENT` ou talvez não seja anexado a nenhuma versão. Se o rótulo de preparação de `AWSPENDING` estiver presente, mas não estiver anexado à mesma versão de `AWSCURRENT`, qualquer invocação posterior de alternância vai pressupor que uma solicitação de alternância anterior ainda está em andamento e retornará um erro. Quando a alternância não for bem-sucedida, o rótulo de preparação de `AWSPENDING` poderá ser anexado a uma versão vazia de segredo. Para obter mais informações, consulte [Solucionar problemas de alternância](troubleshoot_rotation.md).
# AWS Secrets Manager modelos de função de rotação
AWS Secrets Manager fornece um conjunto de modelos de função de rotação que ajudam a automatizar o gerenciamento seguro de credenciais para vários sistemas e serviços de banco de dados. Os modelos são funções ready-to-use Lambda que implementam as melhores práticas para rotação de credenciais, ajudando você a manter sua postura de segurança sem intervenção manual.
Os modelos oferecem suporte a duas estratégias principais de alternância:
+ *Alternância de usuário único*, que atualiza as credenciais de um único usuário.
+ *Alternância de usuários alternados*, que mantém dois usuários separados para ajudar a eliminar o tempo de inatividade durante mudanças de credenciais.
O Secrets Manager também fornece um modelo genérico que serve como ponto de partida para qualquer tipo de segredo.
Para usar os modelos, consulte:
+ [Alternância automática para segredos de banco de dados (console)](rotate-secrets_turn-on-for-db.md)
+ [Alternância automática para segredos não de banco de dados (console)](rotate-secrets_turn-on-for-other.md)
Para escrever sua própria função de alternância, consulte [Escrever uma função de alternância](rotate-secrets_lambda-functions.md).
**Contents**
+ [
## Amazon RDS e Amazon Aurora
](#RDS_rotation_templates)
+ [
### Usuário único do Db2 do Amazon RDS
](#sar-template-db2-singleuser)
+ [
### Usuários em alternância do Db2 do Amazon RDS
](#sar-template-db2-multiuser)
+ [
### Usuário único do MariaDB do Amazon RDS
](#sar-template-mariadb-singleuser)
+ [
### Usuários alternados do MariaDB do Amazon RDS
](#sar-template-mariadb-multiuser)
+ [
### Usuário único do Amazon RDS e do Amazon Aurora MySQL
](#sar-template-mysql-singleuser)
+ [
### Usuários em alternância do Amazon RDS e do Amazon Aurora MySQL
](#sar-template-mysql-multiuser)
+ [
### Usuário único do Oracle do Amazon RDS
](#sar-template-oracle-singleuser)
+ [
### Usuários alternados do Oracle do Amazon RDS
](#sar-template-oracle-multiuser)
+ [
### Usuário único do Amazon RDS e do Amazon Aurora PostgreSQL
](#sar-template-postgre-singleuser)
+ [
### Usuários em alternância do Amazon RDS e do Amazon Aurora PostgreSQL
](#sar-template-postgre-multiuser)
+ [
### Amazon RDS Microsoft (usuário SQLServer único)
](#sar-template-sqlserver-singleuser)
+ [
### Amazon RDS Microsoft (usuários SQLServer alternados)
](#sar-template-sqlserver-multiuser)
+ [
## Amazon DocumentDB (compatível com MongoDB)
](#NON-RDS_rotation_templates)
+ [
### Usuário único do Amazon DocumentDB
](#sar-template-mongodb-singleuser)
+ [
### Usuários alternados do Amazon DocumentDB
](#sar-template-mongodb-multiuser)
+ [
## banco de dados de origem
](#template-redshift)
+ [
### Usuário único do Amazon Redshift
](#sar-template-redshift-singleuser)
+ [
### Usuários alternados do Amazon Redshift
](#sar-template-redshift-multiuser)
+ [
## Amazon Timestream para InfluxDB
](#template-TimeStream)
+ [
### Usuário único do Amazon Timestream para InfluxDB
](#template-TimeStream-singleuser)
+ [
### Usuário alternados do Amazon Timestream para InfluxDB
](#template-TimeStream-multiuser)
+ [
## Amazon ElastiCache
](#template-ELC)
+ [
## Active Directory
](#template-AD)
+ [
### Credenciais do Active Directory
](#template-AD-password)
+ [
### Atributos do Active Directory
](#template-AD-keytab)
+ [
## Outros tipos de segredo
](#OTHER_rotation_templates)
## Amazon RDS e Amazon Aurora
### Usuário único do Db2 do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSDb2 RotationSingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSDb2RotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationSingleUser/lambda_function.py)
+ **Dependência: **[python-ibmdb](https://github.com/ibmdb/python-ibmdb)
### Usuários em alternância do Db2 do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSDb2 RotationMultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSDb2RotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSDb2RotationMultiUser/lambda_function.py)
+ **Dependência: **[python-ibmdb](https://github.com/ibmdb/python-ibmdb)
### Usuário único do MariaDB do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSMaria DBRotation SingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSMariaDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationSingleUser/lambda_function.py)
+ **Dependência:** PyMy SQL 1.0.2. Se você usar a senha sha256 para autenticação, PyMy SQL [rsa]. Para obter informações sobre o uso de pacotes com código compilado em um runtime do Lambda, consulte [Como faço para adicionar pacotes Python com binários compilados ao meu pacote de implantação e tornar o pacote compatível com o Lambda?](https://repost.aws/knowledge-center/lambda-python-package-compatible) no *Centro de Conhecimentos da AWS *.
### Usuários alternados do MariaDB do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSMaria DBRotation MultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSMariaDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMariaDBRotationMultiUser/lambda_function.py)
+ **Dependência:** PyMy SQL 1.0.2. Se você usar a senha sha256 para autenticação, PyMy SQL [rsa]. Para obter informações sobre o uso de pacotes com código compilado em um runtime do Lambda, consulte [Como faço para adicionar pacotes Python com binários compilados ao meu pacote de implantação e tornar o pacote compatível com o Lambda?](https://repost.aws/knowledge-center/lambda-python-package-compatible) no *Centro de Conhecimentos da AWS *.
### Usuário único do Amazon RDS e do Amazon Aurora MySQL
+ **Nome do modelo:** SecretsManager RDSMy SQLRotation SingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSMySQLRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationSingleUser/lambda_function.py)
+ **Dependência:** PyMy SQL 1.0.2. Se você usar a senha sha256 para autenticação, PyMy SQL [rsa]. Para obter informações sobre o uso de pacotes com código compilado em um runtime do Lambda, consulte [Como faço para adicionar pacotes Python com binários compilados ao meu pacote de implantação e tornar o pacote compatível com o Lambda?](https://repost.aws/knowledge-center/lambda-python-package-compatible) no *Centro de Conhecimentos da AWS *.
### Usuários em alternância do Amazon RDS e do Amazon Aurora MySQL
+ **Nome do modelo:** SecretsManager RDSMy SQLRotation MultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSMySQLRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSMySQLRotationMultiUser/lambda_function.py)
+ **Dependência:** PyMy SQL 1.0.2. Se você usar a senha sha256 para autenticação, PyMy SQL [rsa]. Para obter informações sobre o uso de pacotes com código compilado em um runtime do Lambda, consulte [Como faço para adicionar pacotes Python com binários compilados ao meu pacote de implantação e tornar o pacote compatível com o Lambda?](https://repost.aws/knowledge-center/lambda-python-package-compatible) no *Centro de Conhecimentos da AWS *.
### Usuário único do Oracle do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSOracle RotationSingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSOracleRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationSingleUser/lambda_function.py)
+ **Dependência:** [python-oracledb](https://github.com/oracle/python-oracledb) 2.4.1
### Usuários alternados do Oracle do Amazon RDS
+ **Nome do modelo:** SecretsManager RDSOracle RotationMultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSOracleRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSOracleRotationMultiUser/lambda_function.py)
+ **Dependência:** [python-oracledb](https://github.com/oracle/python-oracledb) 2.4.1
### Usuário único do Amazon RDS e do Amazon Aurora PostgreSQL
+ **Nome do modelo:** SecretsManager RDSPostgre SQLRotation SingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationSingleUser/lambda_function.py)
+ **Dependência: PyGre SQL 5.2.5**
### Usuários em alternância do Amazon RDS e do Amazon Aurora PostgreSQL
+ **Nome do modelo:** SecretsManager RDSPostgre SQLRotation MultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSPostgreSQLRotationMultiUser/lambda_function.py)
+ **Dependência: PyGre SQL 5.2.5**
### Amazon RDS Microsoft (usuário SQLServer único)
+ **Nome do modelo:** SecretsManager RDSSQLServer RotationSingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSSQLServerRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationSingleUser/lambda_function.py)
+ **Dependência: **Pymssql 2.2.2
### Amazon RDS Microsoft (usuários SQLServer alternados)
+ **Nome do modelo:** SecretsManager RDSSQLServer RotationMultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon RDS e do Aurora](reference_secret_json_structure.md#reference_secret_json_structure_rds).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRDSSQLServerRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRDSSQLServerRotationMultiUser/lambda_function.py)
+ **Dependência: **Pymssql 2.2.2
## Amazon DocumentDB (compatível com MongoDB)
### Usuário único do Amazon DocumentDB
+ **Nome do modelo:** SecretsManagerMongo DBRotation SingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon DocumentDB](reference_secret_json_structure.md#reference_secret_json_structure_docdb).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerMongoDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationSingleUser/lambda_function.py)
+ **Dependência: 4.2.0** PyMongo
### Usuários alternados do Amazon DocumentDB
+ **Nome do modelo:** SecretsManagerMongo DBRotation MultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon DocumentDB](reference_secret_json_structure.md#reference_secret_json_structure_docdb).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerMongoDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerMongoDBRotationMultiUser/lambda_function.py)
+ **Dependência: 4.2.0** PyMongo
## banco de dados de origem
### Usuário único do Amazon Redshift
+ **Nome do modelo:** SecretsManagerRedshiftRotationSingleUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuário único](rotation-strategy.md#rotating-secrets-one-user-one-password).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon Redshift](reference_secret_json_structure.md#reference_secret_json_structure_RS).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRedshiftRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationSingleUser/lambda_function.py)
+ **Dependência: PyGre SQL 5.2.5**
### Usuários alternados do Amazon Redshift
+ **Nome do modelo:** SecretsManagerRedshiftRotationMultiUser
+ **Estratégia de alternância:** [Estratégia de alternância: usuários alternados](rotation-strategy.md#rotating-secrets-two-users).
+ **Estrutura esperada da `SecretString`:** [Credenciais do Amazon Redshift](reference_secret_json_structure.md#reference_secret_json_structure_RS).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRedshiftRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRedshiftRotationMultiUser/lambda_function.py)
+ **Dependência: PyGre SQL 5.2.5**
## Amazon Timestream para InfluxDB
Para usar esses modelos, consulte [Como o Amazon Timestream para InfluxDB usa segredos](https://docs.aws.amazon.com/timestream/latest/developerguide/timestream-for-influx-security-db-secrets.html) no *Guia do desenvolvedor do Amazon Timestream*.
### Usuário único do Amazon Timestream para InfluxDB
+ **Nome do modelo:** SecretsManager Influx DBRotation SingleUser
+ **Estrutura esperada da `SecretString`:** [Estrutura de segredo do Amazon Timestream para InfluxDB](reference_secret_json_structure.md#reference_secret_json_structure_TIME).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerInfluxDBRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationSingleUser/lambda_function.py)
+ **Dependência: **cliente python do InfluxDB 2.0
### Usuário alternados do Amazon Timestream para InfluxDB
+ **Nome do modelo:** SecretsManagerInflux DBRotation MultiUser
+ **Estrutura esperada da `SecretString`:** [Estrutura de segredo do Amazon Timestream para InfluxDB](reference_secret_json_structure.md#reference_secret_json_structure_TIME).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerInfluxDBRotationMultiUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerInfluxDBRotationMultiUser/lambda_function.py)
+ **Dependência: **cliente python do InfluxDB 2.0
## Amazon ElastiCache
Para usar esse modelo, consulte [Rotação automática de senhas para usuários](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/User-Secrets-Manager.html) no *Guia do ElastiCache usuário da Amazon*.
+ **Nome do modelo:** SecretsManagerElasticacheUserRotation
+ **Estrutura esperada da `SecretString`:** [ElastiCache Credenciais da Amazon](reference_secret_json_structure.md#reference_secret_json_structure_ELC).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerElasticacheUserRotation/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerElasticacheUserRotation/lambda_function.py)
## Active Directory
### Credenciais do Active Directory
+ **Nome do modelo:** SecretsManagerActiveDirectoryRotationSingleUser
+ **Estrutura esperada da `SecretString`:** [Credenciais do Active Directory](reference_secret_json_structure.md#reference_secret_json_structure_AD).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerActiveDirectoryRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryRotationSingleUser/lambda_function.py)
### Atributos do Active Directory
+ **Nome do modelo:** SecretsManagerActiveDirectoryAndKeytabRotationSingleUser
+ **Estrutura esperada da `SecretString`:** [Credenciais do Active Directory](reference_secret_json_structure.md#reference_secret_json_structure_AD).
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerActiveDirectoryAndKeytabRotationSingleUser/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerActiveDirectoryAndKeytabRotationSingleUser/lambda_function.py)
+ **Dependências:** msktutil
## Outros tipos de segredo
O Secrets Manager fornece esse modelo como ponto de partida para você criar uma função de alternância para qualquer tipo de segredo.
+ **Nome do modelo:** SecretsManagerRotationTemplate
+ **Código fonte: https://github.com/aws-samples/** [aws-secrets-manager-rotation- lambdas/tree/master/SecretsManagerRotationTemplate/lambda \$1function.py](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas/tree/master/SecretsManagerRotationTemplate/lambda_function.py)
# Permissões da função de execução da função de rotação Lambda para AWS Secrets Manager
Em [Função do Lambda de alternância](rotate-secrets_lambda.md), quando o Secrets Manager usa uma função do Lambda para alternar um segredo, o Lamba assume um [perfil de execução do IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) e fornece essas credenciais ao código da função do Lambda. Para obter instruções sobre como configurar a alternância automática, consulte:
+ [Alternância automática para segredos de banco de dados (console)](rotate-secrets_turn-on-for-db.md)
+ [Alternância automática para segredos não de banco de dados (console)](rotate-secrets_turn-on-for-other.md)
+ [Alternância automática (AWS CLI)](rotate-secrets_turn-on-cli.md)
Os exemplos a seguir mostram políticas em linha para funções de execução da função de alternância do Lambda. Para criar uma função de execução e anexá-la a uma política de permissões, consulte [Perfil de execução do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html).
**Topics**
+ [
## Política para uma função de execução da função de alternância do Lambda
](#rotating-secrets-required-permissions-function-example)
+ [
## Declaração de política para chaves gerenciadas pelo cliente
](#rotating-secrets-required-permissions-function-cust-key-example)
+ [
## Declaração de política para a estratégia de usuários alternados
](#rotating-secrets-required-permissions-function-alternating-example)
## Política para uma função de execução da função de alternância do Lambda
A política de exemplo a seguir permite que a função de alternância:
+ Execute as operações do Secrets Manager para*SecretARN*.
+ Criar uma nova senha.
+ Definir a configuração necessária se seu banco de dados ou serviço for executado em uma VPC. Consulte [Configuring a Lambda function to access resources in a VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html) (Configurar uma função do Lambda para acessar recursos em uma VPC).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
},
{
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
## Declaração de política para chaves gerenciadas pelo cliente
Se o segredo for criptografado com uma chave KMS diferente da Chave gerenciada pela AWS `aws/secretsmanager`, será necessário conceder à função de execução do Lambda permissão para usar a chave. Você pode usar o [contexto de criptografia SecretARN](security-encryption.md#security-encryption-encryption-context) para limitar o uso da função de descriptografia, para que a função de alternância tenha acesso apenas para descriptografar o segredo que é responsável pela rotação. O exemplo a seguir mostra uma instrução a ser adicionada à política de função de execução para descriptografar o segredo usando a chave KMS.
```
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKey"
],
"Resource": "KMSKeyARN",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:SecretARN": "SecretARN"
}
}
}
```
Para usar a função de alternância para vários segredos criptografados com uma chave gerenciada pelo cliente, adicione uma declaração como o exemplo a seguir para permitir que o perfil de execução decifre o segredo.
```
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKey"
],
"Resource": "KMSKeyARN",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:SecretARN": [
"arn1",
"arn2"
]
}
}
}
```
## Declaração de política para a estratégia de usuários alternados
Para obter informações sobre a *estratégia de alternância de usuários alternados*, consulte [Estratégias de alternância da função do Lambda](rotation-strategy.md).
Para um segredo que contém credenciais do Amazon RDS, se você estiver usando a estratégia de usuários alternados e o segredo do superusuário for gerenciado [pelo Amazon RDS](rotate-secrets_managed.md), você também deverá permitir que a função de rotação chame somente leitura no APIs Amazon RDS para que ela possa obter as informações de conexão do banco de dados. Recomendamos que você anexe a política AWS gerenciada [da Amazon RDSRead OnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html).
O exemplo de política a seguir permite que a função:
+ Execute as operações do Secrets Manager para*SecretARN*.
+ Recupere as credenciais no segredo do superusuário. O Secrets Manager usa as credenciais no segredo do superusuário para atualizar as credenciais no segredo que está sendo alternado.
+ Criar uma nova senha.
+ Definir a configuração necessária se seu banco de dados ou serviço for executado em uma VPC. Para obter mais informações, consulte [Configuração de uma função do Lambda para acessar recursos em uma VPC](https://docs.aws.amazon.com/lambda/latest/dg/vpc.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
},
{
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
```
------
# Acesso à rede para função AWS Lambda de rotação
Em [Função do Lambda de alternância](rotate-secrets_lambda.md), quando o Secrets Manager usa uma função do Lambda para alternar um segredo, a função de alternância do Lambda deve ser capaz de acessar o segredo. Se seu segredo contiver credenciais, a função do Lambda também deverá poder acessar a fonte dessas credenciais, como um banco de dados ou serviço.
**Para acessar um segredo**
A função de alternância do Lambda deve ser capaz de acessar um endpoint do Secrets Manager. Se sua função do Lambda puder acessar a Internet, é possível usar um endpoint público. Para localizar um endpoint, consulte [AWS Secrets Manager endpoints](asm_access.md#endpoints).
Se a função do Lambda for executada em uma VPC que não tem acesso à Internet, recomendamos que você configure endpoints privados de serviço do Secrets Manager dentro de sua VPC. Assim, sua VPC pode interceptar solicitações endereçadas ao endpoint regional público e redirecioná-las para o endpoint privado. Para obter mais informações, consulte [Endpoints da VPC (AWS PrivateLink)](vpc-endpoint-overview.md).
Como alternativa, é possível habilitar a função do Lambda para acessar um endpoint público do Secrets Manager adicionando um [gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) ou um [gateway da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) à VPC, o que permite que o tráfego da VPC alcance o endpoint público. Isso expõe a VPC a um risco maior, pois um endereço IP do gateway pode ser atacado a partir da Internet pública.
**(Opcional) para acessar o banco de dados ou o serviço**
Para segredos como chaves de API, não há banco de dados ou serviço de origem que você precise atualizar junto com o segredo.
Se seu banco de dados ou serviço estiver sendo executado em uma EC2 instância da Amazon em uma VPC, recomendamos que você configure sua função Lambda para ser executada na mesma VPC. Assim, a função de alternância pode se comunicar diretamente com seu serviço. Para obter mais informações, consulte [Configuring VPC access](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-configuring) (Configurar o acesso à VPC).
Para permitir que a função do Lambda acesse o banco de dados ou serviço, certifique-se de que os grupos de segurança anexados à sua função de alternância do Lambda permitam conexões de saída com o banco de dados ou serviço. Você também deve garantir que os grupos de segurança anexados ao seu banco de dados ou serviço permitam conexões de entrada a partir da função de alternância do Lambda.
# Solucionar problemas de rotação AWS Secrets Manager
Em muitos serviços, o Secrets Manager usa uma função do Lambda para alternar segredos. Para obter mais informações, consulte [Função do Lambda de alternância](rotate-secrets_lambda.md). A função de alternância do Lambda interage com o banco de dados ou serviço para o qual o segredo se destina, bem como o Secrets Manager. Quando a rotação não funciona da maneira esperada, você deve primeiro verificar os CloudWatch registros.
**nota**
Alguns serviços podem gerenciar segredos para você, incluindo o gerenciamento da alternância automática. Para obter mais informações, consulte [Rotação gerenciada para AWS Secrets Manager segredos](rotate-secrets_managed.md).
**Topics**
+ [
## Como solucionar falhas de rotação secreta em funções AWS Lambda
](#troubleshooting-secret-rotation-failures)
+ [
## Nenhuma atividade após “Found credentials in environment variables” (Credenciais encontradas em variáveis de ambiente)
](#troubleshoot_rotation_timing-out)
+ [
## Nenhuma atividade após “createSecret”
](#troubleshoot_rotation_createSecret)
+ [
## Erro: “O acesso ao KMS não é permitido”
](#troubleshoot_rotation_kms-key)
+ [
## Erro: “Key is missing from secret JSON” (A chave do segredo JSON está ausente)
](#tshoot-lambda-mismatched-secretvalue)
+ [
## Erro: “setSecret: Unable to log into database” (setSecret: não é possível fazer login no banco de dados)
](#troubleshoot_rotation_setSecret)
+ [
## Erro: “Não é possível importar o módulo ‘lambda\$1function’"
](#tshoot-python-version)
+ [
## Atualize uma função de alternância existente do Python 3.7 para 3.9
](#troubleshoot_rotation_python39)
+ [
## Atualize uma função de alternância existente de Python 3.9 para 3.10
](#troubleshoot_rotation_python_310)
+ [
## AWS Lambda rotação secreta com `PutSecretValue` falha
](#troubleshoot_rotation_putsecretvalue)
+ [
## Erro: “Erro ao executar lambda ** durante a ** etapa”
](#concurrency-related-failures)
## Como solucionar falhas de rotação secreta em funções AWS Lambda
Se estiver enfrentando falhas de alternância de segredo nas funções do Lambda, use as etapas a seguir para solucionar o problema.
### Possíveis causas
+ Execuções simultâneas insuficientes para a função do Lambda
+ Condições de corrida devido a várias chamadas de API durante a alternância
+ Lógica incorreta da função do Lambda
+ Problemas de rede entre a função do Lambda e o banco de dados
### Etapas gerais de solução de problemas
1. Analise CloudWatch os registros:
+ Procure por mensagens de erro específicas ou comportamentos inesperados nos logs das funções do Lambda
+ Verifique se todas as etapas de alternância (**CreateSecret**, **SetSecret**, **TestSecret**, **FinishSecret**) estão sendo tentadas
1. Analise as chamadas de API durante a alternância:
+ Evite fazer chamadas de API mutantes no segredo durante a alternância do Lambda
+ Certifique-se de que não haja condições de corrida entre as chamadas **RotateSecret** e **PutSecretValue**
1. Verifique a lógica da função do Lambda:
+ Confirme se você está usando o código de AWS amostra mais recente para rotação secreta
+ Se estiver usando código personalizado, revise-o para verificar o tratamento adequado de todas as etapas da alternância
1. Verifique a configuração da rede:
+ Verifique se as regras do grupo de segurança permitem que a função do Lambda acesse o banco de dados
+ Garanta o acesso adequado ao endpoint da VPC ou ao endpoint público para o Secrets Manager
1. Teste as versões do segredo:
+ Verifique se a AWSCURRENT versão do segredo permite acesso ao banco de dados
+ Verifique se AWSPREVIOUS nossas AWSPENDING versões são válidas
1. Limpe as alternâncias pendentes:
+ Se a rotação falhar consistentemente, limpe a etiqueta AWSPENDING de preparação e tente novamente a rotação
1. Verifique as configurações de simultaneidade do Lambda:
+ Verifique se as configurações de simultaneidade são apropriadas para sua workload
+ Se você suspeitar de problemas de simultaneidade, consulte a seção “Solução de falhas de alternância relacionadas à simultaneidade”
## Nenhuma atividade após “Found credentials in environment variables” (Credenciais encontradas em variáveis de ambiente)
Se não houver atividade após "Credenciais encontradas em variáveis de ambiente" e a duração da tarefa for longa, por exemplo, o tempo limite padrão do Lambda de 30 mil milissegundos, a função do Lambda pode estar expirando ao tentar alcançar o endpoint do Secrets Manager.
A função de alternância do Lambda deve ser capaz de acessar um endpoint do Secrets Manager. Se sua função do Lambda puder acessar a Internet, é possível usar um endpoint público. Para localizar um endpoint, consulte [AWS Secrets Manager endpoints](asm_access.md#endpoints).
Se a função do Lambda for executada em uma VPC que não tem acesso à Internet, recomendamos que você configure endpoints privados de serviço do Secrets Manager dentro de sua VPC. Assim, sua VPC pode interceptar solicitações endereçadas ao endpoint regional público e redirecioná-las para o endpoint privado. Para obter mais informações, consulte [Endpoints da VPC (AWS PrivateLink)](vpc-endpoint-overview.md).
Como alternativa, é possível habilitar a função do Lambda para acessar um endpoint público do Secrets Manager adicionando um [gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) ou um [gateway da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) à VPC, o que permite que o tráfego da VPC alcance o endpoint público. Isso expõe a VPC a um risco maior, pois um endereço IP do gateway pode ser atacado a partir da Internet pública.
## Nenhuma atividade após “createSecret”
A seguir, estão os problemas que podem fazer com que a alternância pare após createSecret:
**A rede VPC ACLs não permite entrada e saída de tráfego HTTPS.**
Para obter mais informações, consulte [Controle o tráfego para sub-redes usando a rede ACLs no Guia](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html) do usuário da Amazon *VPC*.
**A configuração de tempo limite da função do Lambda é muito curta para executar a tarefa. **
Para obter mais informações, consulte [Configurar as opções da função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) no *Guia do desenvolvedor do AWS Lambda *.
**O endpoint VPC do Secrets Manager não permite que a VPC entre CIDRs nos grupos de segurança atribuídos. **
Para obter mais informações, consulte [Controle o tráfego para recursos usando grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no *Guia do usuário da Amazon VPC*.
**A política de endpoint da VPC do Secrets Manager não permite que o Lambda use o endpoint da VPC. **
Para obter mais informações, consulte [Usando um AWS Secrets Manager VPC endpoint](vpc-endpoint-overview.md).
**O segredo usa a alternância de usuários alternados, o segredo do superusuário é gerenciado pelo Amazon RDS e a função do Lambda não pode acessar a API do RDS.**
Para [rodízio de usuários em alternância](rotation-strategy.md#rotating-secrets-two-users) em que o segredo do superusuário é [gerenciado por outro produto da AWS](service-linked-secrets.md), a função de rodízio do Lambda deve ser capaz de chamar o endpoint do serviço para obter as informações de conexão do banco de dados. Recomendamos que você configure um endpoint da VPC para o serviço de banco de dados. Para obter mais informações, consulte:
+ [API do Amazon RDS e endpoints da VPC de interface](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/vpc-interface-endpoints.html) no *Guia do usuário do Amazon RDS*.
+ [Trabalhar com endpoints da VPC](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-working-with-endpoints.html) no *Guia de gerenciamento do Amazon Redshift*.
## Erro: “O acesso ao KMS não é permitido”
Se você vir `ClientError: An error occurred (AccessDeniedException) when calling the GetSecretValue operation: Access to KMS is not allowed`, a função de alternância não tem permissão para descriptografar o segredo usando a chave KMS usada para criptografar o segredo. Pode haver uma condição na política de permissões que limita o contexto de criptografia a um segredo específico. Para obter informações sobre as permissões necessárias, consulte [Declaração de política para chaves gerenciadas pelo cliente](rotating-secrets-required-permissions-function.md#rotating-secrets-required-permissions-function-cust-key-example).
## Erro: “Key is missing from secret JSON” (A chave do segredo JSON está ausente)
Uma função de alternância do Lambda requer que o valor do segredo esteja em uma estrutura JSON específica. Se você vir esse erro, o JSON pode estar sem uma chave que a função de alternância tentou acessar. Para obter informações sobre a estrutura JSON para cada tipo de segredo, consulte [Estrutura JSON de segredos AWS Secrets Manager](reference_secret_json_structure.md).
## Erro: “setSecret: Unable to log into database” (setSecret: não é possível fazer login no banco de dados)
A seguir, estão os problemas que podem causar esse erro:
**A função de alternância não pode acessar o banco de dados.**
Se a duração da tarefa for longa, por exemplo, mais de 5 milissegundos, a função de alternância do Lambda pode não conseguir acessar o banco de dados utilizando a rede.
Se seu banco de dados ou serviço estiver sendo executado em uma instância do Amazon EC2 em uma VPC, é recomendável que você configure a função do Lambda para ser executada na mesma VPC. Assim, a função de alternância pode se comunicar diretamente com seu serviço. Para obter mais informações, consulte [Configuring VPC access](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-configuring) (Configurar o acesso à VPC).
Para permitir que a função do Lambda acesse o banco de dados ou serviço, certifique-se de que os grupos de segurança anexados à sua função de alternância do Lambda permitam conexões de saída com o banco de dados ou serviço. Você também deve garantir que os grupos de segurança anexados ao seu banco de dados ou serviço permitam conexões de entrada a partir da função de alternância do Lambda.
**As credenciais no segredo estão incorretas.**
Se a duração da tarefa for curta, a função de alternância do Lambda pode não conseguir autenticar com as credenciais no segredo. Verifique as credenciais fazendo login manualmente com as informações nas `AWSPREVIOUS` versões `AWSCURRENT` e do segredo usando o AWS CLI comando [https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
**O banco de dados usa `scram-sha-256` para criptografar senhas.**
Se seu banco de dados for Aurora PostgreSQL versão 13 ou posterior e usar `scram-sha-256` para criptografar senhas, mas a função de alternância usar `libpq` versão 9 ou anterior que não seja compatível com `scram-sha-256`, a função de alternância não poderá estabelecer conexão com o banco de dados.
**Para determinar quais usuários do banco de dados usam criptografia `scram-sha-256`**
+ Consulte *Checking for users with non-SCRAM passwords* (Verificação de usuários com senhas não SCRAM) na postem de blog [SCRAM Authentication in RDS for PostgreSQL 13](https://aws.amazon.com/blogs/database/scram-authentication-in-rds-for-postgresql-13/) (Autenticação SCRAM no RDS para PostgreSQL 13).
**Para determinar a versão que sua função de alternância `libpq` usa**
1. Em um computador baseado em Linux, no console do Lambda, acesse sua função de alternância e baixe o pacote de implantação. Descompacte o arquivo zip em um diretório de trabalho.
1. Usando uma linha de comando, no diretório de trabalho, execute:
`readelf -a libpq.so.5 | grep RUNPATH`
1. Se você visualizar a string *`PostgreSQL-9.4.x`* ou qualquer versão principal inferior à versão 10, a função de alternância não será compatível com `scram-sha-256`.
+ Saída para uma função de alternância incompatível com `scram-sha-256`:
`0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild-a1b2c/workspace/build/PostgreSQL/PostgreSQL-9.4.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild-a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
+ Saída para uma função de alternância compatível com `scram-sha-256`:
`0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild-a1b2c/workspace/build/PostgreSQL/PostgreSQL-10.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild-a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
+ Saída para uma função de alternância compatível com `scram-sha-256`:
`0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild- a1b2c /workspace/build/PostgreSQL/PostgreSQL-14.x_client_only. 123456 .0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil-path/build.libfarm/lib:/local/p4clients/pkgbuild- a1b2c /workspace/src/PostgreSQL/build/private/install/lib]`
+ Saída para uma função de alternância compatível com `scram-sha-256`:
`0x000000000000001d (RUNPATH) Library runpath: [/local/p4clients/pkgbuild- a1b2c/workspace/build/PostgreSQL/PostgreSQL- 14.x_client_only.123456.0/AL2_x86_64/DEV.STD.PTHREAD/build/private/tmp/brazil- path/build.libfarm/lib:/local/p4clients/pkgbuild- a1b2c/workspace/src/PostgreSQL/build/private/install/lib]`
Se tiver configurado a alternância automática de segredos antes de 30 de dezembro de 2021, sua função de alternância incluiu uma versão anterior de `libpq` que não oferece suporte a `scram-sha-256`. Para oferecer suporte a `scram-sha-256`, você precisa [recriar sua função de alternância](rotate-secrets_turn-on-for-db.md).
**O banco de dados requer SSL/TLS acesso.**
Se seu banco de dados exigir uma SSL/TLS conexão, mas a função de rotação usar uma conexão não criptografada, a função de rotação não poderá se conectar ao banco de dados. As funções de rodízio do Amazon RDS (exceto Oracle e Db2) e o Amazon DocumentDB usam automaticamente o Secure Socket Layer (SSL) ou o Transport Layer Security (TLS) para se conectar ao seu banco de dados, se ele estiver disponível. Caso contrário, utilizarão uma conexão não criptografada.
Se você configurou a rotação secreta automática antes de 20 de dezembro de 2021, sua função de rotação pode ser baseada em um modelo anterior que não era compatívelSSL/TLS. To support connections that use SSL/TLS. Você precisará [recriar sua função de rotação](rotate-secrets_turn-on-for-db.md).
**Para determinar quando a sua função de alternância foi criada**
1. No console do Secrets Manager [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/), abra seu segredo. Na seção **Configuração de alternância**, em **Função de alternância do Lambda**, você verá o **ARN da função do Lambda**, por exemplo, `arn:aws:lambda:aws-region:123456789012:function:SecretsManagerMyRotationFunction `. Copie o nome da função do final do ARN. Neste exemplo, é ` SecretsManagerMyRotationFunction `.
1. No AWS Lambda console [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), em **Funções**, cole o nome da função Lambda na caixa de pesquisa, escolha Enter e escolha a função Lambda.
1. Na página de detalhes da função, na guia **Configuration** (Configuração), em **Tags** (Etiquetas), copie o valor ao lado da chave **aws:cloudformation:stack-name**.
1. No AWS CloudFormation console [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/), em **Stacks**, cole o valor da chave na caixa de pesquisa e escolha Enter.
1. A lista de filtros de pilhas para que somente a pilha que criou a função de alternância do Lambda apareça. Na coluna **Created date** (Data da criação), visualize a data em que a pilha foi criada. Esta é a data em que a função de alternância do Lambda foi criada.
## Erro: “Não é possível importar o módulo ‘lambda\$1function’"
É possível receber esse erro se estiver executando uma função do Lambda anterior que foi atualizada automaticamente do Python 3.7 para uma versão mais recente do Python. Para solucionar o erro, é possível alterar a versão da função do Lambda de volta para Python 3.7 e, em seguida, para [Atualize uma função de alternância existente do Python 3.7 para 3.9](#troubleshoot_rotation_python39). Para obter mais informações, consulte [Por que a alternância da minha função do Lambda do Secrets Manager falhou com o erro “módulo pg não encontrado”?](https://repost.aws/knowledge-center/secrets-manager-lambda-rotation) no *AWS re:Post*.
## Atualize uma função de alternância existente do Python 3.7 para 3.9
Algumas funções de alternância criadas antes de novembro de 2022 usavam o Python 3.7. O AWS SDK para Python deixou de oferecer suporte ao Python 3.7 em dezembro de 2023. Para obter mais informações, consulte [Atualizações AWS SDKs e ferramentas da política de suporte do Python](https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/). Para mudar para uma nova função de alternância que usa o Python 3.9, é possível adicionar uma propriedade de runtime a uma função de alternância existente ou recriá-la.
**Para descobrir quais funções de alternância do Lambda usam o Python 3.7**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Na lista de **Funções**, filtre por **SecretsManager**.
1. Na lista filtrada de funções, em **Runtime**, busque o Python 3.7.
**Topics**
+ [
### Opção 1: Recriar a função de rotação usando CloudFormation
](#update-python-opt-1)
+ [
### Opção 2: atualizar o tempo de execução da função de rotação existente usando CloudFormation
](#update-python-opt-2)
+ [
### Opção 3: Para AWS CDK usuários, atualize a biblioteca CDK
](#update-python-opt-3)
### Opção 1: Recriar a função de rotação usando CloudFormation
Quando você usa o console do Secrets Manager para ativar a rotação, o Secrets Manager usa CloudFormation para criar os recursos necessários, incluindo a função de rotação do Lambda. Se você usou o console para ativar a rotação ou criou a função de rotação usando uma CloudFormation pilha, poderá usar a mesma CloudFormation pilha para recriar a função de rotação com um novo nome. A nova função usa a versão mais recente do Python.
**Para encontrar a CloudFormation pilha que criou a função de rotação**
+ Na página de detalhes da função do Lambda, na guia **Configuração**, escolha **Tags**. Visualize o ARN próximo à **aws:cloudformation:stack-id**.
O nome da pilha está incorporado no ARN, conforme exibido no exemplo a seguir.
+ ARN: `arn:aws:cloudformation:us-west-2:408736277230:stack/SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda-3CUDHZMDMBO8/79fc9050-2eef-11ed-80f0-021fb13c0537`
+ Nome da pilha: **SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda**
**Para recriar uma função de alternância (CloudFormation)**
1. Em CloudFormation, pesquise a pilha pelo nome e escolha **Atualizar**.
Se aparecer uma caixa de diálogo recomendando a atualização da pilha raiz, escolha **Ir para a pilha raiz** e, em seguida, escolha **Atualizar**.
1. Na página **Atualizar pilha**, em **Preparar modelo**, escolha **Editar no Application Composer** e, em **Editar modelo no Application Composer**, escolha o botão **Editar no Application Composer**.
1. No Application Composer, faça o seguinte:
1. No código do modelo, em `SecretRotationScheduleHostedRotationLambda`, substitua o valor por `"functionName": "SecretsManagerTestRotationRDS"` com um novo nome de função. Por exemplo, em JSON, `"functionName": "SecretsManagerTestRotationRDSupdated"`.
1. Escolha **Atualizar modelo**.
1. Na caixa de diálogo **Prosseguir para CloudFormation**, escolha **Confirmar e prosseguir para CloudFormation**.
1. Continue com o fluxo de trabalho da CloudFormation pilha e escolha **Enviar**.
### Opção 2: atualizar o tempo de execução da função de rotação existente usando CloudFormation
Quando você usa o console do Secrets Manager para ativar a rotação, o Secrets Manager usa CloudFormation para criar os recursos necessários, incluindo a função de rotação do Lambda. Se você usou o console para ativar a rotação ou criou a função de rotação usando uma CloudFormation pilha, poderá usar a mesma CloudFormation pilha para atualizar o tempo de execução da função de rotação.
**Para encontrar a CloudFormation pilha que criou a função de rotação**
+ Na página de detalhes da função do Lambda, na guia **Configuração**, escolha **Tags**. Visualize o ARN próximo à **aws:cloudformation:stack-id**.
O nome da pilha está incorporado no ARN, conforme exibido no exemplo a seguir.
+ ARN: `arn:aws:cloudformation:us-west-2:408736277230:stack/SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda-3CUDHZMDMBO8/79fc9050-2eef-11ed-80f0-021fb13c0537`
+ Nome da pilha: **SecretsManagerRDSMySQLRotationSingleUser5c2-SecretRotationScheduleHostedRotationLambda**
**Para atualizar o runtime de uma função de alternância (CloudFormation)**
1. Em CloudFormation, pesquise a pilha pelo nome e escolha **Atualizar**.
Se aparecer uma caixa de diálogo recomendando a atualização da pilha raiz, escolha **Ir para a pilha raiz** e, em seguida, escolha **Atualizar**.
1. Na página **Atualizar pilha**, em **Preparar modelo**, escolha **Editar no Application Composer** e, em **Editar modelo no Application Composer**, escolha o botão **Editar no Application Composer**.
1. No Application Composer, faça o seguinte:
1. No modelo JSON, para `SecretRotationScheduleHostedRotationLambda`, em `Properties`, em `Parameters`, adicione **"runtime": "python3.9"**.
1. Escolha **Atualizar modelo**.
1. Na caixa de diálogo **Prosseguir para CloudFormation**, escolha **Confirmar e prosseguir para CloudFormation**.
1. Continue com o fluxo de trabalho da CloudFormation pilha e escolha **Enviar**.
### Opção 3: Para AWS CDK usuários, atualize a biblioteca CDK
Se você usou a versão AWS CDK anterior à v2.94.0 para configurar a rotação do seu segredo, você pode atualizar a função Lambda fazendo o upgrade para a v2.94.0 ou posterior. Para obter mais informações, consulte o [Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) v2](https://docs.aws.amazon.com/cdk/v2/guide/home.html).
## Atualize uma função de alternância existente de Python 3.9 para 3.10
O Secrets Manager está fazendo a transição de Python 3.9 para 3.10 para funções de alternância do Lambda. Para mudar para uma nova função de alternância que use o Python 3.10, é necessário seguir o caminho de atualização com base no método de implantação. Use os procedimentos a seguir para atualizar a versão do Python e as dependências subjacentes.
**Para descobrir quais funções de rotação do Lambda, use o Python 3.9**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Na lista de **Funções**, filtre por **SecretsManager**.
1. Na lista filtrada de funções, em **Runtime**, busque por **Python 3.9**.
### Atualização de caminhos por método de implantação
As funções de rotação do Lambda identificadas nessa lista podem ser implantadas por meio do console, AWS Serverless Application Repository aplicativos ou transformações do Secrets Manager. CloudFormation Cada uma dessas estratégias de implantação tem um caminho de atualização distinto.
Use um dos procedimentos a seguir para atualizar suas funções de alternância do Lambda, dependendo de como sua função foi implantada.
------
#### [ AWS Secrets Manager console-deployed functions ]
Uma nova função Lambda deve ser implantada por meio do AWS Secrets Manager console, pois você não pode atualizar manualmente as dependências das funções Lambda existentes.
Use o procedimento a seguir para atualizar as funções implantadas no AWS Secrets Manager console.
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Em **AWS Secrets Manager**, selecione **Segredos**. Selecione o segredo que usa a função do Lambda que deseja atualizar.
1. Navegue até a guia **Alternâncias** e selecione a opção **Atualizar configurações de alternância**.
1. Em **Funções de alternância**, escolha **Criar uma nova função** e insira um nome para a função de alternância do Lambda.
1. (Opcional) Depois que a atualização for concluída, será possível testar a função do Lambda atualizada para confirmar se ela funciona conforme o esperado. Na guia **Alternância**, selecione **Alternar segredo imediatamente** para iniciar uma alternância imediata.
1. (Opcional) Você pode visualizar seus registros de funções e a versão do Python usada em tempo de execução na Amazon. CloudWatch Para obter mais informações, consulte [Visualização de CloudWatch registros de funções Lambda](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-view.html#monitoring-cloudwatchlogs-console) no Guia do *AWS Lambda desenvolvedor*.
1. Depois que a nova função de alternância estiver configurada, será possível excluir a função de alternância antiga.
------
#### [ AWS Serverless Application Repository deployments ]
O procedimento a seguir mostra como atualizar as AWS Serverless Application Repository implantações. As funções Lambda implantadas por meio AWS Serverless Application Repository de um banner informando `This function belongs to an application. Click here to manage it.` que inclui um link para o aplicativo Lambda ao qual a função pertence.
**Importante**
AWS Serverless Application Repository a disponibilidade Região da AWS depende.
Use o procedimento a seguir para atualizar as funções AWS Serverless Application Repository implantadas.
1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Navegue até a guia **Configurações** da função do Lambda que precisa ser atualizada.
1. Você precisará das seguintes informações sobre sua função ao atualizar o AWS Serverless Application Repository aplicativo implantado. É possível encontrar estas informações no console do Lambda.
+ **Nome da aplicação do Lambda**
+ O nome da aplicação do Lambda pode ser encontrado usando o link no banner. Por exemplo, o banner indica `serverlessrepo-SecretsManagerRedshiftRotationSingleUser`. Neste exemplo, o nome é `SecretsManagerRedshiftRotationSingleUser`.
+ **Nome da função de alternância do Lambda**
+ **Ponto final do Secrets Manager**
+ **O endpoint pode ser encontrado nas guias **Configurações** e **Variáveis de ambiente** atribuídas à variável SECRETS\$1MANAGER\$1ENDPOINT**.
1. Para atualizar o Python, será necessário atualizar a versão semântica da aplicação sem servidor. Consulte [Atualização de aplicações](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-how-to-consume-new-version.html#update-applications) no *Guia do desenvolvedor do AWS Serverless Application Repository *.
------
#### [ Custom Lambda rotation functions ]
Se você criou funções personalizadas de alternância do Lambda, precisará atualizar as dependências e os runtimes de cada pacote para essas funções. Para obter mais informações, consulte [Atualização do runtime da função do Lambda para a versão mais recente](https://repost.aws/knowledge-center/lambda-upgrade-function-runtime).
------
#### [ AWS::SecretsManager-2024-09-16 transform macro ]
Se a função do Lambda for implantada por meio dessa transformação, a [atualização das pilhas usando o modelo existente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-direct.html) permitirá que você use o runtime atualizado do Lambda.
Use o procedimento a seguir para atualizar a CloudFormation pilha usando o modelo existente.
1. Abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na página **Pilhas**, selecione a pilha que você deseja atualizar.
1. Escolha **Atualizar** no painel de detalhes da pilha.
1. Em **Escolha um método de atualização de modelo**, selecione **Atualização direta**.
1. Na página **Especificar modelo**, selecione **Usar modelo existente**.
1. Deixe todas as outras opções nos valores padrão e escolha **Atualizar pilha**.
Se você tiver problemas para atualizar a pilha, consulte [Determinação da causa de uma falha na pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/determine-root-cause-for-stack-failures.html) no *Guia do usuário do CloudFormation *.
------
#### [ AWS::SecretsManager-2020-07-23 transform macro ]
Recomendamos que você migre para a versão de transformação mais recente se estiver usando o `AWS::SecretsManager-2020-07-23`. Consulte [Apresentando uma versão aprimorada da AWS Secrets Manager transformação:: AWS: SecretsManager -2024-09-16](https://aws.amazon.com/blogs/security/introducing-an-enhanced-version-of-the-aws-secrets-manager-transform-awssecretsmanager-2024-09-16/) no blog de *AWS segurança* para obter mais informações. Se você continuar usando o `AWS::SecretsManager-2020-07-23`, poderá encontrar um erro de incompatibilidade entre sua versão de runtime e os artefatos do código da função do Lambda. Para obter mais informações, consulte [AWS:SecretsManager:: RotationSchedule HostedRotationLambda](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-secretsmanager-rotationschedule-hostedrotationlambda.html#cfn-secretsmanager-rotationschedule-hostedrotationlambda-runtime) na *Referência do CloudFormation modelo*.
Se você tiver problemas para atualizar a pilha, consulte [Determinação da causa de uma falha na pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/determine-root-cause-for-stack-failures.html) no *Guia do usuário do CloudFormation *.
------
**Verificação da atualização do Python**
**Para verificar a atualização do Python, abra o console Lambda ([https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)) e acesse a página Function.** Selecione a função que você atualizou. Na seção **Fonte do código**, revise os arquivos incluídos no diretório e verifique se a versão do arquivo .so do Python é `3.10`.
## AWS Lambda rotação secreta com `PutSecretValue` falha
Se você usa uma função assumida ou uma rotação entre contas com o Secrets Manager e encontra um **RotationFailed** evento CloudTrail com a mensagem: A versão secreta pendente do *VERSION\$1ID * Secret não *SECRET\$1ARN * foi criada pelo *LAMBDA\$1ARN.* Lambda Remova `AWSPENDING` o rótulo de teste e reinicie a rotação, então você precisa atualizar sua função Lambda para usar o parâmetro. `RotationToken`
## Atualização da função de alternância Lambda para incluir `RotationToken`
1. Baixe o código da função do Lambda
+ Abra o console do Lambda
+ Selecione **Funções** no painel de navegação
+ Selecione sua função de alternância de segredos do Lambda em **Nome da função**
+ Em **Download**, escolha um dentre **Códigos de função .zip**, **Arquivo AWS SAM **, **Ambos**
+ Escolha **OK** para salvar a função em sua máquina local.
1. Editar o `Lambda_handler`
Inclua o parâmetro rotation\$1token na etapa create\$1secret para alternância entre contas:
```
def lambda_handler(event, context):
"""Secrets Manager Rotation Template
This is a template for creating an AWS Secrets Manager rotation lambda
Args:
event (dict): Lambda dictionary of event parameters. These keys must include the following:
- SecretId: The secret ARN or identifier
- ClientRequestToken: The ClientRequestToken of the secret version
- Step: The rotation step (one of createSecret, setSecret, testSecret, or finishSecret)
- RotationToken: the rotation token to put as parameter for PutSecretValue call
context (LambdaContext): The Lambda runtime information
Raises:
ResourceNotFoundException: If the secret with the specified arn and stage does not exist
ValueError: If the secret is not properly configured for rotation
KeyError: If the event parameters do not contain the expected keys
"""
arn = event['SecretId']
token = event['ClientRequestToken']
step = event['Step']
# Add the rotation token
rotation_token = event['RotationToken']
# Setup the client
service_client = boto3.client('secretsmanager', endpoint_url=os.environ['SECRETS_MANAGER_ENDPOINT'])
# Make sure the version is staged correctly
metadata = service_client.describe_secret(SecretId=arn)
if not metadata['RotationEnabled']:
logger.error("Secret %s is not enabled for rotation" % arn)
raise ValueError("Secret %s is not enabled for rotation" % arn)
versions = metadata['VersionIdsToStages']
if token not in versions:
logger.error("Secret version %s has no stage for rotation of secret %s." % (token, arn))
raise ValueError("Secret version %s has no stage for rotation of secret %s." % (token, arn))
if "AWSCURRENT" in versions[token]:
logger.info("Secret version %s already set as AWSCURRENT for secret %s." % (token, arn))
return
elif "AWSPENDING" not in versions[token]:
logger.error("Secret version %s not set as AWSPENDING for rotation of secret %s." % (token, arn))
raise ValueError("Secret version %s not set as AWSPENDING for rotation of secret %s." % (token, arn))
# Use rotation_token
if step == "createSecret":
create_secret(service_client, arn, token, rotation_token)
elif step == "setSecret":
set_secret(service_client, arn, token)
elif step == "testSecret":
test_secret(service_client, arn, token)
elif step == "finishSecret":
finish_secret(service_client, arn, token)
else:
raise ValueError("Invalid step parameter")
```
1. Edição do código `create_secret`
Revise a função `create_secret` para aceitar e usar o parâmetro `rotation_token`:
```
# Add rotation_token to the function
def create_secret(service_client, arn, token, rotation_token):
"""Create the secret
This method first checks for the existence of a secret for the passed in token. If one does not exist, it will generate a
new secret and put it with the passed in token.
Args:
service_client (client): The secrets manager service client
arn (string): The secret ARN or other identifier
token (string): The ClientRequestToken associated with the secret version
rotation_token (string): the rotation token to put as parameter for PutSecretValue call
Raises:
ResourceNotFoundException: If the secret with the specified arn and stage does not exist
"""
# Make sure the current secret exists
service_client.get_secret_value(SecretId=arn, VersionStage="AWSCURRENT")
# Now try to get the secret version, if that fails, put a new secret
try:
service_client.get_secret_value(SecretId=arn, VersionId=token, VersionStage="AWSPENDING")
logger.info("createSecret: Successfully retrieved secret for %s." % arn)
except service_client.exceptions.ResourceNotFoundException:
# Get exclude characters from environment variable
exclude_characters = os.environ['EXCLUDE_CHARACTERS'] if 'EXCLUDE_CHARACTERS' in os.environ else '/@"\'\\'
# Generate a random password
passwd = service_client.get_random_password(ExcludeCharacters=exclude_characters)
# Put the secret, using rotation_token
service_client.put_secret_value(SecretId=arn, ClientRequestToken=token, SecretString=passwd['RandomPassword'], VersionStages=['AWSPENDING'], RotationToken=rotation_token)
logger.info("createSecret: Successfully put secret for ARN %s and version %s." % (arn, token))
```
1. Transferência do código atualizado da função do Lambda
Depois de atualizar o código da função do Lambda, [transfira-o para alternar seu segredo](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-zip.html#configuration-function-update).
## Erro: “Erro ao executar lambda ** durante a ** etapa”
Se você estiver enfrentando falhas intermitentes de alternância de segredos com sua função do Lambda presa em um loop de conjuntos, por exemplo, entre **CreateSecret** e **SetSecret**, o problema pode estar relacionado às configurações de simultaneidade.
### Etapas da solução de problemas de simultaneidade
**Atenção**
Definir o parâmetro de simultaneidade provisionado como um valor menor que 10 pode causar limitação devido à insuficiência de threads de execução para a função do Lambda. Para obter mais informações, consulte [Noções básicas sobre simultaneidade reservada e simultaneidade provisionada](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned) no Guia do desenvolvedor do AWS Lambda AWS Lambda .
1. Verifique e ajuste as configurações de simultaneidade do Lambda:
+ Verifique se `reserved_concurrent_executions` não está definido como muito baixo (por exemplo, 1)
+ Se estiver usando simultaneidade reservada, defina para pelo menos 10
+ Considere o uso de simultaneidade sem reservas para obter mais flexibilidade
1. Para simultaneidade provisionada:
+ Não defina explicitamente o parâmetro de simultaneidade provisionado (por exemplo, no Terraform).
+ Se você precisar configurá-lo, use um valor de pelo menos 10.
+ Teste minuciosamente para garantir que o valor escolhido funcione para seu caso de uso.
1. Monitore e ajuste a simultaneidade:
+ Calcule a simultaneidade usando esta fórmula: Concorrência = (média de solicitações por segundo) \$1 (duração média da solicitação em segundos). Para obter mais informações, consulte [Estimativa de simultaneidade reservada](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html#estimating-reserved-concurrency).
+ Observe e registre os valores durante as alternâncias para determinar as configurações de simultaneidade apropriadas.
+ Tenha cuidado ao definir valores baixos de simultaneidade. Eles podem causar controle de utilização se não houver threads de execução suficientes disponíveis.
Para obter mais informações sobre como configurar a simultaneidade do Lambda, [consulte Configurando a simultaneidade reservada [e Configurando](https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html) a](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) simultaneidade provisionada no Guia do desenvolvedor. AWS Lambda