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á.

# Crie um AWS Secrets Manager segredo
<a name="create_secret"></a>

Um *segredo* pode ser uma senha, um conjunto de credenciais, como nome de usuário e senha, um OAuth token ou outras informações secretas que você armazena de forma criptografada no Secrets Manager. 

**dica**  
Para credenciais de usuário administrador do Amazon RDS e do Amazon Redshift, recomendamos o uso de [segredos gerenciados](service-linked-secrets.md). Você cria o segredo gerenciado por meio do serviço de gerenciamento e, em seguida, pode usar a [alternância gerenciada](rotate-secrets_managed.md).

Quando você usa o console para armazenar credenciais de banco de dados para um banco de dados de origem replicado para outras regiões, o segredo contém informações de conexão para o banco de dados de origem. Se você replicar o segredo, as réplicas serão cópias do segredo de origem e conterão as mesmas informações de conexão. Você pode adicionar mais key/value pares ao segredo para obter informações sobre a conexão regional.

Para criar um segredo, você precisa das permissões concedidas pela [política SecretsManagerReadWrite gerenciada](reference_available-policies.md).

O Secrets Manager gera uma entrada de CloudTrail registro quando você cria um segredo. Para obter mais informações, consulte [AWS Secrets Manager Registre eventos com AWS CloudTrail](monitoring-cloudtrail.md).

**Para criar um segredo (console)**

1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Selecione **Armazenar um novo segredo**.

1. Na página **Selecionar tipo de segredo**, faça o seguinte:

   1. Para **Secret type** (Tipo de segredo), siga um destes procedimentos:
      + Para armazenar credenciais de banco de dados, escolha o tipo de credenciais de banco de dados a armazenar. Em seguida, escolha o **Banco de dados** e insira as **Credenciais**.
      + Para armazenar chaves de APIs, tokens de acesso e credenciais que não sejam para bancos de dados, escolha **Outro tipo de segredo**.

        Em **Key/value pairs** (Pares de chave/valor), ou insira seu segredo no JSON **Key/value** (Chave/valor), ou escolha a guia **Plaintext** (Texto simples) e insira o segredo em qualquer formato. É possível armazenar até 65536 bytes no segredo. Alguns exemplos:

------
#### [ API key ]

        Insira como key/value pares:

        **ClientID** : *my\$1client\$1id*

        **ClientSecret** : *wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY*

------
#### [ OAuth token ]

        Insira como texto sem formatação:

        *AKIAI44QH8DHBEXAMPLE*

------
#### [ Digital certificate ]

        Insira como texto sem formatação:

        ```
        -----BEGIN CERTIFICATE-----
        EXAMPLE
        -----END CERTIFICATE-----
        ```

------
#### [ Private key ]

        Insira como texto sem formatação:

        ```
        –--- BEGIN PRIVATE KEY ----
        EXAMPLE
        ––-- END PRIVATE KEY –---
        ```

------
      + Para armazenar segredos externos gerenciados de um parceiro do Secrets Manager, escolha **Segredo do parceiro**. Em seguida, escolha o parceiro e forneça os detalhes que identificam o segredo do parceiro. Para obter detalhes, consulte [Usando segredos externos AWS Secrets Manager gerenciados para gerenciar segredos de terceiros](managed-external-secrets.md).

   1. Em **Chave de criptografia**, escolha a AWS KMS key que o Secrets Manager usa para criptografar o valor secreto. Para obter mais informações, consulte [Criptografia e descriptografia de segredos](security-encryption.md).
      + Na maioria dos casos, escolha **aws/secretsmanager para usar o for Secrets Chave gerenciada pela AWS Manager**. Não há custo para o uso dessa chave.
      + **Se você precisar acessar o segredo de outra pessoa Conta da AWS ou se quiser usar sua própria chave KMS para poder alterná-la ou aplicar uma política de chaves a ela, escolha uma chave gerenciada pelo cliente na lista, insira o ARN da chave ou o alias ARN de uma chave gerenciada pelo cliente ou escolha Adicionar nova chave para criar uma.** Para obter mais informações sobre os custos do uso de uma chave gerenciada pelo cliente, consulte [Preços](intro.md#asm_pricing).

        É necessário ter [Permissões para a chave do KMS](security-encryption.md#security-encryption-authz). Para obter informações sobre o acesso entre contas, consulte [Acesse AWS Secrets Manager segredos de uma conta diferente](auth-and-access_examples_cross.md). 

   1. Escolha **Próximo**.

1. Na página **Configure secret** (Configurar segredo), faça o seguinte:

   1. Insira um **Secret name** (Nome de segredo) descritivo e uma **Description** (Descrição). Os nomes dos segredos podem conter de 1 a 512 caracteres alfanuméricos e os caracteres /\$1\$1 =.@-.

   1. (Opcional) Se você criou um segredo externo, insira os metadados exigidos pelo parceiro do Secrets Manager que detém o segredo.

   1. (Opcional) Na seção **Tags**, adicione tags ao segredo. Para conhecer as estratégias de marcação, consulte [Marcando segredos em AWS Secrets Manager](managing-secrets_tagging.md). Não armazene informações sigilosas em tags porque elas não são criptografadas.

   1. (Opcional) Em **Resource permissions** (Permissões do recurso), para adicionar uma política de recursos ao segredo, escolha **Edit permissions** (Editar permissões). Para obter mais informações, consulte [Políticas baseadas em recursos](auth-and-access_resource-policies.md).

   1. (Opcional) Em **Replicar segredo**, para replicar seu segredo para outro Região da AWS, escolha **Replicar** segredo. É possível replicar seu segredo agora ou voltar e replicá-lo mais tarde. Para obter mais informações, consulte [Replicação multirregional](replicate-secrets.md).

   1. Escolha **Próximo**.

1. (Opcional) Na página **Configure rotation** (Configurar alternância), habilite alternância automática para os segredos. Você também pode manter a alternância desabilitada por enquanto e habilitá-la mais tarde. Para obter mais informações, consulte [Alternar segredos ](rotating-secrets.md). Escolha **Próximo**.

1. Na página **Review** (Revisar), revise os detalhes do segredo e escolha **Store** (Armazenar).

   O Secrets Manager retorna para a lista de segredos. Se o segredo não aparecer, escolha Refresh (Atualizar).

## AWS CLI
<a name="create_secret_cli"></a>

Quando você insere comandos em um shell de comando, existe o risco de o histórico de comandos ser acessado ou de utilitários terem acesso aos seus parâmetros de comando. Consulte [Mitigue os riscos de usar o AWS CLI para armazenar seus segredos AWS Secrets Manager](security_cli-exposure-risks.md).

**Example Crie um segredo com base nas credenciais do banco de dados em um arquivo JSON**  
O exemplo [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/secretsmanager/create-secret.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/secretsmanager/create-secret.html) a seguir cria um segredo com base em credenciais em um arquivo. Para obter mais informações, consulte [Carregando AWS CLI parâmetros de um arquivo](https://docs.aws.amazon.com//cli/latest/userguide/cli-usage-parameters-file.html) no Guia AWS CLI do usuário.  
Para que o Secrets Manager possa alternar o segredo, é necessário se certificar de que o JSON corresponde a [Estrutura JSON de um segredo](reference_secret_json_structure.md).  

```
aws secretsmanager create-secret \
    --name MyTestSecret \
    --secret-string file://mycreds.json
```
Conteúdo de mycreds.json:  

```
{
    "engine": "mysql",
    "username": "saanvis",
    "password": "EXAMPLE-PASSWORD",
    "host": "my-database-endpoint.us-west-2.rds.amazonaws.com",
    "dbname": "myDatabase",
    "port": "3306"
}
```

**Example Criar um segredo**  
O seguinte exemplo de [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/secretsmanager/create-secret.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/secretsmanager/create-secret.html) cria um segredo com dois pares de chave/valor.  

```
aws secretsmanager create-secret \
    --name MyTestSecret \
    --description "My test secret created with the CLI." \
    --secret-string '{"user":"diegor","password":"EXAMPLE-PASSWORD"}'
```

**Example Criar um segredo**  
O exemplo de [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/create-secret.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/create-secret.html) a seguir cria um segredo com duas tags.  

```
aws secretsmanager create-secret \
    --name MyTestSecret \
    --description "My test secret created with the CLI." \
    --secret-string '{"user":"diegor","password":"EXAMPLE-PASSWORD"}'  \
    --tags '[{"Key": "FirstTag", "Value": "FirstValue"}, {"Key": "SecondTag", "Value": "SecondValue"}]'
```

## AWS SDK
<a name="create_secret_sdk"></a>

Para criar um segredo usando um dos AWS SDKs, use a [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html)ação. Para obter mais informações, consulte [AWS SDKs](asm_access.md#asm-sdks).

# O que há em um segredo do Secrets Manager?
<a name="whats-in-a-secret"></a>

No Secrets Manager, um *segredo* são informações de segredos, isto é, o *valor do segredo* mais alguns metadados sobre o segredo. Um valor do segredo pode ser uma string ou um binário. 

Para armazenar vários valores de strings em um segredo, recomendamos usar uma string de texto JSON com pares de chave-valor, por exemplo:

```
{
  "host"       : "ProdServer-01.databases.example.com",
  "port"       : "8888",
  "username"   : "administrator",
  "password"   : "EXAMPLE-PASSWORD",
  "dbname"     : "MyDatabase",
  "engine"     : "mysql"
}
```

Para segredos de bancos de dados, se você quiser ativar a alternância automática, o segredo deverá conter as informações da conexão do banco de dados na estrutura JSON correta. Para obter mais informações, consulte [Estrutura JSON de segredos AWS Secrets Manager](reference_secret_json_structure.md). 

## Metadados
<a name="whats-in-a-secret-metadata"></a>

Os metadados de um segredo incluem:
+ Um nome do recurso da Amazon (ARN) com o seguinte formato:

  ```
  arn:aws:secretsmanager:<Region>:<AccountId>:secret:SecretName-6RandomCharacters
  ```

  O Secrets Manager inclui seis caracteres aleatórios ao final do nome do segredo para ajudar a garantir que o ARN do segredo seja único. Se o segredo original for excluído e um novo segredo for criado com o mesmo nome, os dois segredos serão diferentes ARNs por causa desses caracteres. Os usuários com acesso ao segredo antigo não obtêm acesso automático ao novo segredo porque ARNs são diferentes.
+ O nome do segredo, uma descrição, uma política de recursos e tags.
+ O ARN de uma *chave de criptografia*, e AWS KMS key que o Secrets Manager usa para criptografar e descriptografar o valor secreto. O Secrets Manager sempre armazena o texto do segredo de forma criptografada e criptografa o segredo em trânsito. Consulte [Criptografia e decodificação secretas em AWS Secrets Manager](security-encryption.md).
+ Informações sobre como alternar o segredo, se você configurar a alternância. Consulte [Gire segredos AWS Secrets Manager](rotating-secrets.md).

O Secrets Manager usa políticas de permissões do IAM para garantir que apenas usuários autorizados possam acessar ou modificar um segredo. Consulte [Autenticação e controle de acesso para AWS Secrets Manager](auth-and-access.md).

Um segredo tem *versões* que contêm cópias do valor do segredo criptografado. Quando você altera o valor do segredo, ou o segredo é alternado, o Secrets Manager cria uma nova versão. Consulte [Versões do segredo](#term_version).

Você pode usar um segredo em vários Regiões da AWS *replicando-o*. Quando você replica um segredo, você cria uma cópia do *segredo primário* ou original, chamado de *segredo de réplica*. O segredo de réplica permanece vinculado ao segredo primário. Consulte [Replique AWS Secrets Manager segredos em todas as regiões](replicate-secrets.md).

Consulte [Gerencie segredos com AWS Secrets Manager](managing-secrets.md).

## Versões do segredo
<a name="term_version"></a>

Um segredo tem *versões* que contêm cópias do valor do segredo criptografado. Quando você altera o valor do segredo, ou o segredo é alternado, o Secrets Manager cria uma nova versão.

O Secrets Manager não armazena um histórico linear de segredos com versões. Em vez disso, ele rastreia três versões específicas, rotulando-as: 
+ A versão atual: `AWSCURRENT`
+ A versão anterior: `AWSPREVIOUS`
+ A versão pendente (durante a alternância): `AWSPENDING`

Um segredo sempre tem uma versão rotulada `AWSCURRENT`, e o Secrets Manager retorna essa versão por padrão quando você recupera o valor do segredo. 

Você também pode rotular versões com suas próprias etiquetas [https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/update-secret-version-stage.html](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/update-secret-version-stage.html)ligando para AWS CLI o. É possível anexar até 20 rótulos a versões em um segredo. Duas versões do segredo não podem ter o mesmo rótulo de preparação. As versões podem ter vários rótulos.

O Secrets Manager nunca remove as versões rotuladas, mas as versões sem rótulos são consideradas obsoletas. O Secrets Manager remove versões obsoletas quando há mais de 100. O Secrets Manager não remove versões criadas há menos de 24 horas.

A figura a seguir mostra um segredo que tem versões AWS rotuladas e versões rotuladas pelo cliente. As versões sem rótulos são consideradas obsoletas e serão removidas pelo Secrets Manager em algum momento no future. 

 ![\[A secret that contains multiple secret versions, some with labels such as AWSCURRENT or MyLabelA, and some without labels.\]](http://docs.aws.amazon.com/pt_br/secretsmanager/latest/userguide/images/SecretVersions.png) 

# Estrutura JSON de segredos AWS Secrets Manager
<a name="reference_secret_json_structure"></a>

É possível armazenar qualquer texto ou binário em um segredo do Secrets Manager, até o tamanho máximo de 65.536 bytes. 

Se você usar [Função do Lambda de alternância](rotate-secrets_lambda.md), um segredo deverá conter campos JSON específicos que a função de alternância espera. Por exemplo, para um segredo que contenha credenciais do banco de dados, a função de alternância se conecta ao banco de dados para atualizar as credenciais, portanto, o segredo deverá conter as informações de conexão do banco de dados.

Se você usar o console para editar a alternância de um segredo de banco de dados, o segredo deverá conter pares de valores-chave JSON específicos que identifiquem o banco de dados. O Secrets Manager usa esses campos para consultar o banco de dados e encontrar a VPC correta na qual armazenar uma função de alternância.

Os nomes de chaves no JSON diferenciam maiúsculas de minúsculas.

**Topics**
+ [Credenciais do Amazon RDS e do Aurora](#reference_secret_json_structure_rds)
+ [Credenciais do Amazon Redshift](#reference_secret_json_structure_RS)
+ [Credenciais do Amazon Redshift sem servidor](#reference_secret_json_structure_RSServerless)
+ [Credenciais do Amazon DocumentDB](#reference_secret_json_structure_docdb)
+ [Estrutura de segredo do Amazon Timestream para InfluxDB](#reference_secret_json_structure_TIME)
+ [ElastiCache Credenciais da Amazon](#reference_secret_json_structure_ELC)
+ [Credenciais do Active Directory](#reference_secret_json_structure_AD)

## Credenciais do Amazon RDS e do Aurora
<a name="reference_secret_json_structure_rds"></a>

Para usar os [modelos de função de alternância fornecidos pelo Secrets Manager](reference_available-rotation-templates.md#RDS_rotation_templates), use a estrutura JSON a seguir. Você pode adicionar mais key/value pares, por exemplo, para conter informações de conexão para bancos de dados de réplica em outras regiões.

------
#### [ DB2 ]

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.

```
{
  "engine": "db2",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "port": <TCP port number. If not specified, defaults to 3306>,
  "masterarn": "<ARN of the elevated secret>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
}
```

------
#### [ MariaDB ]

```
{
  "engine": "mariadb",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "port": <TCP port number. If not specified, defaults to 3306>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
}
```

------
#### [ MySQL ]

```
{
  "engine": "mysql",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "port": <TCP port number. If not specified, defaults to 3306>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
}
```

------
#### [ Oracle ]

```
{
  "engine": "oracle",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name>",
  "port": <TCP port number. If not specified, defaults to 1521>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
}
```

------
#### [ Postgres ]

```
{
  "engine": "postgres",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to 'postgres'>",
  "port": <TCP port number. If not specified, defaults to 5432>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
}
```

------
#### [ SQLServer ]

```
{
  "engine": "sqlserver",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to 'master'>",
  "port": <TCP port number. If not specified, defaults to 1433>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbInstanceIdentifier": <optional: ID of the instance. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>",
  "dbClusterIdentifier": <optional: ID of the cluster.Alternately, use dbInstanceIdentifier.  Required for configuring rotation in the console.>"
}
```

------

## Credenciais do Amazon Redshift
<a name="reference_secret_json_structure_RS"></a>

Para usar os [modelos de função de alternância fornecidos pelo Secrets Manager](reference_available-rotation-templates.md#template-redshift), use a estrutura JSON a seguir. Você pode adicionar mais key/value pares, por exemplo, para conter informações de conexão para bancos de dados de réplica em outras regiões.

```
{
  "engine": "redshift",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "dbClusterIdentifier": "<optional: database ID. Required for configuring rotation in the console.>"
  "port": <optional: TCP port number. If not specified, defaults to 5439>
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>"
}
```

## Credenciais do Amazon Redshift sem servidor
<a name="reference_secret_json_structure_RSServerless"></a>

Para usar os [modelos de função de alternância fornecidos pelo Secrets Manager](reference_available-rotation-templates.md#template-redshift), use a estrutura JSON a seguir. Você pode adicionar mais key/value pares, por exemplo, para conter informações de conexão para bancos de dados de réplica em outras regiões.

```
{
  "engine": "redshift",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "namespaceName": "<optional: namespace name, Required for configuring rotation in the console.> "
  "port": <optional: TCP port number. If not specified, defaults to 5439>
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>"
}
```

## Credenciais do Amazon DocumentDB
<a name="reference_secret_json_structure_docdb"></a>

Para usar os [modelos de função de alternância fornecidos pelo Secrets Manager](reference_available-rotation-templates.md#NON-RDS_rotation_templates), use a estrutura JSON a seguir. Você pode adicionar mais key/value pares, por exemplo, para conter informações de conexão para bancos de dados de réplica em outras regiões.

```
{
  "engine": "mongo",
  "host": "<instance host name/resolvable DNS name>",
  "username": "<username>",
  "password": "<password>",
  "dbname": "<database name. If not specified, defaults to None>",
  "port": <TCP port number. If not specified, defaults to 27017>,
  "ssl": <true|false. If not specified, defaults to false>,
  "masterarn": "<optional: ARN of the elevated secret. Required for the Estratégia de alternância: usuários alternados.>",
  "dbClusterIdentifier": "<optional: database cluster ID. Alternately, use dbInstanceIdentifier. Required for configuring rotation in the console.>"
  "dbInstanceIdentifier": "<optional: database instance ID. Alternately, use dbClusterIdentifier. Required for configuring rotation in the console.>"
}
```

## Estrutura de segredo do Amazon Timestream para InfluxDB
<a name="reference_secret_json_structure_TIME"></a>

Para alternar os segredos do Timestream, é possível usar os modelos de alternância [Amazon Timestream para InfluxDB](reference_available-rotation-templates.md#template-TimeStream).

Para obter mais informações, 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*.

Os segredos do Timestream devem estar na estrutura JSON correta para poderem usar os modelos de alternância. Para obter mais informações, consulte [O que há no segredo](https://docs.aws.amazon.com/timestream/latest/developerguide/timestream-for-influx-security-db-secrets.html#timestream-for-influx-security-db-secrets-definition) no *Guia do desenvolvedor do Amazon Timestream*.

## ElastiCache Credenciais da Amazon
<a name="reference_secret_json_structure_ELC"></a>

O exemplo a seguir mostra a estrutura JSON de um segredo que armazena ElastiCache credenciais.

```
{
  "password": "<password>",
  "username": "<username>" 
  "user_arn": "ARN of the Amazon EC2 user"
}
```

Para obter mais informações, 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*.

## Credenciais do Active Directory
<a name="reference_secret_json_structure_AD"></a>

AWS Directory Service usa segredos para armazenar credenciais do Active Directory. Para obter mais informações, consulte [Associar perfeitamente uma instância Linux do Amazon EC2 ao seu Active Directory AD gerenciado](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/seamlessly_join_linux_instance.html) no *Guia de administração do AWS Directory Service *. A associação perfeita ao domínio requer os nomes de chave nos exemplos a seguir. Se você não usar a associação de domínio perfeita, poderá alterar os nomes das chaves no segredo usando variáveis de ambiente, conforme descrito no código do modelo da função de alternância.

Para alternar segredos do Active Directory, é possível usar os [modelos de alternância do Active Directory](reference_available-rotation-templates.md#template-AD).

------
#### [ Active Directory credential ]

```
{
  "awsSeamlessDomainUsername": "<username>",
  "awsSeamlessDomainPassword": "<password>"
}
```

Se você quiser alternar o segredo, inclua o ID do diretório do domínio.

```
{
  "awsSeamlessDomainDirectoryId": "d-12345abc6e",
  "awsSeamlessDomainUsername": "<username>",
  "awsSeamlessDomainPassword": "<password>"
}
```

Se o segredo for usado em conjunto com um segredo que contém um keytab, você inclui o segredo keytab. ARNs

```
{
  "awsSeamlessDomainDirectoryId": "d-12345abc6e",
  "awsSeamlessDomainUsername": "<username>",
  "awsSeamlessDomainPassword": "<password>",
  "directoryServiceSecretVersion": 1,
  "schemaVersion": "1.0",
  "keytabArns": [
    "<ARN of child keytab secret 1>,
    "<ARN of child keytab secret 2>,
    "<ARN of child keytab secret 3>,
  ],
  "lastModifiedDateTime": "2021-07-19 17:06:58"
}
```

------
#### [ Active Directory keytab ]

Para obter informações sobre o uso de arquivos keytab para autenticação de contas do Active Directory no Amazon EC2, consulte [Implantação e configuração da autenticação do Active Directory com o SQL Server 2017 no Amazon Linux 2](https://aws.amazon.com/blogs/database/deploying-and-configuring-active-directory-authentication-with-sql-server-2017-on-amazon-linux-2/).

```
{
  "awsSeamlessDomainDirectoryId": "d-12345abc6e",
  "schemaVersion": "1.0",
  "name": "< name>",
  "principals": [
    "aduser@MY.EXAMPLE.COM",
    "MSSQLSvc/test:1433@MY.EXAMPLE.COM"
  ],
  "keytabContents": "<keytab>",
  "parentSecretArn": "<ARN of parent secret>",
  "lastModifiedDateTime": "2021-07-19 17:06:58"
  "version": 1
}
```

------