Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Obtener un valor secreto de Secrets Manager con Java
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
Para conectarse a una base de datos mediante las credenciales de un secreto, puede utilizar los controladores de conexión SQL de Secrets Manager, que incluyen el controlador JDBC básico. Esto también utiliza el almacenamiento en caché del lado del cliente, por lo que puede reducir el costo de llamar a Secrets Manager. APIs
**Topics**
+ [
# Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente
](retrieving-secrets_cache-java.md)
+ [
# Conéctese a una base de datos SQL mediante JDBC con las credenciales en secreto AWS Secrets Manager
](retrieving-secrets_jdbc.md)
+ [
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Java
](retrieving-secrets-java-sdk.md)
# Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Java de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-java-ref_SecretCacheHook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ Un entorno de desarrollo Java 8 o una versión posterior. Consulte las [descargas de Java SE](https://www.oracle.com/technetwork/java/javase/downloads/index.html) en el sitio web de Oracle.
Para descargar el código fuente, consulte el componente de [cliente de almacenamiento en caché basado en Java de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-java) en. GitHub
En el archivo pom.xml de Maven, incluya la siguiente dependencia para agregar el componente a su proyecto. Para obtener más información sobre Maven, consulte [Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html) en el sitio web del proyecto de Apache Maven.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](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 Recuperación de un secreto**
En el siguiente ejemplo de código se muestra una función de Lambda que recupera una cadena del secreto. Sigue la [práctica recomendada](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) que consiste en crear una instancia de la memoria caché fuera del controlador de la función, para que no siga llamando a la API en caso de que se vuelva a invocar la función de Lambda.
```
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
Una caché en memoria para los secretos solicitados a Secrets Manager. Utilice [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) o [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) para recuperar un secreto de la caché. Puede configurar los ajustes de la memoria caché si transfiere un objeto [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) en el constructor.
Para obtener más información, incluidos algunos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante Java con almacenamiento en caché del cliente](retrieving-secrets_cache-java.md).
## Constructores
`public SecretCache()`
Constructor predeterminado de un objeto `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Construye una nueva memoria caché con un cliente de Secrets Manager creado a partir del [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) proporcionado. Utilice este constructor para personalizar el cliente de Secrets Manager, por ejemplo, para utilizar una región o un punto de conexión específicos.
`public SecretCache(AWSSecretsManager client)`
Construye una nueva memoria caché del secreto mediante el [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) proporcionado. Utilice este constructor para personalizar el cliente de Secrets Manager, por ejemplo, para utilizar una región o un punto de conexión específicos.
`public SecretCache(SecretCacheConfiguration config)`
Construye una nueva memoria caché del secreto mediante el `SecretCacheConfiguration` proporcionado.
## Métodos
### getSecretString
`public String getSecretString(final String secretId)`
Recupera un secreto de cadena de Secrets Manager. Devuelve [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 un secreto en formato binario desde Secrets Manager. Devuelve [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`
Obliga a la memoria caché a actualizarse. Devuelve `true` si la actualización se completa sin errores, en caso contrario, devuelve `false`.
### close
`public void close()`
Cierra la caché.
# SecretCacheConfiguration
Opciones de configuración de la caché para un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), como el tamaño máximo de esta y el periodo de vida (TTL) de los secretos almacenados en ella.
## Constructor
`public SecretCacheConfiguration`
Constructor predeterminado de un objeto `SecretCacheConfiguration`.
## Métodos
### getClient
`public AWSSecretsManager getClient()`
Devuelve el [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) desde el cual la memoria caché recupera los secretos.
### setClient
`public void setClient(AWSSecretsManager client)`
Establece el [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) desde el cual la memoria caché recupera los secretos.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Devuelve la interfaz [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizada para conectar las actualizaciones de la caché.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Establece la interfaz [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizada para conectar las actualizaciones de la caché.
### getMaxCacheTamaño
`public int getMaxCacheSize()`
Devuelve el tamaño máximo de la caché. El valor predeterminado es de 1024 secretos.
### setMaxCacheTamaño
`public void setMaxCacheSize(int maxCacheSize)`
Establece el tamaño máximo de la caché. El valor predeterminado es de 1024 secretos.
### getCacheItemTTL
`public long getCacheItemTTL()`
Devuelve el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [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). El valor predeterminado es de 1 hora en milisegundos.
La caché actualiza el secreto de forma sincrónica en el momento en que se solicita el secreto después del TTL. Si se produce un error en la actualización sincrónica, la caché devuelve el secreto obsoleto.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Establece el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [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). El valor predeterminado es de 1 hora en milisegundos.
### getVersionStage
`public String getVersionStage()`
Devuelve la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Establece la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es `"AWSCURRENT"`.
### SecretCacheConfiguration Con el cliente
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Establece el [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) desde el cual se recuperan los secretos. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Establece la interfaz utilizada para conectarse a la caché en memoria. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withMaxCacheTamaño
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Establece el tamaño máximo de la caché. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Establece el TTL en milisegundos de los elementos almacenados en la caché. Si un secreto almacenado en la caché supera este TTL, la caché recupera una nueva copia del secreto del [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). El valor predeterminado es de 1 hora en milisegundos. Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Establece la versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). Devuelve el objeto `SecretCacheConfiguration` actualizado con la nueva configuración.
# SecretCacheHook
Una interfaz para conectarse a una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) y realizar acciones sobre los secretos almacenados en ella.
## put
`Object put(final Object o)`
Prepara el objeto para almacenarlo en la caché.
Devuelve el objeto que se almacenará en la caché.
## introducción
`Object get(final Object cachedObject)`
Deriva el objeto a partir del objeto almacenado en caché.
Devuelve el objeto que se devolverá de la caché
# Conéctese a una base de datos SQL mediante JDBC con las credenciales en secreto AWS Secrets Manager
En las aplicaciones Java, puede utilizar los controladores de conexión SQL de Secrets Manager para conectarse a bases de datos MySQL, PostgreSQL, Oracle MSSQLServer, Db2 y Redshift mediante las credenciales almacenadas en Secrets Manager. Cada controlador integra el controlador JDBC base, de modo que puede utilizar las llamadas JDBC para obtener acceso a su base de datos. Sin embargo, en lugar de indicar un nombre de usuario y una contraseña para conectarse, se proporciona el ID de un secreto. El controlador llama a Secrets Manager para recuperar el valor del secreto y, a continuación, utiliza las credenciales y la información de conexión que contiene el secreto para conectarse a la base de datos. El controlador también almacena en caché las credenciales mediante la [biblioteca de almacenamiento en caché del lado del cliente de Java](retrieving-secrets_cache-java.md), por lo que no es necesario llamar a Secrets Manager en futuras conexiones. La caché actualiza por defecto los secretos cada hora y también cuando se rota uno de ellos. Para configurar la caché, consulte [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Puede descargar el código fuente en [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Para utilizar los controladores de conexión SQL de Secrets Manager:
+ Su aplicación debe tener Java 8 o una versión posterior.
+ El secreto debe ser uno de los siguientes:
+ Un [secreto de base de datos con la estructura JSON esperada](reference_secret_json_structure.md). Para comprobar el formato, en la consola de Secrets Manager, consulte su secreto y, a continuación, seleccione **Retrieve secret value** (Recuperar valor del secreto). O bien, en la llamada. AWS CLI[get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)
+ Un [secreto administrado](integrating_how-services-use-secrets_RDS.md) de Amazon RDS. Para este tipo de secreto, debe especificar un punto de conexión y un puerto al establecer la conexión.
+ Un [secreto administrado](integrating_how-services-use-secrets_RS.md) de Amazon Redshift. Para este tipo de secreto, debe especificar un punto de conexión y un puerto al establecer la conexión.
Si la base de datos se replica en otras regiones, para conectarse a una base de datos de réplica de otra región, especifique el punto de conexión y el puerto regionales al crear la conexión. Puede almacenar la información de conexión regional en el secreto como key/value pares adicionales, en los parámetros del SSM Parameter Store o en la configuración de su código.
Para agregar el controlador al proyecto, en el archivo de compilación de Maven `pom.xml`, agregue la siguiente dependencia del controlador. Para obtener más información, consulte [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) en el sitio web del repositorio central de Maven.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
El controlador utiliza la [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). Si ejecuta el controlador en Amazon EKS, es posible que recoja las credenciales del nodo en el que se ejecuta en lugar del rol de la cuenta de servicio. Para solucionar este problema, agregue la versión 1 de `com.amazonaws:aws-java-sdk-sts` a su archivo de proyecto de Gradle o Maven como una dependencia.
Para configurar una URL de punto final de AWS PrivateLink DNS y una región en el `secretsmanager.properties` archivo:
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Para anular la región principal, defina la variable del entorno `AWS_SECRET_JDBC_REGION` o realice el siguiente cambio en el archivo `secretsmanager.properties`:
```
drivers.region = region
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [
## Establecer una conexión a una base de datos
](#retrieving-secrets_jdbc_example)
+ [
## Establecer una conexión especificando el punto de conexión y el puerto
](#retrieving-secrets_jdbc_example_replica)
+ [
## Uso de la agrupación de conexiones c3p0 para establecer una conexión
](#retrieving-secrets_jdbc_example_c3po)
+ [
## Uso de la agrupación de conexiones c3p0 para establecer una conexión especificando el punto de conexión y el puerto
](#retrieving-secrets_jdbc_example_c3p0_replica)
## Establecer una conexión a una base de datos
En el siguiente ejemplo se muestra cómo establecer una conexión con una base de datos con las credenciales e información de conexión de un secreto. Una vez que tenga la conexión, puede utilizar las llamadas JDBC para obtener acceso a la base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación 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);
```
------
## Establecer una conexión especificando el punto de conexión y el puerto
En el siguiente ejemplo se muestra cómo establecer una conexión con una base de datos mediante las credenciales de un secreto con el punto de conexión y puerto que se especifique.
Los [secretos administrados de Amazon RDS](integrating_how-services-use-secrets_RDS.md) no incluyen el punto de conexión ni el puerto de la base de datos. Para conectarse a una base de datos mediante las credenciales maestras de un secreto administrado de Amazon RDS, hay que especificarlas en el código.
Los [secretos que se replican en otras regiones](replicate-secrets.md) pueden mejorar la latencia de la conexión a la base de datos regional, pero no contienen información de conexión distinta del secreto de origen. Cada réplica es una copia del secreto de origen. Para almacenar la información de conexión regional en el secreto, añada más key/value pares para el punto final y la información del puerto para las regiones.
Una vez que tenga la conexión, puede utilizar las llamadas JDBC para obtener acceso a la base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación 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);
```
------
## Uso de la agrupación de conexiones c3p0 para establecer una conexión
En el siguiente ejemplo se muestra cómo establecer un grupo de conexiones con un archivo `c3p0.properties` que utiliza el controlador para recuperar las credenciales y la información de conexión del secreto. Para `user` y `jdbcUrl`, ingrese el ID del secreto y configure el grupo de conexiones. A continuación, puede recuperar las conexiones del grupo y utilizarlas como cualquier otra conexión de base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
Para obtener más información sobre c3p0, consulte [c3p0](https://www.mchange.com/projects/c3p0/) en el sitio web 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
```
------
## Uso de la agrupación de conexiones c3p0 para establecer una conexión especificando el punto de conexión y el puerto
En el siguiente ejemplo, se muestra cómo establecer un grupo de conexiones con un archivo `c3p0.properties` que utiliza el controlador para recuperar las credenciales de un secreto con el punto de conexión y puerto que se especifique. A continuación, puede recuperar las conexiones del grupo y utilizarlas como cualquier otra conexión de base de datos. Para obtener más información, consulte [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) en el sitio web de documentación de Java.
Los [secretos administrados de Amazon RDS](integrating_how-services-use-secrets_RDS.md) no incluyen el punto de conexión ni el puerto de la base de datos. Para conectarse a una base de datos mediante las credenciales maestras de un secreto administrado de Amazon RDS, hay que especificarlas en el código.
Los [secretos que se replican en otras regiones](replicate-secrets.md) pueden mejorar la latencia de la conexión a la base de datos regional, pero no contienen información de conexión distinta del secreto de origen. Cada réplica es una copia del secreto de origen. Para almacenar la información de conexión regional en el secreto, añada más key/value pares para el punto final y la información del puerto para las regiones.
------
#### [ 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
```
------
# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Java
En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de los AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.
+ Si almacena las credenciales de la base de datos en el secreto, utilice los [controladores de conexión SQL de Secrets Manager](retrieving-secrets_jdbc.md) para conectarse a una base de datos mediante esas credenciales.
+ Para otros tipos de secretos, utilice el [componente de almacenamiento en caché basado en Java de Secrets Manager](retrieving-secrets_cache-java.md) o llame al SDK directamente con [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) o [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).
Los siguientes ejemplos de código muestran cómo utilizar `GetSecretValue`.
**Permisos necesarios: **`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);
}
}
}
```