Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Ottieni un valore segreto di Secrets Manager usando Java
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per connettersi a un database utilizzando le credenziali di un segreto, è possibile utilizzare i driver Secrets Manager SQL Connection, che racchiudono il driver JDBC di base. Questa soluzione utilizza anche la memorizzazione nella cache lato client, in modo da ridurre i costi di chiamata a Secrets Manager. APIs
**Topics**
+ [
# Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client
](retrieving-secrets_cache-java.md)
+ [
# Connect a un database SQL utilizzando JDBC con credenziali segrete Gestione dei segreti AWS
](retrieving-secrets_jdbc.md)
+ [
# Ottieni un valore segreto di Secrets Manager utilizzando Java AWS SDK
](retrieving-secrets-java-sdk.md)
# Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client
Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su Java di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-java-ref_SecretCacheHook.md) per aggiungere altre funzionalità.
La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.
Per usare il componente, devi disporre dei seguenti elementi:
+ Ambiente di sviluppo Java 8 o versioni successive. Consulta [Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) sul sito Web di Oracle.
Per scaricare il codice sorgente, vedete [Secrets Manager, componente client di caching basato su Java](https://github.com/aws/aws-secretsmanager-caching-java) su. GitHub
Per aggiungere il componente al progetto, nel file Maven pom.xml, includi la seguente dipendenza. Per ulteriori informazioni su Maven, consulta la [Guida alle operazioni di base](https://maven.apache.org/guides/getting-started/index.html) sul sito Web Apache Maven Project.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](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 Recupero di un segreto**
L'esempio di codice riportato di seguito mostra una funzione Lambda che recupera una stringa del segreto. Segue la [best practice](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) di creare un'istanza della cache al di fuori del gestore della funzione quindi non continua a chiamare l'API se si chiama nuovamente la funzione 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 cache in memoria per i segreti richiesti da Secrets Manager. Si usa [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) o [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) per recuperare un segreto dalla cache. È possibile configurare le impostazioni della cache specificando un oggetto [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) nel costruttore.
Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client](retrieving-secrets_cache-java.md).
## Costruttori
`public SecretCache()`
Costruttore di default per un oggetto `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Costruisce una nuova cache utilizzando un client di Secrets Manager creato utilizzando l'[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) fornito. Utilizzate questo costruttore per personalizzare il client Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifici.
`public SecretCache(AWSSecretsManager client)`
Costruisce una nuova cache del segreto utilizzando l'[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) fornito. Utilizzate questo costruttore per personalizzare il client Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifici.
`public SecretCache(SecretCacheConfiguration config)`
Costruisce una nuova cache del segreto utilizzando il `SecretCacheConfiguration` fornito.
## Metodi
### getSecretString
`public String getSecretString(final String secretId)`
Recupera un segreto stringa da Secrets Manager. Restituisce una [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 segreto binario da Secrets Manager. Restituisce 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`
Forza l'aggiornamento della cache. Restituisce `true` se l'aggiornamento è stato completato senza errori, altrimenti `false`.
### close
`public void close()`
Chiude la cache.
# SecretCacheConfiguration
Opzioni di configurazione della cache per una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), ad esempio dimensione massima della cache e durata (TTL) per i segreti memorizzati nella cache.
## Costruttore
`public SecretCacheConfiguration`
Costruttore di default per un oggetto `SecretCacheConfiguration`.
## Metodi
### getClient
`public AWSSecretsManager getClient()`
Restituisce l'[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) da cui la cache recupera segreti.
### setClient
`public void setClient(AWSSecretsManager client)`
Restituisce il 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) da cui la cache recupera segreti.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Restituisce l'interfaccia [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizzata per collegarsi agli aggiornamenti della cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Imposta l'interfaccia [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizzata per collegarsi agli aggiornamenti della cache.
### getMaxCacheDimensioni
`public int getMaxCacheSize()`
Restituisce la dimensione massima della cache. Il valore di default è 1024 segreti.
### setMaxCacheDimensioni
`public void setMaxCacheSize(int maxCacheSize)`
Imposta la dimensione massima della cache. Il valore di default è 1024 segreti.
### getCacheItemTTL
`public long getCacheItemTTL()`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [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). Il valore predefinito è 1 ora in millisecondi.
La cache aggiorna il segreto in modo sincrono quando viene richiesto il segreto dopo il TTL. Se l'aggiornamento sincrono ha esito negativo, la cache restituisce il segreto non aggiornato.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [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). Il valore predefinito è 1 ora in millisecondi.
### getVersionStage
`public String getVersionStage()`
Restituisce la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è `"AWSCURRENT"`.
### SecretCacheConfiguration Con Client
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Imposta il [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) da cui recuperare segreti. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Imposta l'interfaccia utilizzata per collegare la cache in memoria. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withMaxCacheDimensioni
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Imposta la dimensione massima della cache. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [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). Il valore predefinito è 1 ora in millisecondi. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
# SecretCacheHook
Un'interfaccia per collegarsi a una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) per eseguire operazioni sui segreti memorizzati al suo interno.
## put
`Object put(final Object o)`
Prepara l'oggetto per la memorizzazione nella cache.
Restituisce l'oggetto da memorizzare nella cache.
## get
`Object get(final Object cachedObject)`
Deriva l'oggetto dall'oggetto memorizzato nella cache.
Restituisce l'oggetto da restituire dalla cache
# Connect a un database SQL utilizzando JDBC con credenziali segrete Gestione dei segreti AWS
Nelle applicazioni Java, è possibile utilizzare i driver Secrets Manager SQL Connection per connettersi ai database MySQL, PostgreSQL, MSSQLServer Oracle, Db2 e Redshift utilizzando le credenziali archiviate in Secrets Manager. Ogni driver esegue il wrapping del driver JDBC di base per consentire l'utilizzo delle chiamate JDBC per accedere al database. Tuttavia, invece di specificare un nome utente e una password per la connessione, si fornisce l'ID di un segreto. Il driver chiama Secrets Manager per recuperare il valore del segreto, quindi utilizza le credenziali nel segreto per connettersi al database. Il driver inoltre memorizza le credenziali nella cache utilizzando la [libreria di caching lato client Java](retrieving-secrets_cache-java.md), in modo che per le connessioni future non sia necessaria una chiamata a Secrets Manager. Per impostazione predefinita, la cache viene aggiornata ogni ora e anche quando un segreto viene ruotato. Per configurare la cache, consulta [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
È possibile scaricare il codice sorgente da. [GitHub](https://github.com/aws/aws-secretsmanager-jdbc )
Per utilizzare i driver di connessione SQL di Secrets Manager:
+ L'applicazione deve essere in Java 8 o versioni successive.
+ Il segreto deve essere uno fra i seguenti:
+ Un [segreto di database nella struttura JSON prevista](reference_secret_json_structure.md). Per verificare il formato, nella console di Secrets Manager, visualizza il tuo segreto e seleziona **Retrieve secret value** (Recupera valore segreto). In alternativa AWS CLI, nella chiamata [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Un [segreto gestito](integrating_how-services-use-secrets_RDS.md) da Amazon RDS. Per questo tipo di segreto, quando si stabilisce la connessione è necessario specificare un endpoint e una porta.
+ Un segreto [gestito](integrating_how-services-use-secrets_RS.md) da Amazon Redshift. Per questo tipo di segreto, quando si stabilisce la connessione è necessario specificare un endpoint e una porta.
Se il database viene replicato in altre regioni, per connettersi a un database di replica in una regione differente, è necessario specificare l'endpoint e la porta della regione al momento della creazione della connessione. Puoi memorizzare le informazioni di connessione regionali nel segreto come key/value coppie aggiuntive, nei parametri SSM Parameter Store o nella configurazione del codice.
Per aggiungere il driver al progetto, nel file di build Maven `pom.xml`, aggiungi la seguente dipendenza per il driver. Per ulteriori informazioni, consulta [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) sul sito Web di Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Il driver utilizza 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). Se esegui il driver su Amazon EKS, potrebbe raccogliere le credenziali del nodo su cui è in esecuzione anziché il ruolo dell'account di servizio. Per risolvere questo problema, aggiungi la versione 1 di `com.amazonaws:aws-java-sdk-sts` al tuo file di progetto Gradle o Maven come dipendenza.
Per impostare un URL di endpoint AWS PrivateLink DNS e una regione nel file: `secretsmanager.properties`
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Per sovrascrivere la regione primaria, imposta la variabile d'ambiente `AWS_SECRET_JDBC_REGION` o apporta la seguente modifica al file `secretsmanager.properties`:
```
drivers.region = region
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [
## Stabilire una connessione a un database
](#retrieving-secrets_jdbc_example)
+ [
## Impostazione di una connessione specificando l'endpoint e la porta
](#retrieving-secrets_jdbc_example_replica)
+ [
## Utilizzare il pooling di connessioni c3p0 per stabilire una connessione
](#retrieving-secrets_jdbc_example_c3po)
+ [
## Utilizzo del pooling di connessioni c3p0 per stabilire una connessione specificando l'endpoint e la porta
](#retrieving-secrets_jdbc_example_c3p0_replica)
## Stabilire una connessione a un database
Nell'esempio seguente viene illustrato come stabilire una connessione a un database utilizzando le credenziali e le informazioni di connessione in un segreto. Una volta acquisita la connessione, puoi utilizzare le chiamate JDBC per accedere al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione 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);
```
------
## Impostazione di una connessione specificando l'endpoint e la porta
Nell'esempio seguente viene illustrato come stabilire una connessione a un database utilizzando le credenziali in un segreto con un endpoint e una porta specificati dall'utente.
[I segreti gestiti da Amazon RDS](integrating_how-services-use-secrets_RDS.md) non includono l'endpoint e la porta del database. Per connettersi a un database utilizzando le credenziali master in un segreto gestito da Amazon RDS, è necessario specificarle nel codice.
[I segreti replicati in altre Regioni](replicate-secrets.md) possono migliorare la latenza per la connessione al database regionale, ma non contengono informazioni di connessione diverse dal segreto di origine. Ogni replica è una copia del segreto di origine. Per memorizzare le informazioni di connessione regionali in modalità segreta, aggiungi altre key/value coppie per l'endpoint e le informazioni sulla porta per le regioni.
Una volta acquisita la connessione, puoi utilizzare le chiamate JDBC per accedere al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione 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);
```
------
## Utilizzare il pooling di connessioni c3p0 per stabilire una connessione
Nell'esempio seguente viene illustrato come stabilire un pool di connessioni con un file `c3p0.properties` che utilizza il driver per recuperare le credenziali e le informazioni sulla connessione dal segreto. Per `user` e `jdbcUrl`, inserisci l'ID segreto per configurare il pool di connessioni. Puoi quindi recuperare le connessioni dal pool e utilizzarle come qualsiasi altra connessione al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
Per ulteriori informazioni su c3p0, consulta [c3p0](https://www.mchange.com/projects/c3p0/) sul sito 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
```
------
## Utilizzo del pooling di connessioni c3p0 per stabilire una connessione specificando l'endpoint e la porta
L'esempio seguente mostra come stabilire un pool di connessioni con un `c3p0.properties` file che utilizza il driver per recuperare le credenziali in un segreto con un endpoint e una porta specificati dall'utente. Puoi quindi recuperare le connessioni dal pool e utilizzarle come qualsiasi altra connessione al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
[I segreti gestiti da Amazon RDS](integrating_how-services-use-secrets_RDS.md) non includono l'endpoint e la porta del database. Per connettersi a un database utilizzando le credenziali master in un segreto gestito da Amazon RDS, è necessario specificarle nel codice.
[I segreti replicati in altre Regioni](replicate-secrets.md) possono migliorare la latenza per la connessione al database regionale, ma non contengono informazioni di connessione diverse dal segreto di origine. Ogni replica è una copia del segreto di origine. Per memorizzare le informazioni di connessione regionali nel segreto, aggiungi altre key/value coppie per l'endpoint e le informazioni sulla porta per le regioni.
------
#### [ 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
```
------
# Ottieni un valore segreto di Secrets Manager utilizzando Java AWS SDK
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
+ Se memorizzi le credenziali del database nel segreto, utilizza i [driver di connessione SQL di Secrets Manager](retrieving-secrets_jdbc.md) per eseguire la connessione a un database utilizzando le credenziali nel segreto.
+ Per altri tipi di segreti, usa il [componente di caching basato su Java Secrets Manager](retrieving-secrets_cache-java.md) o chiama l'SDK direttamente con o. [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)
Gli esempi di codice seguenti mostrano come utilizzare `GetSecretValue`.
**Autorizzazioni richieste:**`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);
}
}
}
```