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á.
# Obtenha segredos de AWS Secrets Manager
O Secrets Manager gera uma entrada de CloudTrail registro quando você recupera um segredo. Para obter mais informações, consulte [AWS Secrets Manager Registre eventos com AWS CloudTrail](monitoring-cloudtrail.md).
**Topics**
+ [Java](retrieving-secrets-java.md)
+ [Python](retrieving-secrets-python.md)
+ [.NET](retrieving-secrets-net.md)
+ [Go](retrieving-secrets-go.md)
+ [Rust](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Agente do Secrets Manager](secrets-manager-agent.md)
+ [C\$1\$1](retrieving-secrets-cpp.md)
+ [JavaScript](retrieving-secrets-javascript.md)
+ [Kotlin](retrieving-secrets-kotlin.md)
+ [PHP](retrieving-secrets-php.md)
+ [Ruby](retrieving-secrets-ruby.md)
+ [AWS CLI](retrieving-secrets_cli.md)
+ [AWS console](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub empregos](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Parameter Store](integrating_parameterstore.md)
# Obter um valor de segredo do Secrets Manager usando Java
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
Para se conectar a um banco de dados usando as credenciais em um segredo, é possível usar os drivers de conexão de SQL do Secrets Manager, que encapsulam o driver JDBC básico. Isso também usa o cache do lado do cliente, para reduzir o custo de chamar o Secrets Manager. APIs
**Topics**
+ [Obtenha um segredo do Secrets Manager usando Java com armazenamento em cache no lado do cliente](retrieving-secrets_cache-java.md)
+ [Conecte-se a um banco de dados SQL usando JDBC com credenciais em um segredo AWS Secrets Manager](retrieving-secrets_jdbc.md)
+ [Obtenha um valor secreto do Secrets Manager usando o Java AWS SDK](retrieving-secrets-java-sdk.md)
# Obtenha um segredo do Secrets Manager usando Java com armazenamento em cache no lado do cliente
Ao recuperar um segredo, você pode usar o componente de cache baseado em Java do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).
A política de caches é a do menos usado recentemente (LRU). Assim, quando o cache precisar descartar um segredo, escolherá o segredo menos usado recentemente. Por padrão, o cache atualiza segredos a cada hora. É possível configurar [com qual frequência o segredo será atualizado](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) no cache e será possível [se conectar à recuperação do segredo](retrieving-secrets_cache-java-ref_SecretCacheHook.md) para adicionar mais funcionalidades.
O cache não obriga a coleta de resíduos depois que as referências de cache são liberadas. A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você necessitar de mais segurança, como criptografia de itens no cache, use as interfaces e os métodos abstratos fornecidos.
Para usar o componente, é necessário ter o seguinte:
+ Um ambiente de desenvolvimento Java 8 ou superior. Consulte [Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) (Downloads do Java SE) no site da Oracle.
Para baixar o código-fonte, consulte o componente [cliente de cache baseado em Java do Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-java) em. GitHub
Para adicionar o componente ao seu projeto, inclua a seguinte dependência no arquivo do Maven pom.xml. Para obter mais informações sobre o Maven, consulte o [Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html) (Guia de primeiros passos) no site do projeto Maven do Apache.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md)
+ [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)
**Example Recuperar segredos**
O exemplo de código a seguir mostra uma função Lambda que recupera uma string do segredo. Ele segue a [prática recomendada](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) de instanciar o cache fora do manipulador de funções para que ele não continue chamando a API se você chamar a função Lambda novamente.
```
package com.amazonaws.secretsmanager.caching.examples;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.secretsmanager.caching.SecretCache;
public class SampleClass implements RequestHandler {
private final SecretCache cache = new SecretCache();
@Override public String handleRequest(String secretId, Context context) {
final String secret = cache.getSecretString(secretId);
// Use the secret, return success;
}
}
```
# SecretCache
Um cache na memória para segredos solicitados no Secrets Manager. Você usa [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) ou [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) para recuperar um segredo do cache. É possível definir as configurações de cache executando-as em um objeto [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) no construtor.
Para obter mais informações, incluindo exemplos, consulte [Obtenha um segredo do Secrets Manager usando Java com armazenamento em cache no lado do cliente](retrieving-secrets_cache-java.md).
## Construtores
`public SecretCache()`
Construtor padrão para um objeto `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Constrói um novo cache usando um cliente do Secrets Manager criado usando o [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html) fornecido. Use esse construtor para personalizar o cliente do Secrets Manager, por exemplo, para usar uma região ou endpoint específico.
`public SecretCache(AWSSecretsManager client)`
Constrói um novo cache de segredo usando o [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) fornecido. Use esse construtor para personalizar o cliente do Secrets Manager, por exemplo, para usar uma região ou endpoint específico.
`public SecretCache(SecretCacheConfiguration config)`
Constrói um novo cache de segredo usando a `SecretCacheConfiguration` fornecida.
## Métodos
### getSecretString
`public String getSecretString(final String secretId)`
Recupera um segredo de string do Secrets Manager. Retorna um [https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true).
### getSecretBinary
`public ByteBuffer getSecretBinary(final String secretId)`
Recupera um segredo de binário do Secrets Manager. Retorna um [https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html).
### refreshNow
`public boolean refreshNow(final String secretId) throws InterruptedException`
Impõe a atualização do cache. Retorna `true` se a atualização for concluída sem erro; caso contrário, `false`.
### feche
`public void close()`
Fecha o cache.
# SecretCacheConfiguration
Opções de configuração de cache para um [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), como o tamanho máximo do cache e a vida útil (TTL) para segredos armazenados em cache.
## Construtor
`public SecretCacheConfiguration`
Construtor padrão para um objeto `SecretCacheConfiguration`.
## Métodos
### getClient
`public AWSSecretsManager getClient()`
Ele retorna o [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) de onde o cache recupera segredos.
### setClient
`public void setClient(AWSSecretsManager client)`
Configura o cliente do [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) de onde o cache recupera segredos.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Retorna a interface do [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) usada para conectar atualizações de cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Define a interface do [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) usada para conectar atualizações de cache.
### getMaxCacheTamanho
`public int getMaxCacheSize()`
Retorna o tamanho máximo do cache. O padrão é de 1.024 segredos.
### setMaxCacheTamanho
`public void setMaxCacheSize(int maxCacheSize)`
Define o tamanho máximo do cache. O padrão é de 1.024 segredos.
### getCacheItemTTL
`public long getCacheItemTTL()`
Retorna o TTL em milissegundos para os itens armazenados em cache. Quando um segredo armazenado em cache excede esse TTL, o cache recupera uma nova cópia do segredo do [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). O padrão é 1 hora em milissegundos.
O cache atualizará o segredo de forma síncrona quando ele for solicitado após o TTL. Se a atualização síncrona falhar, o cache retornará o segredo obsoleto.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Define o TTL em milissegundos para os itens armazenados em cache. Quando um segredo armazenado em cache excede esse TTL, o cache recupera uma nova cópia do segredo do [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). O padrão é 1 hora em milissegundos.
### getVersionStage
`public String getVersionStage()`
Retorna a versão dos segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). O padrão é ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Define a versão dos segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). O padrão é `"AWSCURRENT"`.
### SecretCacheConfiguration Com o cliente
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Define o [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) de onde os segredos serão recuperados. Retorna o objeto da `SecretCacheConfiguration` atualizado com a nova configuração.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Define a interface usada para conectar o cache na memória. Retorna o objeto da `SecretCacheConfiguration` atualizado com a nova configuração.
### SecretCacheConfiguration withMaxCacheTamanho
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Define o tamanho máximo do cache. Retorna o objeto da `SecretCacheConfiguration` atualizado com a nova configuração.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Define o TTL em milissegundos para os itens armazenados em cache. Quando um segredo armazenado em cache excede esse TTL, o cache recupera uma nova cópia do segredo do [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). O padrão é 1 hora em milissegundos. Retorna o objeto da `SecretCacheConfiguration` atualizado com a nova configuração.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Define a versão dos segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). Retorna o objeto da `SecretCacheConfiguration` atualizado com a nova configuração.
# SecretCacheHook
Uma interface para conectar a um [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) para executar ações nos segredos sendo armazenados no cache.
## put
`Object put(final Object o)`
Prepare o objeto para o armazenamento no cache.
Retorna o objeto a ser armazenado no cache.
## obter
`Object get(final Object cachedObject)`
Derive o objeto do objeto sendo armazenado em cache.
Retorna o objeto a ser retornado do cache
# Conecte-se a um banco de dados SQL usando JDBC com credenciais em um segredo AWS Secrets Manager
Em aplicativos Java, você pode usar os drivers de conexão SQL do Secrets Manager para se conectar aos bancos de dados MySQL, PostgreSQL, Oracle, MSSQLServer Db2 e Redshift usando credenciais armazenadas no Secrets Manager. Cada driver empacota o driver JDBC base para que você possa usar chamadas JDBC para acessar o seu banco de dados. No entanto, em vez de passar um nome de usuário e senha para a conexão, você fornece o ID de um segredo. O driver chama o Secrets Manager para recuperar o valor do segredo e usa as credenciais no segredo para se conectar ao banco de dados. O driver também armazena em cache as credenciais usando a [biblioteca em cache no lado do cliente de Java](retrieving-secrets_cache-java.md). Assim, as conexões futuras não exigem uma chamada para o Secrets Manager. Por padrão, o cache é atualizado a cada hora e também quando o segredo é alternado. Para configurar o cache, consulte [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Você pode baixar o código-fonte em [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Para usar os drivers de conexão SQL do Secrets Manager:
+ A sua aplicação deve estar em Java 8 ou superior.
+ O seu segredo deve ser um dos seguintes:
+ Um [segredo de banco de dados na estrutura JSON esperada](reference_secret_json_structure.md). Para verificar o formato, no console do Secrets Manager, veja o seu segredo e escolha **Retrieve secret value** (Recuperar o valor do segredo). Como alternativa, no AWS CLI, ligue [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Um [segredo gerenciado](integrating_how-services-use-secrets_RDS.md) pelo Amazon RDS. Para esse tipo de segredo, é necessário especificar um endpoint e uma porta ao estabelecer a conexão.
+ Um [segredo gerenciado](integrating_how-services-use-secrets_RS.md) pelo Amazon Redshift. Para esse tipo de segredo, é necessário especificar um endpoint e uma porta ao estabelecer a conexão.
Se o banco de dados for replicado para outras regiões, para se conectar a uma réplica de banco de dados em outra região, especifique o endpoint regional e a porta ao criar a conexão. Você pode armazenar informações de conexão regional no segredo como key/value pares extras, nos parâmetros do SSM Parameter Store ou na sua configuração de código.
Para adicionar o driver ao seu projeto, no arquivo de compilação do Maven `pom.xml`, adicione a seguinte dependência para o driver. Para obter mais informações, consulte [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) (Biblioteca de conexões SQL do Secrets Manager) no site Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
O driver usa a [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html). Se você executar o driver no Amazon EKS, ele poderá retirar as credenciais do nó em que está sendo executado, em vez do perfil da conta de serviço. Para resolver isso, adicione a versão 1 de `com.amazonaws:aws-java-sdk-sts` ao seu arquivo de projeto Gradle ou Maven como uma dependência.
Para definir uma URL de endpoint de AWS PrivateLink DNS e uma região no `secretsmanager.properties` arquivo:
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Para substituir a região primária, defina a variável de ambiente `AWS_SECRET_JDBC_REGION` ou faça a seguinte alteração no arquivo `secretsmanager.properties`:
```
drivers.region = region
```
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Estabeleça uma conexão com um banco de dados](#retrieving-secrets_jdbc_example)
+ [Estabelecer uma conexão especificando o endpoint e a porta](#retrieving-secrets_jdbc_example_replica)
+ [Use o grupo de conexões c3p0 para estabelecer uma conexão](#retrieving-secrets_jdbc_example_c3po)
+ [Usar o agrupamento de conexões c3p0 para estabelecer uma conexão especificando o endpoint e a porta](#retrieving-secrets_jdbc_example_c3p0_replica)
## Estabeleça uma conexão com um banco de dados
O exemplo a seguir mostra como estabelecer uma conexão com um banco de dados usando as credenciais e informações sobre a conexão em um segredo. Assim que você tiver uma conexão, será possível usar chamadas JDBC para acessar o banco de dados. Para obter mais informações, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) (Conceitos básicos de JDBC) no site da documentação de Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Estabelecer uma conexão especificando o endpoint e a porta
O exemplo a seguir mostra como estabelecer uma conexão com um banco de dados usando as credenciais em um segredo com um endpoint e uma porta que você especifica.
Os [segredos gerenciados pelo Amazon RDS](integrating_how-services-use-secrets_RDS.md) não incluem o endpoint e a porta do banco de dados. Para se conectar a um banco de dados usando credenciais principais em um segredo gerenciado pelo Amazon RDS, você as especifica em seu código.
[Segredos que são replicados para outras regiões](replicate-secrets.md) podem melhorar a latência da conexão com o banco de dados regional, mas não contêm informações diferentes de conexão em relação ao segredo da origem. Cada réplica é uma cópia do segredo de origem. Para armazenar informações de conexão regional no segredo, adicione mais key/value pares para o endpoint e informações de porta para as regiões.
Assim que você tiver uma conexão, será possível usar chamadas JDBC para acessar o banco de dados. Para obter mais informações, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) (Conceitos básicos de JDBC) no site da documentação de Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:mysql://example.com:3306";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:postgresql://example.com:5432/database";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:sqlserver://example.com:1433";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.govskope.ca.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:db2://example.com:50000";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.govskope.ca.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:redshift://example.com:5439";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Use o grupo de conexões c3p0 para estabelecer uma conexão
O exemplo a seguir mostra como estabelecer um pool de conexões com um arquivo `c3p0.properties` que usa o driver para recuperar credenciais e informações de conexão do segredo. Em `user` e `jdbcUrl`, insira o ID do segredo para configurar o grupo de conexões. Em seguida, você pode recuperar conexões do grupo e usá-las como qualquer outra conexão de banco de dados. Para obter mais informações, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) (Conceitos básicos de JDBC) no site da documentação de Java.
Para obter mais informações sobre c3p0, consulte [c3p0](https://www.mchange.com/projects/c3p0/) no site Machinery For Change.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=secretId
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=secretId
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=secretId
```
------
## Usar o agrupamento de conexões c3p0 para estabelecer uma conexão especificando o endpoint e a porta
O exemplo a seguir mostra como estabelecer um pool de conexões com um arquivo `c3p0.properties` que use o driver para recuperar credenciais em um segredo com um endpoint e uma porta que você especifica. Em seguida, você pode recuperar conexões do grupo e usá-las como qualquer outra conexão de banco de dados. Para obter mais informações, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) (Conceitos básicos de JDBC) no site da documentação de Java.
Os [segredos gerenciados pelo Amazon RDS](integrating_how-services-use-secrets_RDS.md) não incluem o endpoint e a porta do banco de dados. Para se conectar a um banco de dados usando credenciais principais em um segredo gerenciado pelo Amazon RDS, você as especifica em seu código.
[Segredos que são replicados para outras regiões](replicate-secrets.md) podem melhorar a latência da conexão com o banco de dados regional, mas não contêm informações diferentes de conexão em relação ao segredo da origem. Cada réplica é uma cópia do segredo de origem. Para armazenar informações de conexão regional no segredo, adicione mais key/value pares para o endpoint e informações de porta para as regiões.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:mysql://example.com:3306
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:postgresql://example.com:5432/database
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=jdbc-secretsmanager:sqlserver://example.com:1433
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=jdbc-secretsmanager:db2://example.com:50000
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=jdbc-secretsmanager:redshift://example.com:5439
```
------
# Obtenha um valor secreto do Secrets Manager usando o Java AWS SDK
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
+ Se você armazenar credenciais de banco de dados no segredo, use os [drivers de conexão SQL do Secrets Manager](retrieving-secrets_jdbc.md) para se conectar a um banco de dados usando as credenciais no segredo.
+ Para outros tipos de segredos, use o [componente de armazenamento em cache baseado em Java do Secrets Manager](retrieving-secrets_cache-java.md) ou chame o SDK diretamente com [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html) ou [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/BatchGetSecretValueResult.html).
Os exemplos de código a seguir mostram como usar o `GetSecretValue`.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueResponse;
import software.amazon.awssdk.services.secretsmanager.model.SecretsManagerException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* We recommend that you cache your secret values by using client-side caching.
*
* Caching secrets improves speed and reduces your costs. For more information,
* see the following documentation topic:
*
* https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html
*/
public class GetSecretValue {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
secretName - The name of the secret (for example, tutorials/MyFirstSecret).\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String secretName = args[0];
Region region = Region.US_EAST_1;
SecretsManagerClient secretsClient = SecretsManagerClient.builder()
.region(region)
.build();
getValue(secretsClient, secretName);
secretsClient.close();
}
public static void getValue(SecretsManagerClient secretsClient, String secretName) {
try {
GetSecretValueRequest valueRequest = GetSecretValueRequest.builder()
.secretId(secretName)
.build();
GetSecretValueResponse valueResponse = secretsClient.getSecretValue(valueRequest);
String secret = valueResponse.secretString();
System.out.println(secret);
} catch (SecretsManagerException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
# Obtenha um segredo do Secrets Manager usando Python
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
**Topics**
+ [Obtenha um segredo do Secrets Manager usando Python com armazenamento em cache no lado do cliente](retrieving-secrets_cache-python.md)
+ [Obtenha um valor secreto do Secrets Manager usando o Python SDK AWS](retrieving-secrets-python-sdk.md)
+ [Obtenha um lote de valores secretos do Secrets Manager usando o Python SDK AWS](retrieving-secrets-python-batch.md)
# Obtenha um segredo do Secrets Manager usando Python com armazenamento em cache no lado do cliente
Ao recuperar um segredo, é possível usar o componente de cache baseado em Python do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).
A política de caches é a do menos usado recentemente (LRU). Assim, quando o cache precisar descartar um segredo, escolherá o segredo menos usado recentemente. Por padrão, o cache atualiza segredos a cada hora. É possível configurar [com qual frequência o segredo será atualizado](retrieving-secrets_cache-ref-secretcacheconfig.md) no cache e será possível [se conectar à recuperação do segredo](retrieving-secrets_cache-ref-secretcachehook.md) para adicionar mais funcionalidades.
O cache não obriga a coleta de resíduos depois que as referências de cache são liberadas. A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você necessitar de mais segurança, como criptografia de itens no cache, use as interfaces e os métodos abstratos fornecidos.
Para usar o componente, é necessário ter o seguinte:
+ Python 3.6 ou superior.
+ botocore 1.12 ou superior. Consulte [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) e [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 ou superior. Veja [https://pypi. org/project/setuptools-fraude/](https://pypi.org/project/setuptools-scm/).
Para baixar o código-fonte, consulte o componente cliente de [cache baseado em Python do Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) em. GitHub
Para instalar o componente, use o seguinte comando.
```
$ pip install aws-secretsmanager-caching
```
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-ref-secretcache.md)
+ [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)
+ [SecretCacheHook](retrieving-secrets_cache-ref-secretcachehook.md)
+ [@InjectSecretString](retrieving-secrets_cache-decor-string.md)
+ [@InjectKeywordedSecretString](retrieving-secrets_cache-decor-keyword.md)
**Example Recuperar segredos**
O exemplo a seguir mostra como obter o valor secreto de um segredo chamado*mysecret*.
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Um cache na memória para segredos recuperados no Secrets Manager. Você usa [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) ou [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) para recuperar um segredo do cache. É possível definir as configurações de cache executando-as em um objeto [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) no construtor.
Para obter mais informações, incluindo exemplos, consulte [Obtenha um segredo do Secrets Manager usando Python com armazenamento em cache no lado do cliente](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Recupera o valor da string do segredo.
Sintaxe da solicitação
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parâmetros
+ `secret_id` (*string*): [obrigatório] o nome ou o ARN do segredo.
+ `version_stage` (*string*): a versão dos segredos que você deseja recuperar. Para obter mais informações, consulte [versões de segredos](whats-in-a-secret.md). O padrão é 'AWSCURRENT'.
Tipo de retorno
string
## get\$1secret\$1binary
Recupera o valor do binário do segredo.
Sintaxe da solicitação
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parâmetros
+ `secret_id` (*string*): [obrigatório] o nome ou o ARN do segredo.
+ `version_stage` (*string*): a versão dos segredos que você deseja recuperar. Para obter mais informações, consulte [versões de segredos](whats-in-a-secret.md). O padrão é 'AWSCURRENT'.
Tipo de retorno
String [codificada em base64](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Opções de configuração de cache para um [SecretCache](retrieving-secrets_cache-ref-secretcache.md), como o tamanho máximo do cache e a vida útil (TTL) para segredos armazenados em cache.Parâmetros
`max_cache_size` (*int*)
O tamanho máximo do cache. O padrão é de `1024` segredos.
`exception_retry_delay_base` (*int*)
O número de segundos a aguardar ao encontrar uma exceção e antes de repetir a solicitação. O padrão é `1`.
`exception_retry_growth_factor` (*int*)pur
O fator de crescimento a ser usado para calcular o tempo de espera entre novas tentativas de solicitações com falha. O padrão é `2`.
`exception_retry_delay_max` (*int*)
O tempo máximo em segundos a aguardar entre solicitações com falha. O padrão é `3600`.
`default_version_stage` (*str*)
A versão de segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). O padrão é `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
O número de segundos a aguardar entre a atualização de informações de segredos armazenados em cache. O padrão é `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Uma implementação da classe abstrata de `SecretCacheHook`. O valor padrão é `None`.
# SecretCacheHook
Uma interface para conectar a um [SecretCache](retrieving-secrets_cache-ref-secretcache.md) para executar ações nos segredos sendo armazenados no cache.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [obter](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Prepara o objeto para armazenamento no cache.
Sintaxe da solicitação
```
response = hook.put(
obj='secret_object'
)
```
Parâmetros
+ `obj` (*objeto*): [obrigatório] o segredo ou objeto que contém o segredo.
Tipo de retorno
objeto
## obter
Deriva o objeto do objeto armazenado em cache.
Sintaxe da solicitação
```
response = hook.get(
obj='secret_object'
)
```
Parâmetros
+ `obj` (*objeto*): [obrigatório] o segredo ou objeto que contém o segredo.
Tipo de retorno
objeto
# @InjectSecretString
Este decorador espera uma string de ID de segredo e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como o primeiro e o segundo argumentos. O decorador retorna o valor da string do segredo. O segredo deve conter uma string.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectSecretString ( 'mysecret' , cache )
def function_to_be_decorated( arg1, arg2, arg3):
```
# @InjectKeywordedSecretString
Este decorador espera uma string de ID de segredo e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como o primeiro e o segundo argumentos. Os argumentos restantes mapeiam parâmetros da função empacotada para chaves JSON no segredo. O segredo deve conter uma string na estrutura JSON.
Para um segredo que contém esse JSON:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
O exemplo a seguir mostra como extrair os valores JSON para `username` e `password` do segredo.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectKeywordedSecretString ( secret_id = 'mysecret' , cache = cache , func_username = 'username' , func_password = 'password' )
def function_to_be_decorated( func_username, func_password):
print( 'Do something with the func_username and func_password parameters')
```
# Obtenha um valor secreto do Secrets Manager usando o Python SDK AWS
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
Para aplicações Python, use o [componente de cache baseado em Python do Secrets Manager](retrieving-secrets_cache-python.md) ou chame o SDK diretamente com [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html) ou [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html).
Os exemplos de código a seguir mostram como usar o `GetSecretValue`.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
"""
Purpose
Shows how to use the AWS SDK for Python (Boto3) with AWS
Secrets Manager to get a specific of secrets that match a
specified name
"""
import boto3
import logging
from get_secret_value import GetSecretWrapper
# Configure logging
logging.basicConfig(level=logging.INFO)
def run_scenario(secret_name):
"""
Retrieve a secret from AWS Secrets Manager.
:param secret_name: Name of the secret to retrieve.
:type secret_name: str
"""
try:
# Validate secret_name
if not secret_name:
raise ValueError("Secret name must be provided.")
# Retrieve the secret by name
client = boto3.client("secretsmanager")
wrapper = GetSecretWrapper(client)
secret = wrapper.get_secret(secret_name)
# Note: Secrets should not be logged.
return secret
except Exception as e:
logging.error(f"Error retrieving secret: {e}")
raise
class GetSecretWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def get_secret(self, secret_name):
"""
Retrieve individual secrets from AWS Secrets Manager using the get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param secret_name: The name of the secret fetched.
:type secret_name: str
"""
try:
get_secret_value_response = self.client.get_secret_value(
SecretId=secret_name
)
logging.info("Secret retrieved successfully.")
return get_secret_value_response["SecretString"]
except self.client.exceptions.ResourceNotFoundException:
msg = f"The requested secret {secret_name} was not found."
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred: {str(e)}.")
raise
```
# Obtenha um lote de valores secretos do Secrets Manager usando o Python SDK AWS
O exemplo de código a seguir mostra como obter um lote de valores de segredo do Secrets Manager.
**Permissões obrigatórias: **
+ `secretsmanager:BatchGetSecretValue`
+ Permissão `secretsmanager:GetSecretValue` para cada segredo que deseja recuperar.
+ Se você usa filtros, também deve ter `secretsmanager:ListSecrets`.
Para um exemplo de política de permissões, consulte [Exemplo: permissão para recuperar um grupo de valores de segredos em um lote](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Importante**
Se você tiver uma política de VPCE que nega permissão para recuperar um segredo individual no grupo que você está recuperando, `BatchGetSecretValue` não retornará nenhum valor de segredo e retornará um erro.
```
class BatchGetSecretsWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def batch_get_secrets(self, filter_name):
"""
Retrieve multiple secrets from AWS Secrets Manager using the batch_get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param filter_name: The full or partial name of secrets to be fetched.
:type filter_name: str
"""
try:
secrets = []
response = self.client.batch_get_secret_value(
Filters=[{"Key": "name", "Values": [f"{filter_name}"]}]
)
for secret in response["SecretValues"]:
secrets.append(json.loads(secret["SecretString"]))
if secrets:
logger.info("Secrets retrieved successfully.")
else:
logger.info("Zero secrets returned without error.")
return secrets
except self.client.exceptions.ResourceNotFoundException:
msg = f"One or more requested secrets were not found with filter: {filter_name}"
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred:\n{str(e)}.")
raise
```
# Obtenção de um valor de segredo do Secrets Manager usando .NET
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
**Topics**
+ [Obtenha um segredo do Secrets Manager usando .NET com armazenamento em cache no lado do cliente](retrieving-secrets_cache-net.md)
+ [Obtenha um valor secreto do Secrets Manager usando o SDK para .NET](retrieving-secrets-net-sdk.md)
# Obtenha um segredo do Secrets Manager usando .NET com armazenamento em cache no lado do cliente
Ao recuperar um segredo, você pode usar o componente de cache baseado em .NET do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).
A política de caches é a do menos usado recentemente (LRU). Assim, quando o cache precisar descartar um segredo, escolherá o segredo menos usado recentemente. Por padrão, o cache atualiza segredos a cada hora. É possível configurar [com qual frequência o segredo será atualizado](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL) no cache e será possível [se conectar à recuperação do segredo](retrieving-secrets_cache-net-ISecretCacheHook.md) para adicionar mais funcionalidades.
O cache não obriga a coleta de resíduos depois que as referências de cache são liberadas. A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você necessitar de mais segurança, como criptografia de itens no cache, use as interfaces e os métodos abstratos fornecidos.
Para usar o componente, é necessário ter o seguinte:
+ .NET Framework 4.6.2 ou superior, ou .NET Standard 2.0 ou superior. Consulte [Download .NET](https://dotnet.microsoft.com/en-us/download) (Baixe .NET) no site da Microsoft .NET.
+ O AWS SDK para.NET. Consulte [AWS SDKs](asm_access.md#asm-sdks).
Para baixar o código-fonte, consulte [Cliente de cache para.NET](https://github.com/aws/aws-secretsmanager-caching-net ) on GitHub.
Para usar o cache, primeiro instancie-o e, em seguida, recupere o seu segredo usando `GetSecretString` ou `GetSecretBinary`. Em recuperações sucessivas, o cache retorna a cópia armazenada em cache do segredo.
**Para obter o pacote de cache**
+ Execute um destes procedimentos:
+ Execute o seguinte comando CLI do .NET em seu diretório de projeto.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Adicione a seguinte referência de pacote ao seu arquivo `.csproj`.
```
```
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)
+ [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
**Example Recuperar segredos**
O exemplo de código a seguir mostra um método que recupera um segredo chamado*MySecret*.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName ="MySecret";
private SecretsManagerCache cache = new SecretsManagerCache();
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string MySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
**Example Configuração da duração da atualização do cache de vida útil (TTL)**
O exemplo de código a seguir mostra um método que recupera um segredo chamado *MySecret* e define a duração da atualização do cache TTL como 24 horas.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName = "MySecret";
private static SecretCacheConfiguration cacheConfiguration = new SecretCacheConfiguration
{
CacheItemTTL = 86400000
};
private SecretsManagerCache cache = new SecretsManagerCache(cacheConfiguration);
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string mySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
# SecretsManagerCache
Um cache na memória para segredos solicitados no Secrets Manager. Você usa [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) ou [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) para recuperar um segredo do cache. É possível definir as configurações de cache executando-as em um objeto [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) no construtor.
Para obter mais informações, incluindo exemplos, consulte [Obtenha um segredo do Secrets Manager usando .NET com armazenamento em cache no lado do cliente](retrieving-secrets_cache-net.md).
## Construtores
`public SecretsManagerCache()`
Construtor padrão para um objeto `SecretsManagerCache`.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Constrói um novo cache usando um cliente do Secrets Manager criado usando o [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) fornecido. Use esse construtor para personalizar o cliente do Secrets Manager, por exemplo, para usar uma região ou endpoint específico.
**Parâmetros**
secretsManager
O [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)para recuperar segredos de.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Constrói um novo cache de segredo usando a [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) fornecida. Use esse construtor para configurar o cache, por exemplo, o número de segredos a serem armazenados em cache e com que frequência ele é atualizado.
**Parâmetros**
config
Uma [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) que contém informações de configuração para o cache.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Constrói um novo cache usando um cliente Secrets Manager criado usando o fornecido [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)e um[SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md). Use este construtor para personalizar o cliente do Secrets Manager, por exemplo, para usar uma região ou endpoint específico, assim como configurar o cache, por exemplo, o número de segredos a serem armazenados em cache e com que frequência ele será atualizado.
**Parâmetros**
secretsManager
O [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)para recuperar segredos de.
config
Uma [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) que contém informações de configuração para o cache.
## Métodos
### GetSecretString
`public async Task GetSecretString(String secretId)`
Recupera um segredo de string do Secrets Manager.Parâmetros
secretId
O ARN ou o nome do segredo a ser recuperado.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Recupera um segredo de binário do Secrets Manager.Parâmetros
secretId
O ARN ou o nome do segredo a ser recuperado.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Solicita o valor do segredo do Secrets Manager e atualiza o cache com quaisquer alterações. Se não houver entrada de cache existente, ele criará uma nova. Se a atualização for bem-sucedida, ele retornará `true`.Parâmetros
secretId
O ARN ou o nome do segredo a ser recuperado.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Retorna a entrada de cache para o segredo especificado, se ele existir no cache. Caso contrário, ele recupera o segredo do Secrets Manager e cria uma nova entrada de cache.Parâmetros
secretId
O ARN ou o nome do segredo a ser recuperado.
# SecretCacheConfiguration
Opções de configuração de cache para um [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), como o tamanho máximo do cache e a vida útil (TTL) para segredos armazenados em cache.
## Propriedades
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
O TTL de um item de cache em milissegundos. O padrão é de `3600000` minutos ou 1 hora. O máximo é de `4294967295` milissegundos, que é aproximadamente 49,7 dias.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
O tamanho máximo do cache. O padrão é de 1.024 segredos. O máximo é 65.535.
### VersionStage
`public string VersionStage { get; set; }`
A versão de segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). O padrão é `"AWSCURRENT"`.
### Cliente
`public IAmazonSecretsManager Client { get; set; }`
O [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)para recuperar segredos de. Se for `null`, o cache instancia um novo cliente. O padrão é `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
O [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md).
# ISecretCacheHook
Uma interface para conectar a um [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) para executar ações nos segredos sendo armazenados no cache.
## Métodos
### Put
`object Put(object o);`
Prepare o objeto para o armazenamento no cache.
Retorna o objeto a ser armazenado no cache.
### Obtenção
`object Get(object cachedObject);`
Derive o objeto do objeto sendo armazenado em cache.
Retorna o objeto a ser retornado do cache
# Obtenha um valor secreto do Secrets Manager usando o SDK para .NET
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
Para aplicações .NET, use o [componente de cache baseado em .NET do Secrets Manager](retrieving-secrets_cache-net.md) ou chame o SDK diretamente com [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) ou [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html).
Os exemplos de código a seguir mostram como usar o `GetSecretValue`.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
///
/// This example uses the Amazon Web Service Secrets Manager to retrieve
/// the secret value for the provided secret name.
///
public class GetSecretValue
{
///
/// The main method initializes the necessary values and then calls
/// the GetSecretAsync and DecodeString methods to get the decoded
/// secret value for the secret named in secretName.
///
public static async Task Main()
{
string secretName = "<<{{MySecretName}}>>";
string secret;
IAmazonSecretsManager client = new AmazonSecretsManagerClient();
var response = await GetSecretAsync(client, secretName);
if (response is not null)
{
secret = DecodeString(response);
if (!string.IsNullOrEmpty(secret))
{
Console.WriteLine($"The decoded secret value is: {secret}.");
}
else
{
Console.WriteLine("No secret value was returned.");
}
}
}
///
/// Retrieves the secret value given the name of the secret to
/// retrieve.
///
/// The client object used to retrieve the secret
/// value for the given secret name.
/// The name of the secret value to retrieve.
/// The GetSecretValueReponse object returned by
/// GetSecretValueAsync.
public static async Task GetSecretAsync(
IAmazonSecretsManager client,
string secretName)
{
GetSecretValueRequest request = new GetSecretValueRequest()
{
SecretId = secretName,
VersionStage = "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified.
};
GetSecretValueResponse response = null;
// For the sake of simplicity, this example handles only the most
// general SecretsManager exception.
try
{
response = await client.GetSecretValueAsync(request);
}
catch (AmazonSecretsManagerException e)
{
Console.WriteLine($"Error: {e.Message}");
}
return response;
}
///
/// Decodes the secret returned by the call to GetSecretValueAsync and
/// returns it to the calling program.
///
/// A GetSecretValueResponse object containing
/// the requested secret value returned by GetSecretValueAsync.
/// A string representing the decoded secret value.
public static string DecodeString(GetSecretValueResponse response)
{
// Decrypts secret using the associated AWS Key Management Service
// Customer Master Key (CMK.) Depending on whether the secret is a
// string or binary value, one of these fields will be populated.
if (response.SecretString is not null)
{
var secret = response.SecretString;
return secret;
}
else if (response.SecretBinary is not null)
{
var memoryStream = response.SecretBinary;
StreamReader reader = new StreamReader(memoryStream);
string decodedBinarySecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(reader.ReadToEnd()));
return decodedBinarySecret;
}
else
{
return string.Empty;
}
}
}
```
# Obter um valor de segredo do Secrets Manager usando Go
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
**Topics**
+ [Obter um segredo do Secrets Manager usando Go com armazenamento em cache no lado do cliente](retrieving-secrets_cache-go.md)
+ [Obtenha um valor secreto do Secrets Manager usando o Go AWS SDK](retrieving-secrets-go-sdk.md)
# Obter um segredo do Secrets Manager usando Go com armazenamento em cache no lado do cliente
Ao recuperar um segredo, você pode usar o componente de cache baseado em Go do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).
A política de caches é a do menos usado recentemente (LRU). Assim, quando o cache precisar descartar um segredo, escolherá o segredo menos usado recentemente. Por padrão, o cache atualiza segredos a cada hora. É possível configurar [com qual frequência o segredo será atualizado](retrieving-secrets_cache-go_CacheConfig.md) no cache e será possível [se conectar à recuperação do segredo](retrieving-secrets_cache-go_CacheHook.md) para adicionar mais funcionalidades.
O cache não obriga a coleta de resíduos depois que as referências de cache são liberadas. A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você necessitar de mais segurança, como criptografia de itens no cache, use as interfaces e os métodos abstratos fornecidos.
Para usar o componente, é necessário ter o seguinte:
+ AWS SDK para Go. Consulte [AWS SDKs](asm_access.md#asm-sdks).
Para baixar o código-fonte, consulte [Cliente de cache do Secrets Manager Go](https://github.com/aws/aws-secretsmanager-caching-go ) ativado GitHub.
Para configurar um ambiente de desenvolvimento Go, consulte [Golang Getting Started](https://golang.org/doc/install) (Conceitos básicos de Golang) no site da Go Programming Language.
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [tipo Cache](retrieving-secrets_cache-go_cache.md)
+ [digitar CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [digitar CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Recuperar segredos**
O exemplo de código a seguir mostra uma função Lambda que recupera um segredo.
```
package main
import (
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-secretsmanager-caching-go/secretcache"
)
var (
secretCache, _ = secretcache.New()
)
func HandleRequest(secretId string) string {
result, _ := secretCache.GetSecretString(secretId)
// Use the secret, return success
}
func main() {
lambda. Start( HandleRequest)
}
```
# tipo Cache
Um cache na memória para segredos solicitados no Secrets Manager. Você usa [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) ou [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) para recuperar um segredo do cache.
O exemplo a seguir mostra como definir as configurações de cache.
```
// Create a custom secretsmanager client
client := getCustomClient()
// Create a custom CacheConfig struct
config := secretcache. CacheConfig{
MaxCacheSize: secretcache.DefaultMaxCacheSize + 10,
VersionStage: secretcache.DefaultVersionStage,
CacheItemTTL: secretcache.DefaultCacheItemTTL,
}
// Instantiate the cache
cache, _ := secretcache.New(
func( c *secretcache.Cache) { c. CacheConfig = config },
func( c *secretcache.Cache) { c. Client = client },
)
```
Para obter mais informações, incluindo exemplos, consulte [Obter um segredo do Secrets Manager usando Go com armazenamento em cache no lado do cliente](retrieving-secrets_cache-go.md).
## Métodos
### Novo
`func New(optFns ...func(*Cache)) (*Cache, error)`
O New constrói um cache do segredo usando opções funcionais. Caso contrário, usa opções padrão. Inicializa um SecretsManager cliente a partir de uma nova sessão. Inicializa CacheConfig com os valores padrão. Inicializa o cache LRU com um tamanho máximo padrão.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString obtém o valor da string secreta do cache para determinado ID secreto. Retorna a string do segredo e um erro caso a operação falhe.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage obtém o valor da string secreta do cache para determinado ID secreto e [estágio de versão](whats-in-a-secret.md#term_version). Retorna a string do segredo e um erro caso a operação falhe.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary obtém o valor binário secreto do cache para determinado ID secreto. Caso a operação falhe, ele retorna o binário do segredo e um erro.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage obtém o valor binário secreto do cache para determinado ID secreto e [estágio de versão](whats-in-a-secret.md#term_version). Caso a operação falhe, ele retorna o binário do segredo e um erro.
# digitar CacheConfig
Opções de configuração de cache para o [Cache](retrieving-secrets_cache-go_cache.md), como o tamanho máximo do cache, a [etapa de versão](whats-in-a-secret.md#term_version) padrão e a vida útil (TTL) para segredos armazenados em cache.
```
type CacheConfig struct {
// The maximum cache size. The default is 1024 secrets.
MaxCacheSize int
// The TTL of a cache item in nanoseconds. The default is
// 3.6e10^12 ns or 1 hour.
CacheItemTTL int64
// The version of secrets that you want to cache. The default
// is "AWSCURRENT".
VersionStage string
// Used to hook in-memory cache updates.
Hook CacheHook
}
```
# digitar CacheHook
Uma interface para conectar a um [Cache](retrieving-secrets_cache-go_cache.md) para executar ações no segredo que está sendo armazenado no cache.
## Métodos
### Put
`Put(data interface{}) interface{}`
Prepara o objeto para armazenamento no cache.
### Obtenção
`Get(data interface{}) interface{}`
Deriva o objeto do objeto armazenado em cache.
# Obtenha um valor secreto do Secrets Manager usando o Go AWS SDK
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
Para aplicações Go, use o [componente de cache baseado em Go do Secrets Manager](retrieving-secrets_cache-go.md) ou chame o SDK diretamente com [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue) ou [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue).
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
// Use this code snippet in your app.
// If you need more information about configurations or implementing the sample code, visit the AWS docs:
// https://aws.github.io/aws-sdk-go-v2/docs/getting-started/
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
func main() {
secretName := "<<{{MySecretName}}>>"
region := "<<{{MyRegionName}}>>"
config, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
if err != nil {
log.Fatal(err)
}
// Create Secrets Manager client
svc := secretsmanager.NewFromConfig(config)
input := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretName),
VersionStage: aws.String("AWSCURRENT"), // VersionStage defaults to AWSCURRENT if unspecified
}
result, err := svc.GetSecretValue(context.TODO(), input)
if err != nil {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
log.Fatal(err.Error())
}
// Decrypts secret using the associated KMS key.
var secretString string = *result.SecretString
// Your code goes here.
}
```
# Obter um valor de segredo do Secrets Manager usando Rust
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
**Topics**
+ [Obtenha um segredo do Secrets Manager usando Rust com armazenamento em cache no lado do cliente](retrieving-secrets_cache-rust.md)
+ [Obtenha um valor secreto do Secrets Manager usando o Rust SDK AWS](retrieving-secrets-rust-sdk.md)
# Obtenha um segredo do Secrets Manager usando Rust com armazenamento em cache no lado do cliente
Ao recuperar um segredo, é possível usar o componente de cache baseado em Rust do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).
A política de cache é a do primeiro a entrar, primeiro a sair (FIFO). Assim, quando o cache precisar descartar um segredo, usará o segredo mais antigo. Por padrão, o cache atualiza segredos a cada hora. É possível configurar as seguintes opções:
+ `max_size`: o número máximo de segredos em cache a serem mantidos antes da remoção dos segredos que não foram acessados recentemente.
+ `ttl`: a duração pela qual um item armazenado em cache é considerado válido antes de exigir uma atualização do estado do segredo.
A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você precisar de segurança adicional, como criptografar itens no cache, use as características fornecidas para modificar o cache.
Para usar o componente, é necessário ter um ambiente de desenvolvimento do Rust 2021 com `tokio`. Para obter mais informações, consulte [Conceitos básicos](https://www.rust-lang.org/learn/get-started) no site Rust Programming Language.
Para baixar o código-fonte, consulte o componente [cliente de cache baseado em Rust do Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) em. GitHub
Para instalar o componente de armazenamento em cache, use o seguinte comando.
```
cargo add aws_secretsmanager_caching
```
**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações, consulte [Referência de permissões](auth-and-access.md#reference_iam-permissions).
**Example Recuperar segredos**
O exemplo a seguir mostra como obter o valor secreto de um segredo chamado*MyTest*.
```
use aws_secretsmanager_caching::SecretsManagerCachingClient;
use std::num::NonZeroUsize;
use std::time::Duration;
let client = match SecretsManagerCachingClient::default(
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = match client.get_secret_value("MyTest", None, None).await {
Ok(s) => s.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
**Example Instanciação do cache com uma configuração personalizada e um cliente personalizado**
O exemplo a seguir mostra como configurar o cache e, em seguida, obter o valor secreto de um segredo chamado*MyTest*.
```
let config = aws_config::load_defaults(BehaviorVersion::latest())
.await
.into_builder()
.region(Region::from_static("us-west-2"))
.build();
let asm_builder = aws_sdk_secretsmanager::config::Builder::from(&config);
let client = match SecretsManagerCachingClient::from_builder(
asm_builder,
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = client
.get_secret_value("MyTest", None, None)
.await
{
Ok(c) => c.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
```
# Obtenha um valor secreto do Secrets Manager usando o Rust SDK AWS
Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.
Para aplicativos Rust, use o [componente de cache baseado em Rust do Secrets Manager](retrieving-secrets_cache-rust.md) ou chame o [SDK](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) diretamente com ou. GetSecretValue BatchGetSecretValue
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
async fn show_secret(client: &Client, name: &str) -> Result<(), Error> {
let resp = client.get_secret_value().secret_id(name).send().await?;
println!("Value: {}", resp.secret_string().unwrap_or("No value!"));
Ok(())
}
```
# Use AWS Secrets Manager segredos no Amazon Elastic Kubernetes Service
Para mostrar segredos do AWS Secrets Manager (ASCP) como arquivos montados nos pods do Amazon EKS, você pode usar os AWS segredos e o provedor de configuração do driver CSI do Kubernetes Secrets Store. O ASCP funciona com o Amazon Elastic Kubernetes Service 1.17\$1 executando um grupo de nós do Amazon EC2. AWS Fargate grupos de nós não são suportados. Com o ASCP, é possível armazenar e gerenciar segredos no Secrets Manager e, em seguida, recuperá-los por meio de workloads executadas no Amazon EKS. Se seu segredo contiver vários pares de chave-valor no formato JSON, será possível escolher quais montará no Amazon EKS. O ASCP usa a sintaxe JMESPath para consultar os pares de chave/valor no seu segredo. O ASCP também funciona com parâmetros do Parameter Store. O ASCP oferece dois métodos de autenticação com o Amazon EKS. A primeira abordagem usa perfis do IAM para contas de serviço (IRSA). A segunda abordagem usa a Identidade de Pods. Cada abordagem tem seus benefícios e casos de uso.
## ASCP com perfis do IAM para contas de serviço (IRSA)
O ASCP com funções do IAM para contas de serviço (IRSA) permite que você monte segredos AWS Secrets Manager como arquivos em seus pods do Amazon EKS. Essa abordagem é adequada quando:
+ É necessário montar os segredos como arquivos nos seus pods.
+ Você está usando a versão 1.17 ou posterior do Amazon EKS com grupos de nós do Amazon EC2.
+ Você deseja recuperar pares de chave-valor específicos de segredos formatados em JSON.
Para obter mais informações, consulte [Use AWS segredos e CSI do provedor de configuração com funções do IAM para contas de serviço (IRSA)](integrating_ascp_irsa.md).
## ASCP com Identidade de Pods
O método ASCP com Identidade de Pods aumenta a segurança e simplifica a configuração para acessar os segredos no Amazon EKS. Essa abordagem é benéfica quando:
+ É necessário um gerenciamento de permissões mais granular no nível do pod.
+ Você está usando a versão 1.24 ou posterior do Amazon EKS.
+ Você quer performance e escalabilidade aprimorados.
Para obter mais informações, consulte [Use AWS segredos e o provedor de configuração CSI com o Pod Identity para Amazon EKS](ascp-pod-identity-integration.md).
## Como escolher a abordagem correta
Considere os seguintes fatores ao decidir entre o ASCP com IRSA e o ASCP com Identidade de Pods:
+ Amazon EKSversion: O Pod Identity requer o Amazon EKS 1.24\$1, enquanto o driver CSI funciona com o Amazon EKS 1.17\$1.
+ Requisitos de segurança: a Identidade de Pods oferece um controle mais granular no nível do pod.
+ Performance: a Identidade de Pods geralmente tem melhor performance em ambientes de alta escala.
+ Complexidade: a Identidade de Pods simplifica a configuração ao eliminar a necessidade de contas de serviço separadas.
Escolha o método que melhor se alinhe aos seus requisitos específicos e ao ambiente do Amazon EKS.
# Instalar o ASCP para Amazon EKS
Esta seção explica como instalar o AWS Secrets and Configuration Provider para o Amazon EKS. Com o ASCP, você pode montar segredos do Secrets Manager e parâmetros AWS Systems Manager como arquivos nos pods do Amazon EKS.
## Pré-requisitos
+ Um cluster do Amazon EKS
+ Versão 1.24 ou posterior da Identidade de Pods
+ Versão 1.17 ou posterior do IRSA
+ O AWS CLI instalado e configurado
+ kubectl instalado e configurado para o cluster do Amazon EKS
+ Helm (versão 3.0 ou superior)
## Instalar e configurar o ASCP
O ASCP está disponível GitHub no repositório [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). O repositório também contém arquivos YAML de exemplo para criar e montar um segredo.
Durante a instalação, é possível configurar o ASCP para usar um endpoint do FIPS. Para uma lista de endpoints , consulte [AWS Secrets Manager endpoints](asm_access.md#endpoints).
**Para instalar o ASCP como um complemento do EKS**
1. Instalar `eksctl` ([instruções de instalação](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Execute o comando a seguir para instalar o complemento com a [configuração padrão](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml):
```
eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider
```
Se você quiser configurar o complemento, execute o seguinte comando de instalação:
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
O arquivo de configuração pode ser um arquivo YAML ou JSON. Para ver o esquema de configuração do complemento:
1. Execute o comando a seguir e observe a versão mais recente do complemento:
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Execute o comando a seguir para ver o esquema de configuração do complemento, `` substituindo-o pela versão da etapa anterior:
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Para instalar o ASCP usando o Helm**
1. Para garantir que o repositório esteja apontando para os gráficos mais recentes, use `helm repo update.`
1. Instale o chart. Veja a seguir um exemplo do comando `helm install`:
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Para usar um endpoint do FIPS, adicione o sinalizador a seguir: `--set useFipsEndpoint=true`
1. Para configurar o controle de utilização, adicione o sinalizador a seguir: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`
1. Se o driver CSI do Secrets Store já estiver instalado em seu cluster, adicione o sinalizador a seguir: `--set secrets-store-csi-driver.install=false`. Isso ignorará a instalação do driver CSI do Secrets Store como uma dependência.
**Para instalar usando o YAML no repositório**
+ Use os seguintes comandos.
```
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml
```
## Verificar as instalações
Para verificar as instalações do cluster do EKS, do driver CSI do Secrets Store e do plug-in do ASCP, siga estas etapas:
1. Verifique o cluster do EKS:
```
eksctl get cluster --name clusterName
```
Este comando deve retornar informações sobre o cluster.
1. Verifique a instalação do driver CSI do Secrets Store:
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
É necessário ver pods em execução com nomes como `csi-secrets-store-secrets-store-csi-driver-xxx`.
1. Verifique a instalação do plug-in do ASCP:
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Resultado do exemplo:
```
NAME READY STATUS RESTARTS AGE
csi-secrets-store-provider-aws-12345 1/1 Running 0 2m
```
------
#### [ Helm installation ]
```
$ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws
```
Resultado do exemplo:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
É necessário ver pods no estado `Running`.
Depois de executar esses comandos, se tudo estiver configurado corretamente, será necessário ver todos os componentes funcionando sem erros. Se você encontrar algum problema, talvez seja necessário solucionar verificando os logs dos pods específicos que estão com problemas.
## Solução de problemas
1. Para verificar os logs do provedor do ASCP, execute:
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Verifique o status de todos os pods no namespace `kube-system`.
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Todos os pods relacionados ao driver CSI e ao ASCP devem estar no estado “Running”.
1. Verifique a versão do driver CSI:
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Este comando deve retornar informações sobre o driver CSI instalado.
## Recursos adicionais do
Para obter mais informações sobre o uso do ASCP com o Amazon EKS, consulte os seguintes recursos:
+ [Uso da Identidade de Pods com o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Driver CSI da Secrets Store ativado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Use AWS segredos e o provedor de configuração CSI com o Pod Identity para Amazon EKS
A integração do AWS Secrets and Configuration Provider com o Pod Identity Agent for Amazon Elastic Kubernetes Service fornece segurança aprimorada, configuração simplificada e desempenho aprimorado para aplicativos executados no Amazon EKS. O Pod Identity simplifica a autenticação do IAM para o Amazon EKS ao recuperar segredos do Secrets Manager ou AWS Systems Manager parâmetros do Parameter Store.
A Identidade de Pods do Amazon EKS simplifica o processo de configuração de permissões do IAM para aplicações do Kubernetes, possibilitando que as permissões sejam configuradas diretamente por meio das interfaces do Amazon EKS, reduzindo o número de etapas e eliminando a necessidade de alternar entre os serviços do Amazon EKS e do IAM. A Identidade de Pods permite o uso de um único perfil do IAM em vários clusters sem atualizar as políticas de confiança, e oferece suporte a [tags de sessão de perfis](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) para um controle de acesso mais granular. Essa abordagem não apenas simplifica o gerenciamento de políticas, permitindo a reutilização de políticas de permissão em todas as funções, mas também aumenta a segurança ao permitir o acesso a AWS recursos com base nas tags correspondentes.
## Como funciona
1. A Identidade de Pods atribui um perfil do IAM ao pod.
1. O ASCP usa essa função para se autenticar com. Serviços da AWS
1. Se autorizado, o ASCP recupera os segredos solicitados e os disponibiliza para o pod.
Para obter mais informações, consulte [Como a Identidade de Pods do Amazon EKS funciona](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) no *Guia do usuário do Amazon EKS*.
## Pré-requisitos
**Importante**
A Identidade de Pods é compatível somente com o Amazon EKS na nuvem. Ela não é compatível com o [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), o [Serviço Red Hat OpenShift na AWS](https://aws.amazon.com/rosa/) ou com clusters autogerenciados do Kubernetes em instâncias do Amazon EC2.
+ Cluster do Amazon EKS (versão 1.24 ou posterior)
+ Acesso a um AWS CLI cluster Amazon EKS via `kubectl`
+ Acesso a dois Contas da AWS (para acesso entre contas)
## Instalar o agente da Identidade de Pods do Amazon EKS
Para usar a Identidade de Pods com o cluster, é necessário instalar o complemento do agente da Identidade de Pods do Amazon EKS.
**Para instalar o complemento agente da Identidade de Pods**
+ Instale o complemento do agente de Identidade de Pods no seu cluster.
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Configurar o ASCP com a Identidade de Pods
1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crie um perfil do IAM que possa ser assumido pela entidade principal do serviço do Amazon EKS para a Identidade de Pods:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Anexe a política do IAM ao perfil.
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Crie uma associação de Identidade de Pods. Para obter um exemplo, consulte [Criar uma associação de Identidade de Pods](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) no *Guia do usuário do Amazon EKS*
1. Crie a `SecretProviderClass` que especifica quais segredos devem ser montados no pod:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
A principal diferença no `SecretProviderClass` entre o IRSA e a Identidade de Pods é o parâmetro opcional `usePodIdentity`. É um campo opcional que determina a abordagem de autenticação. Quando não especificado, o padrão é usar os perfis do IAM para contas de serviço (IRSA).
+ Para usar a Identidade de Pods do EKS, use qualquer um destes valores: `"true", "True", "TRUE", "t", "T"`.
+ Para usar explicitamente o IRSA, defina para qualquer um destes valores: `"false", "False", "FALSE", "f", or "F"`.
1. Implante o pod que monta os segredos em `/mnt/secrets-store`:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Se você usa um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster está tenha um AWS STS endpoint. Para obter informações sobre a criação de um endpoint, consulte [Endpoints da VPC da interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) no *Guia do usuário do AWS Identity and Access Management *.
### Verificar a montagem do segredo
Para verificar se o segredo foi montado corretamente, execute o comando a seguir.
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Para configurar a Identidade de Pods do Amazon EKS para acessar os segredos no Secrets Manager**
1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crie um segredo no Secrets Manager, caso ainda não tenha um.
## Solução de problemas
É possível visualizar a maioria dos erros ao descrever a implantação do pod.
**Para ver mensagens de erro para o contêiner**
1. Obtenha uma lista de nomes de pods com o comando a seguir. Se você não estiver usando o namespace padrão, use `-n NAMESPACE`.
```
kubectl get pods
```
1. Para descrever o pod, no comando a seguir, *PODID* use o ID do pod dos pods que você encontrou na etapa anterior. Se você não estiver usando o namespace padrão, use `-n NAMESPACE`.
```
kubectl describe pod/PODID
```
**Para ver erros para o ASCP**
+ Para encontrar mais informações nos registros do provedor, no comando a seguir, *PODID* use o ID do *csi-secrets-store-provider-aws* Pod.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Use AWS segredos e CSI do provedor de configuração com funções do IAM para contas de serviço (IRSA)
**Topics**
+ [Pré-requisitos](#prerequisites)
+ [Configurar o controle de acesso](#integrating_ascp_irsa_access)
+ [Identificar quais segredos montar](#integrating_ascp_irsa_mount)
+ [Solução de problemas](#integrating_ascp_irsa_trouble)
## Pré-requisitos
+ Cluster do Amazon EKS (versão 1.17 ou posterior)
+ Acesso a um AWS CLI cluster Amazon EKS via `kubectl`
## Configurar o controle de acesso
O ASCP recupera a Identidade de Pods do Amazon EKS e a substitui por um perfil do IAM. Você define permissões em uma política do IAM para esse perfil do IAM. Quando o ASCP assume o perfil do IAM, ele obtém acesso aos segredos que você autorizou. Outros contêineres não podem acessar os segredos, a menos que você também os associe ao perfil do IAM.
**Para conceder ao seu pod do Amazon EKS acesso aos segredos no Secrets Manager**
1. Crie uma política de permissões que conceda as permissões `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` aos segredos que o pod precisa acessar. Para visualizar um exemplo de política, consulte [Exemplo: permissão para ler e descrever segredos individuais](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crie um provedor IAM OIDC Connect (OIDC) para o cluster, se você ainda não tiver um. Para obter mais informações, consulte [Criação de um provedor IAM OIDC para o seu cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) no *Guia do Usuário do Amazon EKS*.
1. Crie um [perfil do IAM para conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) e anexe a política a ele. Para obter mais informações, consulte [Criação de um perfil do IAM para uma conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) no *Guia do usuário do Amazon EKS*.
1. Se você usa um cluster privado do Amazon EKS, certifique-se de que a VPC na qual o cluster está tenha um AWS STS endpoint. Para obter informações sobre a criação de um endpoint, consulte [Endpoints da VPC da interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) no *Guia do usuário do AWS Identity and Access Management *.
## Identificar quais segredos montar
Para determinar quais segredos o ASCP monta no Amazon EKS como arquivos no sistema de arquivos, você cria um arquivo YAML [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass). O `SecretProviderClass` lista os segredos a serem montados e o nome do arquivo no qual montá-los. O`SecretProviderClass` deve estar no mesmo namespace que o pod do Amazon EKS ao qual ele faz referência.
### Montagem dos segredos como arquivos
[As instruções a seguir mostram como montar segredos como arquivos usando exemplos de arquivos YAML .yaml e [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)
**Para montar segredos no Amazon EKS**
1. Aplique o `SecretProviderClass` ao pod:
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Implante o pod:
```
kubectl apply -f ExampleDeployment.yaml
```
1. O ASCP monta os arquivos.
## Solução de problemas
É possível visualizar a maioria dos erros ao descrever a implantação do pod.
**Para ver mensagens de erro para o contêiner**
1. Obtenha uma lista de nomes de pods com o comando a seguir. Se você não estiver usando o namespace padrão, use `-n nameSpace`.
```
kubectl get pods
```
1. Para descrever o pod, no comando a seguir, *podId* use o ID do pod dos pods que você encontrou na etapa anterior. Se você não estiver usando o namespace padrão, use `-n nameSpace`.
```
kubectl describe pod/podId
```
**Para ver erros para o ASCP**
+ Para encontrar mais informações nos registros do provedor, no comando a seguir, *podId* use o ID do *csi-secrets-store-provider-aws* Pod.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Verifique se a CRD do `SecretProviderClass` está instalada:**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Este comando deve retornar informações sobre a definição do recurso personalizado `SecretProviderClass`.
+
**Verifique se o SecretProviderClass objeto foi criado.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Segredos e exemplos de código do provedor de configuração
## Exemplos de autenticação do ASCP e controle de acesso
### Exemplo: política do IAM que permite que o serviço da Identidade de Pods do Amazon EKS (pods.eks.amazonaws.com) assuma o perfil e marque a sessão:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Você usa o YAML para descrever quais segredos devem ser montados no Amazon EKS usando o ASCP. Para obter exemplos, consulte [SecretProviderClass uso](#ascp-scenarios-secretproviderclass).
### SecretProviderClass Estrutura YAML
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
O campo de parâmetros contém os detalhes da solicitação de montagem:
**region**
(Opcional) O Região da AWS do segredo. Se você não usar esse campo, o ASCP procurará a Região a partir da anotação no nó. Essa pesquisa adiciona sobrecarga às solicitações de montagem, portanto, recomendamos que você forneça a região para clusters que usam um grande número de pods.
Se você também especificar `failoverRegion`, o ASCP tentará recuperar o segredo de ambas as regiões. Se qualquer uma das regiões retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito de `region`, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse segredo.
**failoverRegion**
(Opcional) Se você incluir esse campo, o ASCP tentará recuperar o segredo das regiões definidas em `region` e nesse campo. Se qualquer uma das regiões retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito de `region`, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito de `region`, mas for recuperado com êxito de `failoverRegion`, o ASCP montará o valor desse segredo. Para obter um exemplo de como usar esse campo, consulte [Failover multirregiões](#multi-region-failover).
**pathTranslation**
(Opcional) Um só caractere de substituição para usar se o nome de arquivo no Amazon EKS vá conter o caractere separador de caminho, como barra (/) no Linux. O ASCP não poderá criar um arquivo montado que contenha um caractere separador de caminho. Em vez disso, o ASCP substituirá o caractere separador de caminho por outro caractere. Se você não usar esse campo, o caractere substituto será um sublinhado (\$1), portanto, por exemplo,`My/Path/Secret` será montado como `My_Path_Secret`.
Para impedir a substituição de caracteres, digite a string`False`.
**usePodIdentity**
(Opcional) Determina a abordagem de autenticação. Quando não especificado, o padrão é Perfis do IAM para contas de serviço (IRSA).
+ Para usar a Identidade de Pods do EKS, use qualquer um destes valores: `"true"`, `"True"`, `"TRUE"`, `"t"` ou `"T"`.
+ Para usar explicitamente o IRSA, defina qualquer um destes valores: `"false"`, `"False"`, `"FALSE"`, `"f"` ou `"F"`"=.
**preferredAddressType**
(Opcional) Especifica o tipo de endereço IP preferencial para comunicação de endpoints do atendente da Identidade de Pods. O campo só será aplicável ao usar o recurso de Identidade de Pods do EKS, e será ignorado ao usar perfis do IAM para contas de serviço. Os valores não diferenciam maiúsculas de minúsculas. Os valores válidos são:
+ `"ipv4"`, `"IPv4"` “, ou `"IPV4"` — Forçar o uso do IPv4 endpoint do Pod Identity Agent
+ `"ipv6"`,`"IPv6"`, ou `"IPV6"` — Forçar o uso do IPv6 endpoint do Pod Identity Agent
+ não especificado — Use a seleção automática de endpoint, testando primeiro o IPv4 endpoint e retornando ao IPv6 endpoint se falhar IPv4
**objects**
Uma string contendo uma declaração do YAML dos segredos a serem montados. Recomendamos o uso de uma string com várias linhas ou um caractere pipe (\$1) no YAML.
**objectName**
Obrigatório. Especifica o nome do parâmetro ou segredo a ser buscado. Para o Secrets Manager, este é o parâmetro [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) e pode ser o nome amigável ou o ARN completo do segredo. Para o SSM Parameter Store, esse é o [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters) do parâmetro e pode ser o nome ou o ARN completo do parâmetro.
**objectType**
Necessário se você não usar um ARN do Secrets Manager para`objectName`. Pode ser `secretsmanager` ou `ssmparameter`.
**objectAlias**
(Opcional) O nome do arquivo do segredo no pod do Amazon EKS. Se você não especificar esse campo, o `objectName` aparece como o nome do arquivo.
**filePermission**
(Opcional) A string octal de 4 dígitos que especifica a permissão do arquivo para montar o segredo. Se você não especificar esse campo, ele será padronizado como `"0644"`.
**objectVersion**
(Opcional) O ID da versão do segredo. Não recomendado porque é necessário atualizar o ID da versão sempre que atualizar o segredo. Por padrão, a versão mais recente é usada. Se você incluir um `failoverRegion`, esse campo representará o `objectVersion` primário.
**objectVersionLabel**
(Opcional) O alias da versão. O padrão é a versão mais recente AWSCURRENT. Para obter mais informações, consulte [Versões do segredo](whats-in-a-secret.md#term_version). Se você incluir um `failoverRegion`, esse campo representará o `objectVersionLabel` primário.
**jmesPath**
(Opcional) Um mapa das chaves no segredo para os arquivos a serem montados no Amazon EKS. Para usar esse campo, o valor do segredo deve estar no formato JSON. Se você usar esse campo, deverá incluir os subcampos `path` e `objectAlias`.
**caminho**
Uma chave de um par de chave-valor no JSON do valor do segredo. Se o campo contiver um hífen, use aspas simples para delimitá-lo, por exemplo: `path: '"hyphenated-path"'`
**objectAlias**
O nome do arquivo a ser montado no pod Amazon EKS. Se o campo contiver um hífen, use aspas simples para delimitá-lo, por exemplo: `objectAlias: '"hyphenated-alias"'`
**filePermission**
(Opcional) A string octal de 4 dígitos que especifica a permissão do arquivo para montar o segredo. Se você não especificar esse campo, ele será padronizado como a permissão de arquivo do objeto pai.
**failoverObject**
(Opcional) Se você especificar esse campo, o ASCP tentará recuperar o segredo especificado no `objectName` primário e o segredo especificado no subcampo `objectName` de `failoverObject`. Se qualquer um deles retornar um erro 4xx (p. ex., para um problema de autenticação), o ASCP não montará nenhum segredo. Se o segredo for recuperado com êxito do `objectName` primário, o ASCP montará o valor desse segredo. Se o segredo não for recuperado com êxito do `objectName` primário, mas for recuperado com êxito do `objectName` do failover, o ASCP montará o valor desse segredo. Se incluir esse campo, será necessário incluir o campo `objectAlias`. Para obter um exemplo de como usar esse campo, consulte [Failover para um segredo diferente](#failover-secret).
Normalmente, você usa esse campo quando o segredo de failover não for uma réplica. Para obter um exemplo de como especificar uma réplica, consulte [Failover multirregiões](#multi-region-failover).
**objectName**
O nome ou ARN completo do segredo de failover. Se você usar um ARN, a região no ARN deverá corresponder ao campo `failoverRegion`.
**objectVersion**
(Opcional) O ID da versão do segredo. Deve corresponder ao `objectVersion` primário. Não recomendado porque é necessário atualizar o ID da versão sempre que atualizar o segredo. Por padrão, a versão mais recente é usada.
**objectVersionLabel**
(Opcional) O alias da versão. O padrão é a versão mais recente AWSCURRENT. Para obter mais informações, consulte [Versões do segredo](whats-in-a-secret.md#term_version).
### Crie uma SecretProviderClass configuração básica para montar segredos em seus pods do Amazon EKS.
------
#### [ Pod Identity ]
SecretProviderClass para usar um segredo no mesmo cluster do Amazon EKS:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets-manager
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
usePodIdentity: "true"
```
------
#### [ IRSA ]
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: deployment-aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "MySecret"
objectType: "secretsmanager"
```
------
### SecretProviderClass uso
Use esses exemplos para criar SecretProviderClass configurações para diferentes cenários.
#### Exemplo: montar segredos por nome ou ARN
Este exemplo mostra como montar três tipos diferentes de segredos:
+ Um segredo especificado por um ARN completo
+ Um segredo especificado pelo nome
+ Uma versão específica de um segredo
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6"
- objectName: "MySecret3"
objectType: "secretsmanager"
- objectName: "MySecret4"
objectType: "secretsmanager"
objectVersionLabel: "AWSCURRENT"
```
#### Exemplo: montar pares de chave-valor a partir de um segredo
Este exemplo mostra como montar pares de chave-valor específicos de um segredo formatado em JSON:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3"
jmesPath:
- path: username
objectAlias: dbusername
- path: password
objectAlias: dbpassword
```
#### Exemplo: montar segredos por permissão de arquivo
Este exemplo mostra como montar um segredo com uma permissão específica de arquivo
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
filePermission: "0600"
jmesPath:
- path: username
objectAlias: dbusername
filePermission: "0400"
```
#### Exemplo: exemplos de configuração de failover
Estes exemplos mostram como configurar o failover para segredos.
##### Failover multirregiões
Este exemplo mostra como configurar o failover automático para um segredo replicado em várias regiões:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "MySecret"
```
##### Failover para um segredo diferente
Este exemplo mostra como configurar o failover para um segredo diferente (não uma réplica):
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3"
objectAlias: "MyMountedSecret"
failoverObject:
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6"
```
## Recursos adicionais do
Para obter mais informações sobre o uso do ASCP com o Amazon EKS, consulte os seguintes recursos:
+ [Uso da Identidade de Pods com o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Usando AWS segredos e provedor de configuração](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Driver CSI da Secrets Store ativado GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Use AWS Secrets Manager segredos em AWS Lambda funções
AWS Lambda é um serviço de computação sem servidor que permite executar código sem provisionar ou gerenciar servidores. O Parameter Store, um recurso do AWS Systems Manager, fornece armazenamento seguro e hierárquico para gerenciamento de dados de configuração e gerenciamento de segredos. Você pode usar a extensão Lambda de AWS parâmetros e segredos para recuperar e armazenar em cache AWS Secrets Manager segredos e parâmetros do Parameter Store em funções do Lambda sem usar um SDK. Para obter informações detalhadas sobre o uso dessa extensão, consulte [Uso de segredos do Secrets Manager em funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) no *Guia do desenvolvedor do Lambda*.
## Uso de segredos do Secrets Manager com o Lambda
O Guia do desenvolvedor do Lambda fornece instruções abrangentes para usar os segredos do Secrets Manager em funções do Lambda. Para começar:
1. Siga o step-by-step tutorial em [Usar segredos do Secrets Manager nas funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), que inclui:
+ Criação de uma função do Lambda com seu runtime preferido (Python, Node.js, Java)
+ Adicionando a extensão Lambda de AWS parâmetros e segredos como uma camada
+ Configuração das permissões necessárias
+ Escrita de código para recuperação de segredos da extensão
+ Teste da sua função
1. Saiba mais sobre variáveis de ambiente para configuração do comportamento da extensão, incluindo configurações de cache e tempos limite
1. Práticas recomendadas para trabalho com alternância de segredos
### Uso do Secrets Manager e do Lambda em uma VPC
Se sua função do Lambda for executada em uma VPC, será necessário criar um endpoint da VPC para que a extensão possa fazer chamadas para o Secrets Manager. Para obter mais informações, consulte [Usando um AWS Secrets Manager VPC endpoint](vpc-endpoint-overview.md).
## Usando a extensão Lambda de AWS parâmetros e segredos
A extensão pode recuperar segredos do Secrets Manager e parâmetros do Parameter Store. Para obter informações detalhadas sobre o uso dos parâmetros do Parameter Store com a extensão, consulte [Uso de parâmetros do Parameter Store em funções do Lambda](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) no *Guia do usuário do AWS Systems Manager *.
A documentação do Systems Manager inclui:
+ Explicação detalhada de como a extensão funciona com o Parameter Store
+ Instruções para a adição da extensão a uma função do Lambda
+ Variáveis de ambiente para configuração da extensão
+ Comandos de exemplo para recuperação de parâmetros
+ Lista completa de extensões ARNs para todas as arquiteturas e regiões suportadas
# Usando o AWS Secrets Manager agente
## Como o Agente do Secrets Manager funciona
O AWS Secrets Manager Agent é um serviço HTTP do lado do cliente que ajuda você a padronizar como você consome segredos do Secrets Manager em seus ambientes computacionais. É possível usá-lo com serviços a seguir:
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
O Agente do Secrets Manager recupera e armazena segredos em cache na memória, permitindo que suas aplicações obtenham segredos do localhost em vez de fazer chamadas diretas para o Secrets Manager. O Agente do Secrets Manager só pode ler segredos, ele não pode modificá-los.
**Importante**
O Secrets Manager Agent usa as AWS credenciais do seu ambiente para chamar o Secrets Manager. Isso inclui proteção contra falsificação de solicitações do lado do servidor (SSRF) para ajudar a melhorar a segurança dos segredos. O Agente do Secrets Manager usa a troca de chaves pós-quântica ML-KEM como a troca de chaves de maior prioridade por padrão.
## Noções básicas sobre o armazenamento em cache do Agente do Secrets Manager
O Agente do Secrets Manager usa um cache em memória, ele é redefinido quando o Agente do Secrets Manager é reiniciado. Ele atualiza periodicamente os valores de segredos em cache com base no seguinte:
+ A frequência de atualização padrão (TTL) é de 300 segundos
+ É possível modificar o TTL usando um arquivo de configuração
+ A atualização ocorre quando você solicita um segredo após a expiração do TTL
**nota**
O Agente do Secrets Manager não inclui a invalidação do cache. Se um segredo for alternado antes que a entrada do cache expire, o Agente do Secrets Manager poderá retornar um valor de segredo obsoleto.
O Agente do Secrets Manager retorna valores de segredos no mesmo formato da resposta de `GetSecretValue`. Os valores de segredos não são criptografados no cache.
**Topics**
+ [Como o Agente do Secrets Manager funciona](#agent-overview)
+ [Noções básicas sobre o armazenamento em cache do Agente do Secrets Manager](#agent-caching)
+ [Criação do Agente do Secrets Manager](#secrets-manager-agent-build)
+ [Instalação do Agente do Secrets Manager](#secrets-manager-agent-install)
+ [Recuperação de segredos com o Agente do Secrets Manager](#secrets-manager-agent-call)
+ [Noções básicas sobre o parâmetro `refreshNow`](#secrets-manager-agent-refresh)
+ [Configurar o Agente do Secrets Manager](#secrets-manager-agent-config)
+ [Recursos opcionais](#secrets-manager-agent-features)
+ [Registro em log](#secrets-manager-agent-log)
+ [Considerações sobre segurança](#secrets-manager-agent-security)
## Criação do Agente do Secrets Manager
Antes de começar, verifique se você tem as ferramentas de desenvolvimento padrão e as ferramentas do Rust instaladas em sua plataforma.
**nota**
Atualmente, criar o agente com o recurso `fips` ativado no macOS requer a solução alternativa a seguir:
Crie uma variável de ambiente chamada `SDKROOT` que é definida como o resultado da execução de `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Para criar em sistemas baseados em RPM**
1. Use o script `install` fornecido no repositório.
O script gera um token SSRF aleatório no startup e o armazena no arquivo `/var/run/awssmatoken`. O token pode ser lido pelo grupo `awssmatokenreader` criado pelo script de instalação.
1. Para permitir que sua aplicação leia o arquivo de token, você precisa adicionar ao grupo `awssmatokenreader` a conta de usuário na qual sua aplicação é executada. Por exemplo, você pode conceder permissões para que seu aplicativo leia o arquivo de token com o seguinte comando usermod, onde ** está o ID do usuário sob o qual seu aplicativo é executado.
```
sudo usermod -aG awssmatokenreader
```
**Instalação das ferramentas de desenvolvimento**
Em sistemas baseados em RPM AL2023, como, instale o grupo Ferramentas de Desenvolvimento:
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Instalação do Rust**
Siga as instruções em [Instalação do Rust](https://www.rust-lang.org/tools/install) na *documentação do Rust*.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Criação do agente**
Crie o Agente do Secrets Manager usando o comando cargo build:
```
cargo build --release
```
Você encontrará o executável em `target/release/aws_secretsmanager_agent`.
------
#### [ Debian-based systems ]
**Para criar em sistemas baseados em Debian**
1.
**Instalação das ferramentas de desenvolvimento**
Em sistemas baseados no Debian, como o Ubuntu, instale o pacote build-essential.
```
sudo apt install build-essential
```
1.
**Instalação do Rust**
Siga as instruções em [Instalação do Rust](https://www.rust-lang.org/tools/install) na *documentação do Rust*.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Criação do agente**
Crie o Agente do Secrets Manager usando o comando cargo build:
```
cargo build --release
```
Você encontrará o executável em `target/release/aws_secretsmanager_agent`.
------
#### [ Windows ]
**Para criar no Windows**
1.
**Configuração do ambiente de desenvolvimento**
Siga as instruções em [Configuração do seu ambiente de desenvolvimento no Windows para Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) na *documentação do Microsoft Windows*.
1.
**Criação do agente**
Crie o Agente do Secrets Manager usando o comando cargo build:
```
cargo build --release
```
Você encontrará o executável em `target/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross-compile natively ]
**Para compilar de forma cruzada**
1.
**Instalação das ferramentas de compilação cruzada**
Em distribuições em que o pacote mingw-w64 está disponível, como o Ubuntu, instale o conjunto de ferramentas de compilação cruzada.
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Adição de destinos de criação do Rust**
Instale o destino de compilação do Windows GNU:
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Criação no Windows**
Faça a compilação cruzada do agente para Windows:
```
cargo build --release --target x86_64-pc-windows-gnu
```
Você encontrará o executável em `target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross compile with Rust cross ]
**Para fazer a compilação cruzada usando o Rust cross**
Se as ferramentas de compilação cruzada não estiverem disponíveis nativamente no sistema, será possível usar o projeto Rust cross. Para obter mais informações, consulte [https://github.com/cross-rs/cross](https://github.com/cross-rs/cross).
**Importante**
Recomendamos 32 GB de espaço em disco para o ambiente de compilação.
1.
**Configurar o Docker**
Instalação e configuração do Docker
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Configuração das permissões do Docker**
Adicione seuusuário ao grupo do docker:
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Criação no Windows**
Instale o cross e crie o executável:
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Instalação do Agente do Secrets Manager
Escolha seu ambiente de computação entre as opções de instalação a seguir.
------
#### [ Amazon EC2 ]
**Para instalar o Agente do Secrets Manager no Amazon EC2**
1.
**Navegação até o diretório de configurações**
Mude para o diretório de configurações:
```
cd aws_secretsmanager_agent/configuration
```
1.
**Execução do script de instalação**
Execute o script `install` fornecido no repositório.
O script gera um token SSRF aleatório no startup e o armazena no arquivo `/var/run/awssmatoken`. O token pode ser lido pelo grupo `awssmatokenreader` criado pelo script de instalação.
1.
**Configuração de permissões de aplicações**
Adicione a conta de usuário na qual sua aplicação é executada ao grupo `awssmatokenreader`:
```
sudo usermod -aG awssmatokenreader APP_USER
```
Substitua pelo ID de usuário *APP\$1USER* com o qual seu aplicativo é executado.
------
#### [ Container Sidecar ]
É possível executar o Agente do Secrets Manager como um contêiner auxiliar junto com sua aplicação usando o Docker. Então, sua aplicação pode recuperar segredos do servidor HTTP local fornecido pelo Agente do Secrets Manager. Para obter informações sobre o Docker, consulte a [documentação do Docker](https://docs.docker.com).
**Para criar um contêiner auxiliar para o Agente do Secrets Manager**
1.
**Criação do Dockerfile do agente**
Crie um Dockerfile para o contêiner auxiliar do Agente do Secrets Manager.
```
# Use the latest Debian image as the base
FROM debian:latest
# Set the working directory inside the container
WORKDIR /app
# Copy the Secrets Manager Agent binary to the container
COPY secrets-manager-agent .
# Install any necessary dependencies
RUN apt-get update && apt-get install -y ca-certificates
# Set the entry point to run the Secrets Manager Agent binary
ENTRYPOINT ["./secrets-manager-agent"]
```
1.
**Criação do Dockerfile da aplicação**
Crie um Dockerfile para sua aplicação cliente.
1.
**Criação do arquivo Docker Compose**
Crie um arquivo Docker Compose para executar ambos os contêineres com uma interface de rede compartilhada:
**Importante**
Você deve carregar AWS as credenciais e o token SSRF para que o aplicativo possa usar o Secrets Manager Agent. Para o Amazon EKS e o Amazon ECS, consulte:
[Gerenciamento de acesso](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) no *Guia do usuário do Amazon EKS*
[Perfil do IAM da tarefa do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) no *Guia do desenvolvedor do Amazon ECS*
```
version: '3'
services:
client-application:
container_name: client-application
build:
context: .
dockerfile: Dockerfile.client
command: tail -f /dev/null # Keep the container running
secrets-manager-agent:
container_name: secrets-manager-agent
build:
context: .
dockerfile: Dockerfile.agent
network_mode: "container:client-application" # Attach to the client-application container's network
depends_on:
- client-application
```
1.
**Cópia de binário do agente**
Copie o binário do `secrets-manager-agent` para o mesmo diretório que contém seus arquivos Dockerfile e Docker Compose.
1.
**Criação e execução dos contêineres**
Crie e execute os contêineres usando o Docker Compose:
```
docker-compose up --build
```
1.
**Próximas etapas**
Agora é possível usar o Agente do Secrets Manager para recuperar segredos do seu contêiner cliente. Para obter mais informações, consulte [Recuperação de segredos com o Agente do Secrets Manager](#secrets-manager-agent-call).
------
#### [ Lambda ]
É possível [empacotar o Agente do Secrets Manager como uma extensão do LAmbda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Em seguida, é possível [adicioná-lo à sua função do Lambda como uma camada](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) e chamar o Agente do Secrets Manager a partir da sua função da Lambda para obter segredos.
As instruções a seguir mostram como obter um nome secreto *MyTest*usando o script `secrets-manager-agent-extension.sh` de exemplo [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)para instalar o Secrets Manager Agent como uma extensão Lambda.
**Para criar uma extensão do Lambda para o Agente do Secrets Manager**
1.
**Empacotamento da camada do agente**
Na raiz do pacote de código do Agente do Secrets Manager, execute os comandos a seguir:
```
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID
LAMBDA_ARN=LAMBDA_ARN
# Build the release binary
cargo build --release --target=x86_64-unknown-linux-gnu
# Copy the release binary into the `bin` folder
mkdir -p ./bin
cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent
# Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder.
mkdir -p ./extensions
cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions
# Zip the extension shell script and the binary
zip secrets-manager-agent-extension.zip bin/* extensions/*
# Publish the layer version
LAYER_VERSION_ARN=$(aws lambda publish-layer-version \
--layer-name secrets-manager-agent-extension \
--zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn')
```
1.
**Configurar o token de SSRF**
A configuração padrão do agente definirá automaticamente o token SSRF com o valor definido nas variáveis predefinidas `AWS_SESSION_TOKEN` ou de `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente (a última variável para funções Lambda com habilitada). SnapStart Como alternativa, é possível definir a variável de ambiente `AWS_TOKEN` com um valor arbitrário para sua função do Lambda, pois essa variável tem precedência sobre as outras duas. Se você optar por usar a variável de ambiente `AWS_TOKEN`, deverá definir essa variável de ambiente com uma chamada a `lambda:UpdateFunctionConfiguration`.
1.
**Vinculação da camada à função**
Vincule a versão da camada à sua função do Lambda.
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Atualizar um código de função**
Atualize sua função do Lambda para fazer uma consulta a `http://localhost:2773/secretsmanager/get?secretId=MyTest` com o valor de cabeçalho `X-Aws-codes-Secrets-Token` definido como o valor do token de SSRF proveniente de uma das variáveis de ambiente mencionadas acima para recuperar o segredo. Certifique-se de implementar a lógica de repetição no código da aplicação para acomodar atrasos na inicialização e no registro da extensão do Lambda.
1.
**Testar a função**
Invoque a função do Lambda para verificar se o segredo está sendo buscado corretamente.
------
## Recuperação de segredos com o Agente do Secrets Manager
Para recuperar um segredo, chame o endpoint local do Agente do Secrets Manager e incluia o nome ou ARN do segredo como um parâmetro de consulta. Por padrão, o Agente do Secrets Manager recupera a versão `AWSCURRENT` do segredo. Para recuperar uma versão diferente, use o parâmetro versionStage ou versionId.
**Importante**
Para ajudar a proteger o Agente do Secrets Manager, é necessário incluir um cabeçalho de token SSRF como parte de cada solicitação: `X-Aws-Parameters-Secrets-Token`. O Agente do Secrets Manager nega solicitações que não tenham esse cabeçalho ou que tenham um token SSRF inválido. É possível personalizar o nome do cabeçalho SSRF em [Configurar o Agente do Secrets Manager](#secrets-manager-agent-config).
### Permissões obrigatórias
O Secrets Manager Agent usa o AWS SDK para Rust, que usa a cadeia de fornecedores de [AWS credenciais](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). A identidade dessas credenciais do IAM determina as permissões que o Agente do Secrets Manager tem para recuperar segredos.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obter mais informações sobre permissões, consulte [Referência de permissões para AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**Importante**
Depois que o valor do segredo é inserido no Agente do Secrets Manager, qualquer usuário com acesso ao ambiente computacional e ao token SSRF pode acessar o segredo a partir do cache do Agente do Secrets Manager. Para obter mais informações, consulte [Considerações sobre segurança](#secrets-manager-agent-security).
### Exemplo de solicitações
------
#### [ curl ]
**Example Exemplo: obtenção de um segredo usando curl**
O exemplo de curl a seguir mostra como obter um segredo do Agente do Secrets Manager. O exemplo depende da presença do SSRF em um arquivo, que é onde ele é armazenado pelo script de instalação.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Exemplo: obtenção de um segredo usando Python**
O exemplo de Python a seguir mostra como obter um segredo do Agente do Secrets Manager. O exemplo depende da presença do SSRF em um arquivo, que é onde ele é armazenado pelo script de instalação.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Noções básicas sobre o parâmetro `refreshNow`
O Agente do Secrets Manager usa um cache em memória para armazenar valores de segredos, que são atualizados periodicamente. Por padrão, essa atualização ocorre quando você solicita um segredo após a expiração da vida útil (TTL), normalmente a cada 300 segundos. No entanto, essa abordagem às vezes pode resultar em valores de segredo obsoletos, especialmente se um segredo for alternado antes que a entrada do cache expire.
Para resolver essa limitação, o Agente do Secrets Manager oferece suporte a um parâmetro chamado `refreshNow` na URL. Você pode usar esse parâmetro para forçar uma atualização imediata do valor de um segredo, ignorando o cache e garantindo que você tenha o máximo up-to-date de informações.
**Comportamento padrão (sem `refreshNow`)**
+ Usa valores em cache até que o TTL expire
+ Atualiza segredos somente após o TTL (padrão de 300 segundos)
+ Pode retornar valores obsoletos se os segredos forem alternados antes que o cache expire
**Comportamento com `refreshNow=true`**
+ Ignora completamente o cache
+ Recupera o valor do segredo mais recente diretamente do Secrets Manager
+ Atualiza o cache com o novo valor e redefine o TTL
+ Garante que você sempre obtenha o valor secreto mais atual
### Atualização forçada de um valor de segredo
**Importante**
O valor padrão de `refreshNow` é `false`. Quando definido como `true`, substitui o TTL especificado no arquivo de configuração do Agente do Secrets Manager e faz uma chamada de API para o Secrets Manager.
------
#### [ curl ]
**Example Exemplo: atualização forçada de um segredo usando curl**
O exemplo de curl a seguir mostra como forçar o Agente do Secrets Manager a atualizar o segredo. O exemplo depende da presença do SSRF em um arquivo, que é onde ele é armazenado pelo script de instalação.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\
echo
```
------
#### [ Python ]
**Example Exemplo: atualização forçada de um segredo usando Python**
O exemplo de Python a seguir mostra como obter um segredo do Agente do Secrets Manager. O exemplo depende da presença do SSRF em um arquivo, que é onde ele é armazenado pelo script de instalação.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Configurar o Agente do Secrets Manager
Para alterar a configuração do Agente do Secrets Manager, crie um arquivo de configuração [TOML](https://toml.io/en/) e, em seguida, chame `./aws_secretsmanager_agent --config config.toml`.Opções de configuração
**`log_level`**
O nível de detalhes relatado nos logs do Agente do Secrets Manager: DEBUG, INFO, WARN, ERROR ou NONE. O padrão é INFO.
**`log_to_file`**
Se deve enviar o log para um arquivo ou para stdout/stderr: `true` ou `false`. O padrão é `true`.
**`http_port`**
A porta do servidor de HTTP local, no intervalo de 1024 a 65535. O padrão é 2773.
**`region`**
A AWS região a ser usada para solicitações. Se nenhuma região for especificada, o Agente do Secrets Manager determinará a região a partir do SDK. Para obter mais informações, consulte [Especificação das suas credenciais e região padrão](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) no *Guia do desenvolvedor do SDK da AWS para Rust*.
**`ttl_seconds`**
O TTL, em segundos, para os itens em cache, no intervalo de 0 a 3600. O padrão é de 300. 0 indica que não há armazenamento em cache.
**`cache_size`**
O número máximo de segredos que podem ser armazenados no cache, no intervalo de 1 a 1000. O padrão é 1000.
**`ssrf_headers`**
Uma lista de nomes de cabeçalhos que o Agente do Secrets Manager verifica para o token de SSRF. O padrão é “X-Aws-Parameters-Secrets-Token,”. X-Vault-Token
**`ssrf_env_variables`**
Uma lista de nomes de variáveis de ambiente que o Agente do Secrets Manager verifica em ordem sequencial para o token de SSRF. A variável de ambiente pode conter o token ou uma referência ao arquivo de token, como em: `AWS_TOKEN=file:///var/run/awssmatoken`. O padrão é "AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN”.
**`path_prefix`**
O prefixo do URI usado para determinar se a solicitação é baseada em caminho. O padrão é "/v1/".
**`max_conn`**
O número máximo de conexões de clientes HTTP que o Agente do Secrets Manager permite, na faixa de 1 a 1000. O padrão é 800.
## Recursos opcionais
O Agente do Secrets Manager pode ser criado com recursos opcionais passando o sinalizador `--features` para `cargo build`. Os recursos disponíveis são:Recursos de compilação
**`prefer-post-quantum`**
Torna `X25519MLKEM768` o algoritmo de troca de chaves de maior prioridade. Caso contrário, ele está disponível, mas não é de maior prioridade. `X25519MLKEM768`é um algoritmo híbrido de troca de post-quantum-secure chaves.
**`fips`**
Restringe os conjuntos de cifras usados pelo agente somente a cifras aprovadas pelo FIPS.
## Registro em log
**Log local**
O Agente do Secrets Manager registra erros em log localmente no arquivo `logs/secrets_manager_agent.log` ou em stdout/stderr, dependendo da variável de configuração `log_to_file`. Quando sua aplicação chama o Agente do Secrets Manager para obter um segredo, essas chamadas aparecem no log local. Eles não aparecem nos CloudTrail registros.
**Alternância de logs**
O Agente do Secrets Manager e armazena até cinco arquivos de log no total e cria um novo arquivo de log quando o arquivo atinge 10 MB.
**AWS registro de serviços**
O registro não vai para o Secrets Manager, CloudTrail, ou CloudWatch. As solicitações para obter segredos do Agente do Secrets Manager não aparecem nesses logs. Quando o Secrets Manager Agent faz uma chamada para o Secrets Manager para obter um segredo, essa chamada é gravada CloudTrail com uma string de agente de usuário contendo`aws-secrets-manager-agent`.
É possível configurar as opções de log em [Configurar o Agente do Secrets Manager](#secrets-manager-agent-config).
## Considerações sobre segurança
**Domínio de confiança**
Para uma arquitetura de agente, o domínio de confiança é onde o endpoint do agente e o token SSRF estão acessíveis, o que geralmente é o host inteiro. O domínio de confiança do Agente do Secrets Manager deve corresponder ao domínio em que as credenciais do Secrets Manager estão disponíveis para manter a mesma postura de segurança. Por exemplo, no Amazon EC2, o domínio de confiança do Agente do Secrets Manager seria o mesmo que o domínio das credenciais ao usar funções para o Amazon EC2.
**Importante**
Aplicativos preocupados com a segurança que ainda não estão usando uma solução de agente com as credenciais do Secrets Manager bloqueadas no aplicativo devem considerar o uso de soluções específicas do idioma AWS SDKs ou de armazenamento em cache. Para obter mais informações, consulte [Obtenção de segredos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html).
# Obtenha um valor secreto do Secrets Manager usando o SDK para C\$1\$1 AWS
Para aplicativos C\$1\$1, chame o SDK diretamente com [GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)ou. [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue)
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
//! Retrieve an AWS Secrets Manager encrypted secret.
/*!
\param secretID: The ID for the secret.
\return bool: Function succeeded.
*/
bool AwsDoc::SecretsManager::getSecretValue(const Aws::String &secretID,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SecretsManager::SecretsManagerClient secretsManagerClient(clientConfiguration);
Aws::SecretsManager::Model::GetSecretValueRequest request;
request.SetSecretId(secretID);
Aws::SecretsManager::Model::GetSecretValueOutcome getSecretValueOutcome = secretsManagerClient.GetSecretValue(
request);
if (getSecretValueOutcome.IsSuccess()) {
std::cout << "Secret is: "
<< getSecretValueOutcome.GetResult().GetSecretString() << std::endl;
}
else {
std::cerr << "Failed with Error: " << getSecretValueOutcome.GetError()
<< std::endl;
}
return getSecretValueOutcome.IsSuccess();
}
```
# Obtenha um valor secreto do Secrets Manager usando o JavaScript AWS SDK
Para JavaScript aplicativos, chame o SDK diretamente com [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)ou [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property).
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
# Obtenha um valor secreto do Secrets Manager usando o Kotlin SDK AWS
Para aplicativos Kotlin, chame o SDK diretamente com ou. [GetSecretValue[BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
suspend fun getValue(secretName: String?) {
val valueRequest =
GetSecretValueRequest {
secretId = secretName
}
SecretsManagerClient.fromEnvironment { region = "us-east-1" }.use { secretsClient ->
val response = secretsClient.getSecretValue(valueRequest)
val secret = response.secretString
println("The secret value is $secret")
}
}
```
# Obtenha um valor secreto do Secrets Manager usando o AWS SDK do PHP
Para aplicações PHP, chame o SDK diretamente com [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue) ou [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue).
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
>/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
// Create a Secrets Manager Client
$client = new SecretsManagerClient([
'profile' => 'default',
'version' => '2017-10-17',
'region' => '<<{{MyRegionName}}>>',
]);
$secret_name = '<<{{MySecretName}}>>';
try {
$result = $client->getSecretValue([
'SecretId' => $secret_name,
]);
} catch (AwsException $e) {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
throw $e;
}
// Decrypts secret using the associated KMS key.
$secret = $result['SecretString'];
// Your code goes here
```
# Obtenha um valor secreto do Secrets Manager usando o SDK Ruby AWS
Para aplicações Ruby, chame o SDK diretamente com [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method) ou [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method).
O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
```
# Use this code snippet in your app.
# If you need more information about configurations or implementing the sample code, visit the AWS docs:
# https://aws.amazon.com/developer/language/ruby/
require 'aws-sdk-secretsmanager'
def get_secret
client = Aws::SecretsManager::Client.new(region: '<<{{MyRegionName}}>>')
begin
get_secret_value_response = client.get_secret_value(secret_id: '<<{{MySecretName}}>>')
rescue StandardError => e
# For a list of exceptions thrown, see
# https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
raise e
end
secret = get_secret_value_response.secret_string
# Your code goes here.
end
```
# Obtenha um valor secreto usando o AWS CLI
**Permissões obrigatórias: **`secretsmanager:GetSecretValue`
**Example Recuperar o valor secreto criptografado de um segredo**
O exemplo de [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) a seguir obtém o valor atual do segredo.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Recuperar o valor secreto anterior**
O exemplo de [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) a seguir recupera o valor secreto anterior.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Obtenha um grupo de segredos em um lote usando o AWS CLI
**Permissões obrigatórias: **
+ `secretsmanager:BatchGetSecretValue`
+ Permissão `secretsmanager:GetSecretValue` para cada segredo que deseja recuperar.
+ Se você usa filtros, também deve ter `secretsmanager:ListSecrets`.
Para um exemplo de política de permissões, consulte [Exemplo: permissão para recuperar um grupo de valores de segredos em um lote](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Importante**
Se você tiver uma política de VPCE que nega permissão para recuperar um segredo individual no grupo que você está recuperando, `BatchGetSecretValue` não retornará nenhum valor de segredo e retornará um erro.
**Example Recuperar o valor do segredo de um grupo de segredos listados por nome**
O exemplo de [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) a seguir obtém o valor do segredo para três segredos.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Recuperar o valor do segredo de um grupo de segredos selecionados pelo filtro**
O [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) de exemplo a seguir obtém o valor dos segredos que têm uma tag chamada “Test”.
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Obtenha um valor secreto usando o AWS console
**Para recuperar um segredo (console)**
1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Na lista de segredos, escolha o segredo que você deseja recuperar.
1. Na seção **Valor secreto**, selecione **Recuperar valor secreto**.
Secrets Manager exibe a versão atual (`AWSCURRENT`) do segredo. Para ver [outras versões](whats-in-a-secret.md#term_version) do segredo, como `AWSPREVIOUS` versões com rótulos personalizados, use o [Obtenha um valor secreto usando o AWS CLI](retrieving-secrets_cli.md).
# Use AWS Secrets Manager segredos em AWS Batch
AWS Batch ajuda você a executar cargas de trabalho de computação em lote no Nuvem AWS. Com AWS Batch, você pode injetar dados confidenciais em seus trabalhos armazenando seus dados confidenciais em AWS Secrets Manager segredos e, em seguida, referenciando-os na definição de seu trabalho. Para mais informações, consulte [Especificar dados sigilosos usando segredos do Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Obtenha um AWS Secrets Manager segredo em um CloudFormation recurso
Com CloudFormation isso, você pode recuperar um segredo para usar em outro CloudFormation recurso. Um cenário comum é primeiro criar um segredo com uma senha gerada pelo Secrets Manager e, em seguida, recuperar o nome de usuário e a senha do segredo para usar como credenciais para um novo banco de dados. Para obter informações sobre como criar segredos com CloudFormation, consulte[Crie AWS Secrets Manager segredos em AWS CloudFormation](cloudformation.md).
Para recuperar um segredo em um CloudFormation modelo, você usa uma *referência dinâmica*. Quando você cria a pilha, a referência dinâmica extrai o valor secreto para o CloudFormation recurso, para que você não precise codificar as informações secretas. Em vez disso, é necessário fazer referência ao segredo pelo nome ou ARN. É possível usar uma referência dinâmica para um segredo em qualquer propriedade do recurso. Você não pode usar uma referência dinâmica para um segredo em metadados do recurso, por exemplo, [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html), pois isso tornaria o valor do segredo visível no console.
Uma referência dinâmica para um segredo tem o seguinte padrão:
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**secret-id**
O nome ou ARN completo do segredo. Para acessar um segredo em sua AWS conta, você pode usar o nome secreto. Para acessar um segredo em uma AWS conta diferente, use o ARN do segredo.
**json-key** (opcional)
O nome da chave do par de chave-valor cujo valor você deseja recuperar. Se você não especificar um`json-key`, CloudFormation recuperará todo o texto secreto. Esse segmento não pode incluir o caractere de dois pontos (`:`).
**version-stage** (opcional)
A [versão](whats-in-a-secret.md#term_version) do segredo a ser usado. O Secrets Manager usa rótulos de preparação para acompanhar diferentes versões durante o processo de alternância. Se você usar `version-stage`, não especifique `version-id`. Se você não especificar `version-stage` ou `version-id`, o padrão é a versão `AWSCURRENT`. Esse segmento não pode incluir o caractere de dois pontos (`:`).
**version-id** (opcional)
O identificador exclusivo da versão do segredo a usar. Se você especificar `version-id`, não especifique `version-stage`. Se você não especificar `version-stage` ou `version-id`, o padrão é a versão `AWSCURRENT`. Esse segmento não pode incluir o caractere de dois pontos (`:`).
Para obter mais informações, consulte [Uso de referências dinâmicas para especificar segredos do Secrets Manager](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**nota**
Não crie uma referência dinâmica usando uma barra invertida `(\)` como valor final. CloudFormation não consigo resolver essas referências, o que causa uma falha no recurso.
# Use AWS Secrets Manager segredos em GitHub empregos
Para usar um segredo em um GitHub trabalho, você pode usar uma GitHub ação para recuperar segredos AWS Secrets Manager e adicioná-los como [variáveis de ambiente](https://docs.github.com/en/actions/learn-github-actions/environment-variables) mascaradas em seu GitHub fluxo de trabalho. Para obter mais informações sobre GitHub ações, consulte [Entendendo GitHub ações](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) nos *GitHub documentos.*
Quando você adiciona um segredo ao seu GitHub ambiente, ele fica disponível para todas as outras etapas do seu GitHub trabalho. Siga as orientações em [Fortalecimento de segurança para GitHub ações para ajudar a evitar que segredos em seu ambiente sejam usados indevidamente](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions).
É possível definir a cadeia de caracteres inteira no valor do segredo como o valor da variável de ambiente ou, caso a cadeia de caracteres seja JSON, pode analisar o JSON a fim de definir variáveis de ambiente individuais para cada par chave-valor JSON. Se o valor do segredo for um binário, a ação o converterá em uma cadeia de caracteres.
Para visualizar as variáveis de ambiente criadas utilizando seus segredos, ative o log de depuração. Para obter mais informações, consulte [Habilitando o registro de depuração](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) no *GitHub Docs*.
Para usar as variáveis de ambiente criadas a partir de seus segredos, consulte [Variáveis de ambiente](https://docs.github.com/en/actions/learn-github-actions/environment-variables) na *GitHub documentação.*
## Pré-requisitos
Para usar essa ação, primeiro você precisa configurar AWS as credenciais e defini-las Região da AWS em seu GitHub ambiente usando a `configure-aws-credentials` etapa. Siga as instruções em [Configurar ações de AWS credenciais para que GitHub as ações](https://github.com/aws-actions/configure-aws-credentials) **assumam a função diretamente usando o provedor GitHub OIDC**. Isso permite que você use credenciais de curta duração e evite armazenar chaves de acesso adicionais externas ao Secrets Manager.
O perfil do IAM que a ação assume deve ter as seguintes permissões:
+ `GetSecretValue` sobre os segredos que você deseja recuperar.
+ `ListSecrets` em todos os segredos.
+ (Opcional) `Decrypt` KMS key se os segredos estiverem criptografados com um chave gerenciada pelo cliente.
Para obter mais informações, consulte [Autenticação e controle de acesso para AWS Secrets Manager](auth-and-access.md).
## Usage
Para usar a ação, adicione uma etapa ao fluxo de trabalho que use a sintaxe a seguir.
```
- name: Step name
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
secretId1
ENV_VAR_NAME, secretId2
name-transformation: (Optional) uppercase|lowercase|none
parse-json-secrets: (Optional) true|false
```Parâmetros
`secret-ids`
ARNS, nomes e prefixos de nomes dos segredos.
Para definir o nome da variável de ambiente, insira-o antes do ID do segredo e acrescente uma vírgula. Por exemplo, o `ENV_VAR_1, secretId` cria uma variável de ambiente chamada **ENV\$1VAR\$11** utilizando o `secretId` do segredo. O nome da variável de ambiente pode consistir em letras maiúsculas, números e sublinhados.
Para usar um prefixo, digite pelo menos três caracteres seguidos de um asterisco. Por exemplo, `dev*` corresponde a todos os segredos com um nome que começa em **dev**. O número máximo de segredos correspondentes que podem ser recuperados é 100. Se você definir o nome da variável e o prefixo corresponder a diversos segredos, a ação falhará.
`name-transformation`
Por padrão, a etapa cria cada nome de variável de ambiente utilizando o nome do segredo, o qual é transformado para incluir apenas letras maiúsculas, números e sublinhados, bem como não começar com um número. Para as letras no nome, é possível configurar a etapa para usar letras minúsculas com `lowercase` ou não alterar as maiúsculas e minúsculas das letras com `none`. O valor padrão é `uppercase`.
`parse-json-secrets`
(Opcional) Por padrão, a ação define o valor da variável de ambiente para a cadeia de caracteres JSON inteira no valor do segredo. Defina `parse-json-secrets` como `true` para criar variáveis de ambiente para cada par chave-valor no JSON.
Observe que, se o JSON usar chaves que diferenciam maiúsculas de minúsculas, como “nome” e “Nome”, a ação apresentará conflitos de nomes duplicados. Nesse caso, defina os `parse-json-secrets` como `false` e analise o valor do segredo JSON separadamente.
## Nomeação de variáveis de ambiente
As variáveis de ambiente criadas pela ação são nomeadas da mesma forma que os segredos dos quais elas vêm. As variáveis de ambiente têm requisitos de nomenclatura mais rígidos do que os segredos, portanto, a ação transforma os nomes de segredos para atender a esses requisitos. Por exemplo, a ação transforma letras minúsculas em letras maiúsculas. Se você analisar o JSON do segredo, o nome da variável de ambiente incluirá tanto o nome do segredo quanto o nome da chave JSON, por exemplo, `MYSECRET_KEYNAME`. É possível configurar a ação para não transformar letras minúsculas.
Se duas variáveis de ambiente terminarem com o mesmo nome, a ação falhará. Nesse caso, você deverá especificar os nomes que deseja usar para as variáveis de ambiente como *aliases*.
Exemplos de quando os nomes podem entrar em conflito:
+ Um segredo chamado "MySecret" e um segredo chamado “mysecret” se tornariam variáveis de ambiente chamadas “MYSECRET”.
+ Um segredo chamado "secret\$1keyname" e um segredo analisado em JSON chamado "Secret" com uma chave chamada "keyname" se tornariam variáveis de ambiente chamadas "SECRET\$1KEYNAME".
É possível definir o nome da variável de ambiente especificando um *alias*, conforme mostrado no exemplo a seguir, que cria uma variável chamada `ENV_VAR_NAME`.
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Aliases em branco**
+ Se você definir `parse-json-secrets: true` e inserir um alias em branco, seguido por uma vírgula e depois pelo ID do segredo, a ação nomeará a variável de ambiente da mesma forma que as chaves JSON analisadas. Os nomes das variáveis não incluem o nome do segredo.
Se o segredo não contiver um JSON válido, a ação criará uma variável de ambiente e a nomeará da mesma forma que o nome do segredo.
+ Se você definir `parse-json-secrets: false` e inserir um alias em branco, seguido por uma vírgula e depois pelo ID do segredo, a ação nomeará as variáveis de ambiente como se você não especificasse um alias.
Veja a seguir um exemplo de um alias em branco.
```
,secret2
```
## Exemplos
**Example 1. Obtenha segredos por nome e por ARN**
O exemplo a seguir cria variáveis de ambiente para segredos identificados por nome e por ARN.
```
- name: Get secrets by name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
exampleSecretName
arn:aws:secretsmanager:us-east-2:123456789012:secret:test1-a1b2c3
0/test/secret
/prod/example/secret
SECRET_ALIAS_1,test/secret
SECRET_ALIAS_2,arn:aws:secretsmanager:us-east-2:123456789012:secret:test2-a1b2c3
,secret2
```
Variáveis de ambiente criadas:
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2. Obtenha todos os segredos que começam com determinado prefixo**
O exemplo a seguir cria variáveis de ambiente para todos os segredos com nomes que começam com*beta*.
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Variáveis de ambiente criadas:
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3. Análise do JSON no segredo**
O exemplo a seguir cria variáveis de ambiente ao analisar o JSON no segredo.
```
- name: Get Secrets by Name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
test/secret
,secret2
parse-json-secrets: true
```
O segredo `test/secret` tem o seguinte valor de segredo.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
O segredo `secret2` tem o seguinte valor de segredo.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Variáveis de ambiente criadas:
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 Use letras minúsculas para nomes de variáveis de ambiente**
O exemplo a seguir cria uma variável de ambiente com um nome em minúsculas.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Variável de ambiente criada:
```
examplesecretname: secretValue
```
# Use AWS Secrets Manager em GitLab
AWS Secrets Manager se integra com GitLab. Você pode aproveitar os segredos do Secrets Manager para proteger suas GitLab credenciais para que elas não sejam mais codificadas. GitLab Em vez disso, o [GitLab Runner](https://docs.gitlab.com/runner/) recupera esses segredos do Secrets Manager quando seu aplicativo executa um trabalho nos pipelines de GitLab CI/CD.
Para usar essa integração, você criará um [provedor de identidade OpenID Connect (OIDC) no IAM AWS Identity and Access Management e uma função do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html). Isso permite que o GitLab Runner acesse seu segredo do Secrets Manager. [Para obter mais informações sobre GitLab CI/CD e OIDC, consulte a documentação. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Considerações
Se você estiver usando uma GitLab instância não pública, não poderá usar essa integração com o Secrets Manager. Em vez disso, consulte a [GitLab documentação de instâncias não públicas](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Pré-requisitos
Para integrar o Secrets Manager com GitLab, preencha os seguintes pré-requisitos:
1.
**Crie um AWS Secrets Manager segredo**
Você precisará de um segredo do Secrets Manager que será recuperado em seu GitLab trabalho e eliminará a necessidade de codificar essas credenciais. Você precisará do ID secreto do Secrets Manager ao [configurar seu GitLab pipeline](#configure-gitlab-pipeline). Consulte [Crie um AWS Secrets Manager segredo](create_secret.md) para obter mais informações.
1.
**Crie GitLab seu provedor OIDC no console do IAM.**
Nesta etapa, você criará GitLab seu provedor OIDC no console do IAM. [Para obter mais informações, consulte [Criar um provedor de identidade e documentação do OpenID Connect (OIDC)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html). GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Ao criar o provedor OIDC no console do IAM, use as configurações a seguir:
1. Defina o `provider URL` para sua GitLab instância. Por exemplo, .**gitlab.example.com**
1. Configure `audience` ou `aud` como **sts.amazonaws.com**.
1.
**Criar uma política e um perfil do IAM**
Será necessário criar uma política e um perfil do IAM. Essa função é assumida por GitLab with [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). Para obter mais informações, consulte [Criação de um perfil usando políticas de confiança personalizadas](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html).
1. No console do IAM, use as configurações a seguir ao criar o perfil do IAM:
+ Defina `Trusted entity type` como **Web identity**.
+ Defina `Group` como **your GitLab group**.
+ `Identity provider`Defina com o mesmo URL do provedor (a [GitLab instância](#step2-oidc-provider)) que você usou na etapa 2.
+ Defina `Audience` como o mesmo [público](#step2-oidc-audience) que você usou na etapa 2.
1. Veja a seguir um exemplo de uma política de confiança que GitLab permite assumir funções. Sua política de confiança deve listar seu Conta da AWS GitLab URL e o [caminho do projeto](https://docs.gitlab.com/user/project/).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRoleWithWebIdentity",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/gitlab.example.com"
},
"Condition": {
"StringEquals": {
"gitlab.example.com:aud": [
"sts.amazon.com"
]
},
"StringLike": {
"gitlab.example.com:sub": [
"project_path:mygroup/project-*:ref_type:branch-*:ref:main*"
]
}
}
}
]
}
```
1. Você também precisará criar uma política do IAM para permitir o GitLab acesso AWS Secrets Manager a. É possível adicionar essa política à sua política de confiança. Para obter mais informações, consulte [Criação de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:your-secret"
}
]
}
```
## Integrando com AWS Secrets Manager GitLab
Depois de concluir os pré-requisitos, você pode configurar GitLab para usar o Secrets Manager para proteger suas credenciais.
### Configurar o GitLab pipeline para usar o Secrets Manager
Você precisará atualizar seu [arquivo de configuração de GitLab CI/CD](https://docs.gitlab.com/ci/yaml/yaml_optimization/) com as seguintes informações:
+ O público do token definido como STS.
+ O ID do segredo do Secrets Manager.
+ A função do IAM que você deseja que o GitLab Runner assuma ao executar trabalhos no GitLab pipeline.
+ O Região da AWS local onde o segredo está armazenado.
GitLab busca o segredo do Secrets Manager e armazena o valor em um arquivo temporário. O caminho para esse arquivo é armazenado em uma CI/CD variável, semelhante às variáveis [CI/CD do tipo de arquivo](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
Veja a seguir um trecho do arquivo YAML para um arquivo de configuração GitLab CI/CD:
```
variables:
AWS_REGION: us-east-1
AWS_ROLE_ARN: 'arn:aws:iam::111122223333:role/gitlab-role'
job:
id_tokens:
AWS_ID_TOKEN:
aud: 'sts.amazonaws.com'
secrets:
DATABASE_PASSWORD:
aws_secrets_manager:
secret_id: "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
```
Para obter mais informações, consulte a [documentação de integração do GitLab Secrets Manager](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Opcionalmente, você pode testar sua configuração do OIDC em. GitLab Consulte a [GitLab documentação para testar a configuração do OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration) para obter mais informações.
## Solução de problemas
O seguinte pode ajudá-lo a solucionar problemas comuns que você pode encontrar ao integrar o Secrets Manager com o. GitLab
### GitLab Problemas de tubulação
Se você tiver problemas no GitLab pipeline, verifique o seguinte:
+ Seu arquivo YAML está formatado corretamente. Para obter mais informações, consulte a [documentação da GitLab](https://docs.gitlab.com/ee/ci/yaml/).
+ Seu GitLab funil está assumindo a função correta, tem as permissões apropriadas e acesso ao AWS Secrets Manager segredo correto.
### Recursos adicionais do
Os recursos a seguir podem ajudá-lo a solucionar problemas com GitLab e AWS Secrets Manager:
+ [GitLab Solução de problemas do OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [ GitLab Depurando o pipeline de CI/CD](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Solução de problemas](ascp-eks-installation.md#troubleshooting)
# Use AWS Secrets Manager segredos em AWS IoT Greengrass
AWS IoT Greengrass é um software que estende os recursos da nuvem para dispositivos locais. Isso permite que os dispositivos coletem e analisem dados mais próximos da fonte de informações, reajam de maneira autônoma a eventos locais e se comuniquem com segurança uns com os outros em redes locais.
AWS IoT Greengrass permite que você se autentique com serviços e aplicativos de AWS IoT Greengrass dispositivos sem codificar senhas, tokens ou outros segredos. Você pode usar AWS Secrets Manager para armazenar e gerenciar com segurança seus segredos na nuvem. AWS IoT Greengrass estende o Secrets Manager aos dispositivos AWS IoT Greengrass principais, para que seus conectores e funções Lambda possam usar segredos locais para interagir com serviços e aplicativos.
Para integrar um segredo em um AWS IoT Greengrass grupo, você cria um recurso de grupo que faz referência ao segredo do Secrets Manager. Esse recurso de segredo faz referência ao segredo da nuvem usando o ARN associado. Para saber como criar, gerenciar e usar recursos secretos, consulte Como [trabalhar com recursos secretos](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) no Guia do AWS IoT desenvolvedor.
Para implantar segredos no AWS IoT Greengrass núcleo, consulte [Implantar segredos no AWS IoT Greengrass núcleo.](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# Use AWS Secrets Manager segredos no Parameter Store
AWS O Systems Manager Parameter Store fornece armazenamento seguro e hierárquico para gerenciamento de dados de configuração e gerenciamento de segredos. Você pode armazenar dados, como senhas, strings de banco de dados e códigos de licença como valores de parâmetro. No entanto, o repositório de parâmetros não fornece serviços de rotação automática para os segredos armazenados. Em vez disso, o Parameter Store permite que você armazene o segredo no Secrets Manager e faça referência ao segredo como um parâmetro do Parameter Store.
Quando você configura o Parameter Store com o Secrets Manager, o Parameter Store do `secret-id` requer uma barra (/) antes da string do nome.
Para obter mais informações, consulte Como [referenciar AWS Secrets Manager segredos dos parâmetros do Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html) no *Guia do AWS Systems Manager usuário*.