Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Obtenir une valeur secrète de Secrets Manager à l'aide de Java
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour vous connecter à une base de données à l'aide des informations d'identification contenues dans un code secret, vous pouvez utiliser les pilotes de connexion SQL Secrets Manager, qui encapsulent le pilote JDBC de base. Cela utilise également la mise en cache côté client, ce qui permet de réduire le coût d'appel de Secrets Manager. APIs
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client](retrieving-secrets_cache-java.md)
+ [Connectez-vous à une base de données SQL à l'aide de JDBC avec des informations d'identification enregistrées dans un secret AWS Secrets Manager](retrieving-secrets_jdbc.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Java](retrieving-secrets-java-sdk.md)
# Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Java de Secrets Manager pour le mettre en cache en vue d'une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut vous permettre de réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique de cache est la moins récemment utilisée (LRU). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le moins récemment utilisé. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer [la fréquence d'actualisation du secret](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) dans le cache et [utiliser un hook pour la récupération du secret](retrieving-secrets_cache-java-ref_SecretCacheHook.md) afin d’ajouter plus de fonctionnalités.
Le cache ne force pas le récupérateur de mémoire une fois que les références du cache sont libérées. L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement d'éléments dans le cache, utilisez les interfaces et les méthodes abstraites fournies.
Pour pouvoir utiliser le composant, vous devez disposer des éléments suivants :
+ Environnement de développement Java 8 ou une version ultérieure. Consultez [Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) sur le site web d'Oracle.
Pour télécharger le code source, consultez le [composant client de mise en cache basé sur Java de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-java) sur. GitHub
Pour ajouter le composant à votre projet, dans votre fichier Maven pom.xml, intégrez la dépendance suivante. Pour plus d'informations sur Maven, consultez le [Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html) sur le site web Apache Maven Project.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](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 Récupérer un secret**
L'exemple de code suivant montre une fonction Lambda qui récupère une chaîne de secret. Il respecte les [bonnes pratiques](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) consistant à instancier le cache en dehors du gestionnaire de fonctions, de sorte qu'il ne continue pas d'appeler l'API si vous appelez à nouveau la fonction 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
Un cache en mémoire pour les secrets demandés à Secrets Manager. Vous utilisez [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) ou [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) pour récupérer un secret du cache. Vous pouvez configurer les paramètres de cache en transmettant un objet [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) dans le constructeur.
Pour plus d'informations, ainsi que pour voir des exemples, consultez [Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client](retrieving-secrets_cache-java.md).
## Constructeurs
`public SecretCache()`
Constructeur par défaut d'un objet `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Crée un cache à l'aide d'un client Secrets Manager créé à l'aide du [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) fourni. Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple pour utiliser une région ou un point de terminaison spécifique.
`public SecretCache(AWSSecretsManager client)`
Crée un cache de secret à l'aide du [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) fourni. Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple pour utiliser une région ou un point de terminaison spécifique.
`public SecretCache(SecretCacheConfiguration config)`
Crée un cache de secret à l'aide du `SecretCacheConfiguration` fourni.
## Méthodes
### getSecretString
`public String getSecretString(final String secretId)`
Récupère un secret de chaîne dans Secrets Manager. Retourne un [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)`
Récupère un secret binaire dans Secrets Manager. Retourne un [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`
Force l'actualisation du cache. Renvoie `true` si l'actualisation s'est terminée sans erreur, sinon `false`.
### close
`public void close()`
Ferme le cache.
# SecretCacheConfiguration
Options de configuration du cache pour un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), telles que la taille maximale du cache et la durée de vie (TTL) pour les secrets mis en cache.
## Constructeur
`public SecretCacheConfiguration`
Constructeur par défaut d'un objet `SecretCacheConfiguration`.
## Méthodes
### getClient
`public AWSSecretsManager getClient()`
Renvoie le [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) dont le cache récupère les secrets.
### setClient
`public void setClient(AWSSecretsManager client)`
Définit le client [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) à partir desquels le cache récupère des secrets.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Renvoie l'interface [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilisée pour raccorder les mises à jour du cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Définit l'interface [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilisée pour raccorder les mises à jour du cache.
### getMaxCacheTaille
`public int getMaxCacheSize()`
Renvoie la taille maximale du cache. La valeur par défaut est de 1 024 secrets.
### setMaxCacheTaille
`public void setMaxCacheSize(int maxCacheSize)`
Définit la taille maximale du cache. La valeur par défaut est de 1 024 secrets.
### getCacheItemTTL
`public long getCacheItemTTL()`
Renvoie la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes.
Le cache actualise le secret de manière synchrone lorsque le secret est demandé après la durée de vie. Si l'actualisation synchrone échoue, le cache renvoie le secret obsolète.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Définit la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes.
### getVersionStage
`public String getVersionStage()`
Renvoie la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Définit la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est `"AWSCURRENT"`.
### SecretCacheConfiguration Avec le client
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Définit le [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) pour en récupérer des secrets. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Définit l'interface utilisée pour raccorder le cache en mémoire. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withMaxCacheTaille
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Définit la taille maximale du cache. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Définit la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Définit la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
# SecretCacheHook
Une interface pour se connecter à un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) pour effectuer des actions sur les secrets stockés dans le cache.
## put
`Object put(final Object o)`
Préparez l'objet en vue de son stockage dans le cache.
Renvoie l'objet à stocker dans le cache.
## get
`Object get(final Object cachedObject)`
Dérivez l'objet de l'objet mis en cache.
Renvoie l'objet à renvoyer à partir du cache
# Connectez-vous à une base de données SQL à l'aide de JDBC avec des informations d'identification enregistrées dans un secret AWS Secrets Manager
Dans les applications Java, vous pouvez utiliser les pilotes de connexion SQL Secrets Manager pour vous connecter aux bases de données MySQL, PostgreSQL, Oracle MSSQLServer, Db2 et Redshift à l'aide des informations d'identification stockées dans Secrets Manager. Chaque pilote encapsule le pilote JDBC de base, vous pouvez donc utiliser des appels JDBC pour accéder à votre base de données. Cependant, au lieu de transmettre un nom d'utilisateur et un mot de passe pour la connexion, vous fournissez l'ID d'un secret. Le pilote appelle Secrets Manager pour récupérer la valeur du secret, puis utilise les informations d'identification dans le secret pour se connecter à la base de données. Le pilote met également en cache les informations d'identification à l'aide de la [bibliothèque de mise en cache côté client Java](retrieving-secrets_cache-java.md), de sorte que les futures connexions ne nécessitent pas d'effectuer d'appel à Secrets Manager. Par défaut, le cache est actualisé toutes les heures et également lors de la rotation du secret. Pour configurer le cache, consultez [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Vous pouvez télécharger le code source à partir de [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Pour utiliser les pilotes de connexion SQL Secrets Manager :
+ Votre application doit être en Java 8 ou une version ultérieure.
+ Votre secret doit être parmi les suivants :
+ Un [secret de base de données dans la structure JSON attendue](reference_secret_json_structure.md). Pour vérifier le format, dans la console Secrets Manager, affichez votre secret et sélectionnez **Retrieve secret value** (Récupérer la valeur du secret). Sinon, dans le AWS CLI, appelez [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Un [secret géré](integrating_how-services-use-secrets_RDS.md) par Amazon RDS. Pour ce type de secret, vous devez spécifier un point de terminaison et un port lorsque vous établissez la connexion.
+ Un secret [géré](integrating_how-services-use-secrets_RS.md) par Amazon Redshift. Pour ce type de secret, vous devez spécifier un point de terminaison et un port lorsque vous établissez la connexion.
Si votre base de données est répliquée vers d'autres régions, pour vous connecter à une base de données de réplica dans une autre région, vous spécifiez le point de terminaison et le port régionaux lorsque vous créez la connexion. Vous pouvez stocker les informations de connexion régionales dans le secret sous forme de key/value paires supplémentaires, dans les paramètres du magasin de paramètres SSM ou dans la configuration de votre code.
Pour ajouter le pilote à votre projet, dans votre fichier de création Maven `pom.xml`, ajoutez la dépendance suivante pour le pilote. Pour plus d'informations, consultez [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) (français non garanti) sur le site web de Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Le pilote utilise 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 vous exécutez le pilote sur Amazon EKS, il est possible qu'il récupère les informations d'identification du nœud sur lequel il s'exécute au lieu du rôle de compte de service. Pour résoudre ce problème, ajoutez la version 1 de `com.amazonaws:aws-java-sdk-sts` à votre fichier de projet Gradle ou Maven en tant que dépendance.
Pour définir une URL de point de terminaison AWS PrivateLink DNS et une région dans le `secretsmanager.properties` fichier :
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Pour remplacer la région principale, définissez la variable d'environnement `AWS_SECRET_JDBC_REGION` ou apportez les modifications suivantes au fichier `secretsmanager.properties` :
```
drivers.region = region
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Établir une connexion à une base de données](#retrieving-secrets_jdbc_example)
+ [Établir une connexion en spécifiant le point de terminaison et le port](#retrieving-secrets_jdbc_example_replica)
+ [Utiliser le regroupement de connexions c3p0 pour établir une connexion](#retrieving-secrets_jdbc_example_c3po)
+ [Utiliser le regroupement de connexions c3p0 pour établir une connexion en spécifiant le point de terminaison et le port](#retrieving-secrets_jdbc_example_c3p0_replica)
## Établir une connexion à une base de données
L'exemple suivant montre comment établir une connexion à une base de données à l'aide des informations d'identification et de connexion dans un secret. Une fois la connexion établie, vous pouvez utiliser les appels JDBC pour accéder à la base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation 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);
```
------
## Établir une connexion en spécifiant le point de terminaison et le port
L'exemple suivant montre comment établir une connexion avec une base de données en utilisant les informations d'identification dans un secret avec un point de terminaison et un port que vous devez spécifier.
[Les secrets gérés par Amazon RDS](integrating_how-services-use-secrets_RDS.md) n'incluent pas le point de terminaison et le port de la base de données. Pour vous connecter à une base de données à l'aide d'informations d'identification principales dans un secret géré par Amazon RDS, vous devez les spécifier dans votre code.
[Les secrets répliqués vers d'autres régions](replicate-secrets.md) peuvent améliorer la latence de la connexion à la base de données régionale, mais ils ne contiennent pas d'informations de connexion différentes de celles du secret source. Chaque réplica est une copie du secret source. Pour stocker les informations de connexion régionales dans le secret, ajoutez des key/value paires supplémentaires pour les informations de point de terminaison et de port pour les régions.
Une fois la connexion établie, vous pouvez utiliser les appels JDBC pour accéder à la base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation 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);
```
------
## Utiliser le regroupement de connexions c3p0 pour établir une connexion
L'exemple suivant montre comment établir un groupement de connexions à l'aide d'un `c3p0.properties` fichier qui se sert du pilote pour récupérer les informations d'identification et de connexion à partir du secret. Pour `user` et `jdbcUrl`, saisissez l'ID secret pour configurer le groupe de connexions. Vous pouvez ensuite récupérer les connexions du groupe et les utiliser comme n'importe quelle autre connexion de base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation Java.
Pour plus d'informations sur c3p0, consultez [c3p0](https://www.mchange.com/projects/c3p0/) sur le site 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
```
------
## Utiliser le regroupement de connexions c3p0 pour établir une connexion en spécifiant le point de terminaison et le port
L'exemple suivant montre comment établir un pool de connexions avec un `c3p0.properties` fichier qui utilise le pilote pour récupérer des informations d'identification dans un secret avec un point de terminaison et un port que vous spécifiez. Vous pouvez ensuite récupérer les connexions du groupe et les utiliser comme n'importe quelle autre connexion de base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation Java.
[Les secrets gérés par Amazon RDS](integrating_how-services-use-secrets_RDS.md) n'incluent pas le point de terminaison et le port de la base de données. Pour vous connecter à une base de données à l'aide d'informations d'identification principales dans un secret géré par Amazon RDS, vous devez les spécifier dans votre code.
[Les secrets répliqués vers d'autres régions](replicate-secrets.md) peuvent améliorer la latence de la connexion à la base de données régionale, mais ils ne contiennent pas d'informations de connexion différentes de celles du secret source. Chaque réplica est une copie du secret source. Pour stocker les informations de connexion régionales dans le secret, ajoutez des key/value paires supplémentaires pour les informations de point de terminaison et de port pour les régions.
------
#### [ 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
```
------
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Java
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
+ Si vous stockez les informations d'identification de la base de données dans le secret, utilisez les pilotes [de connexion Secrets Manager SQL](retrieving-secrets_jdbc.md) pour vous connecter à une base de données à l'aide des informations d'identification que contient le secret.
+ Pour les autres types de secrets, utilisez le [composant de mise en cache Java de Secrets Manager](retrieving-secrets_cache-java.md) ou appelez le SDK directement avec ou. [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)
Les exemples de code suivants illustrent comment utiliser `GetSecretValue`.
**Autorisations requises : **`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);
}
}
}
```