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á.
# 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.goskope.com.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.goskope.com.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);
}
}
}
```