Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Holen Sie sich einen geheimen Secrets Manager Manager-Wert mit Java
In Anwendungen können Sie Ihre Geheimnisse abrufen, indem Sie `GetSecretValue` oder `BatchGetSecretValue` in einem der AWS SDKs. Wir empfehlen jedoch, Ihre Secret-Werte mithilfe des clientseitigen Cachings zu speichern. Das Caching von Secrets verbessert die Geschwindigkeit und senkt Ihre Kosten.
Um mithilfe der Anmeldeinformationen in einem Secret eine Verbindung zu einer Datenbank herzustellen, können Sie die Secrets Manager SQL Connection-Treiber verwenden, die den JDBC-Basistreiber umschließen. Dabei wird auch clientseitiges Caching verwendet, sodass die Kosten für den Aufruf von Secrets Manager reduziert werden können. APIs
**Topics**
+ [
# Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Java mit clientseitigem Caching
](retrieving-secrets_cache-java.md)
+ [
# Stellen Sie mithilfe von JDBC mit geheimen Anmeldeinformationen eine Connect zu einer SQL-Datenbank her AWS Secrets Manager
](retrieving-secrets_jdbc.md)
+ [
# Rufen Sie mit dem Java AWS SDK einen geheimen Wert von Secrets Manager ab
](retrieving-secrets-java-sdk.md)
# Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Java mit clientseitigem Caching
Wenn Sie ein Secret abrufen, können Sie die Java-basierte Caching-Komponente von Secrets Manager verwenden, um es für zukünftige Verwendung zu cachen. Das Abrufen eines gecacheten Secrets ist schneller als das Abrufen aus Secrets Manager. Da der Aufruf von Secrets Manager mit Kosten verbunden ist APIs, kann die Verwendung eines Caches Ihre Kosten senken. Alle Möglichkeiten, wie Sie Secrets abrufen können, finden Sie unter [Holen Sie sich Geheimnisse](retrieving-secrets.md).
Die Cache-Richtlinie ist Least Recently Used (LRU). Wenn der Cache also ein Secret verwerfen muss, verwirft er das am wenigsten verwendete Secret. Standardmäßig aktualisiert der Cache Secrets jede Stunde. Sie können konfigurieren, [wie oft das Secret im Cache aktualisiert wird](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL), und Sie können [den Secret-Abruf anbinden](retrieving-secrets_cache-java-ref_SecretCacheHook.md), um weitere Funktionalität hinzuzufügen.
Der Cache erzwingt keine Garbage Collection, sobald Cache-Referenzen freigegeben wurden. Die Cache-Implementierung beinhaltet keine Cache-Invalidierung. Die Cache-Implementierung konzentriert sich auf den Cache selbst und ist weder sicherheitsgehärtet noch fokussiert. Wenn Sie zusätzliche Sicherheit benötigen, z. B. das Verschlüsseln von Elementen im Cache, verwenden Sie die bereitgestellten Schnittstellen und abstrakten Methoden.
Zum Verwenden der Komponente ist Folgendes erforderlich:
+ Eine Java-8- oder eine höhere Entwicklungsumgebung. Siehe [Java SE-Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) auf der Oracle-Website.
Informationen zum Herunterladen des Quellcodes finden Sie unter [Secrets Manager Java-basierte Caching-Client-Komponente](https://github.com/aws/aws-secretsmanager-caching-java) auf. GitHub
Um die Komponente Ihrem Projekt hinzuzufügen, fügen Sie in Ihrer Datei Maven pom.xml die folgende Abhängigkeit ein. Weitere Informationen zu Maven finden Sie im [Handbuch „Erste Schritte“](https://maven.apache.org/guides/getting-started/index.html) auf der Website von Apache Maven.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](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 Ein Secret abrufen**
Das folgende Codebeispiel zeigt eine Lambda-Funktion, die eine Secret-Zeichenfolge abruft. Es folgt der [bewährten Methode](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html), den Cache außerhalb des Funktionshandlers zu instanziieren, ruft also die API nicht weiter auf, wenn Sie die Lambda-Funktion erneut aufrufen.
```
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
Ein In-Memory-Cache für von Secrets Manager angeforderte Secrets. Sie verwenden [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) oder [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary), um ein Secret aus dem Cache abzurufen. Sie können die Cache-Einstellungen konfigurieren, indem Sie ein [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md)-Objekt im Konstruktor übergeben.
Weitere Informationen hierzu einschließlich Beispielen finden Sie unter [Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Java mit clientseitigem Caching](retrieving-secrets_cache-java.md).
## Konstruktoren
`public SecretCache()`
Standardkonstruktor für ein `SecretCache`-Objekt.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Konstruiert einen neuen Cache mit einem Secrets-Manager-Manager-Client, der mit dem bereitgestellten [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) erstellt wurde. Verwenden Sie diesen Konstruktor, um den Secrets Manager Manager-Client anzupassen, z. B. um eine bestimmte Region oder einen bestimmten Endpunkt zu verwenden.
`public SecretCache(AWSSecretsManager client)`
Konstruiert einen neuen Secret-Cache mit dem bereitgestellten [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). Verwenden Sie diesen Konstruktor, um den Secrets Manager Manager-Client anzupassen, z. B. um eine bestimmte Region oder einen bestimmten Endpunkt zu verwenden.
`public SecretCache(SecretCacheConfiguration config)`
Konstruiert einen neuen Secret-Cache mit dem bereitgestellten `SecretCacheConfiguration`.
## Methoden
### getSecretString
`public String getSecretString(final String secretId)`
Ruft ein String-Secret von Secrets Manager ab. Gibt eine [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) zurück.
### getSecretBinary
`public ByteBuffer getSecretBinary(final String secretId)`
Ruft ein binäres Secret von Secrets Manager ab. Gibt eine [https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html) zurück.
### refreshNow
`public boolean refreshNow(final String secretId) throws InterruptedException`
Zwingt den Cache zur Aktualisierung. Gibt `true` zurück, wenn die Aktualisierung fehlerfrei abgeschlossen ist, sonst `false`.
### close
`public void close()`
Schließt den Cache.
# SecretCacheConfiguration
Cache-Konfigurationsoptionen für ein [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), z. B. maximale Cachegröße und Time to Live (TTL) für gecachete Secrets.
## Konstruktor
`public SecretCacheConfiguration`
Standardkonstruktor für ein `SecretCacheConfiguration`-Objekt.
## Methoden
### getClient
`public AWSSecretsManager getClient()`
Gibt den neuen [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) zurück, von dem der Cache Secrets abruft.
### setClient
`public void setClient(AWSSecretsManager client)`
Legt den neuen [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) fest, von dem der Cache Secrets abruft.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Gibt die neue [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)-Schnittstelle zurück, die zum Anbinden von Cache-Updates verwendet wird.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Legt die neue [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)-Schnittstelle fest, die zum Anbinden von Cache-Updates verwendet wird.
### getMaxCacheGröße
`public int getMaxCacheSize()`
Gibt die maximale Cachegröße zurück. Der Standardwert ist 1 024 Secrets.
### setMaxCacheGröße
`public void setMaxCacheSize(int maxCacheSize)`
Legt die maximale Cachegröße fest. Der Standardwert ist 1 024 Secrets.
### getCacheItemTTL
`public long getCacheItemTTL()`
Gibt die TTL in Millisekunden für die gecacheten Elemente zurück. Wenn ein gecachetes Secret diese TTL überschreitet, ruft der Cache eine neue Kopie des Secrets aus dem [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) ab. Der Standardwert beträgt 1 Stunde in Millisekunden.
Der Cache aktualisiert das Secret synchron, wenn das Secret nach der TTL angefordert wird. Wenn die synchrone Aktualisierung fehlschlägt, gibt der Cache das veraltete Secrets zurück.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Legt die TTL in Millisekunden für die gecacheten Elemente fest. Wenn ein gecachetes Secret diese TTL überschreitet, ruft der Cache eine neue Kopie des Secrets aus dem [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) ab. Der Standardwert beträgt 1 Stunde in Millisekunden.
### getVersionStage
`public String getVersionStage()`
Gibt die Version von Secrets zurück, die Sie cachen möchten. Weitere Informationen hierzu finden Sie unter [Secret-Versionen](whats-in-a-secret.md#term_version). Der Standardwert ist ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Legt die Version von Secrets fest, die Sie cachen möchten. Weitere Informationen hierzu finden Sie unter [Secret-Versionen](whats-in-a-secret.md#term_version). Der Standardwert ist `"AWSCURRENT"`.
### SecretCacheConfiguration Mit dem Kunden
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Legt den neuen [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) zum Abrufen von Secrets fest. Gibt das aktualisierte `SecretCacheConfiguration`-Objekt mit der neuen Einstellung zurück.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Legt die Schnittstelle fest, die zum Anbinden des In-Memory-Cache verwendet wird. Gibt das aktualisierte `SecretCacheConfiguration`-Objekt mit der neuen Einstellung zurück.
### SecretCacheConfiguration withMaxCacheGröße
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Legt die maximale Cachegröße fest. Gibt das aktualisierte `SecretCacheConfiguration`-Objekt mit der neuen Einstellung zurück.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Legt die TTL in Millisekunden für die gecacheten Elemente fest. Wenn ein gecachetes Secret diese TTL überschreitet, ruft der Cache eine neue Kopie des Secrets aus dem [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) ab. Der Standardwert beträgt 1 Stunde in Millisekunden. Gibt das aktualisierte `SecretCacheConfiguration`-Objekt mit der neuen Einstellung zurück.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Legt die Version von Secrets fest, die Sie cachen möchten. Weitere Informationen hierzu finden Sie unter [Secret-Versionen](whats-in-a-secret.md#term_version). Gibt das aktualisierte `SecretCacheConfiguration`-Objekt mit der neuen Einstellung zurück.
# SecretCacheHook
Eine Schnittstelle für das Anbinden eines [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), um Aktionen mit dem im Cache gespeicherten Secret durchzuführen.
## put
`Object put(final Object o)`
Bereitet das Objekt für das Speichern im Cache vor.
Gibt das Objekt zurück, das im Cache gespeichert werden soll.
## get
`Object get(final Object cachedObject)`
Leitet das Objekt aus dem gecacheten Objekt ab.
Gibt das Objekt zurück, das vom Cache zurückgegeben werden soll.
# Stellen Sie mithilfe von JDBC mit geheimen Anmeldeinformationen eine Connect zu einer SQL-Datenbank her AWS Secrets Manager
In Java-Anwendungen können Sie die Secrets Manager SQL Connection-Treiber verwenden, um mithilfe der in Secrets Manager gespeicherten Anmeldeinformationen eine Verbindung zu MySQL-, PostgreSQL- MSSQLServer, Oracle-, Db2- und Redshift-Datenbanken herzustellen. Jeder Treiber umschließt den JDBC-Basis-Treiber, sodass Sie JDBC-Aufrufe verwenden können, um auf Ihre Datenbank zuzugreifen. Anstatt jedoch einen Benutzernamen und ein Passwort für die Verbindung zu übergeben, geben Sie die ID eines Secrets an. Der Treiber ruft Secrets Manager auf, um den Secret-Wert abzurufen, und verwendet dann die Anmeldeinformationen im Secret, um eine Verbindung mit der Datenbank herzustellen. Der Treiber speichert die Anmeldeinformationen auch mit der [Java-clientseitigen Caching-Library](retrieving-secrets_cache-java.md), damit zukünftige Verbindungen keinen Anruf bei Secrets Manager erfordern. Standardmäßig wird der Cache jede Stunde aktualisiert sowie wenn ein Secret gedreht wird. Informationen zum Konfigurieren des Cache finden Sie unter [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Sie können den Quellcode von herunterladen. [GitHub](https://github.com/aws/aws-secretsmanager-jdbc )
So verwenden Sie die Secrets-Manager-SQL-Connection-Treiber:
+ Ihre Anwendung muss sich in Java 8 oder höher befinden.
+ Ihr Secret muss in einem der folgenden Formate vorliegen:
+ Ein [Datenbank-Secret in der erwarteten JSON-Struktur](reference_secret_json_structure.md). Um das Format zu überprüfen, sehen Sie sich in der Secrets-Manager-Konsole Ihr Secret an und wählen Sie **Retrieve secret value** (Secret-Wert abrufen) aus. Alternativ rufen Sie im AWS CLI an [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Ein von Amazon RDS [verwaltetes Secret](integrating_how-services-use-secrets_RDS.md). Für diese Art von Secret müssen Sie einen Endpunkt und einen Port angeben, wenn Sie die Verbindung herstellen.
+ Ein von Amazon Redshift [verwaltetes Geheimnis](integrating_how-services-use-secrets_RS.md). Für diese Art von Secret müssen Sie einen Endpunkt und einen Port angeben, wenn Sie die Verbindung herstellen.
Wenn Ihre Datenbank in andere Regionen repliziert wird, geben Sie, um eine Verbindung mit einer Replikat-Datenbank in einer anderen Region herzustellen, beim Erstellen der Verbindung den regionalen Endpunkt und den Port an. Sie können regionale Verbindungsinformationen im Secret als zusätzliche key/value Paare, in SSM-Parameterspeicher-Parametern oder in Ihrer Codekonfiguration speichern.
Um den Treiber zu Ihrem Projekt hinzuzufügen, fügen Sie in Ihrer Maven Build-Datei `pom.xml` die folgende Abhängigkeit für den Treiber hinzu. Weitere Informationen finden Sie unter [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) auf der Maven-Central-Repository-Website.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Der Treiber verwendet [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). Wenn Sie den Treiber auf Amazon EKS ausführen, werden möglicherweise die Anmeldeinformationen des Knotens, auf dem er ausgeführt wird, anstelle der Dienstkontorolle abgerufen. Um dies zu beheben, fügen Sie Version 1 von `com.amazonaws:aws-java-sdk-sts` als Abhängigkeit zu Ihrer Gradle- oder Maven-Projektdatei hinzu.
So legen Sie eine AWS PrivateLink DNS-Endpunkt-URL und eine Region in der `secretsmanager.properties` Datei fest:
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Um die primäre Region zu überschreiben, legen Sie die `AWS_SECRET_JDBC_REGION`-Umgebungsvariable fest oder nehmen Sie die folgende Änderung an der `secretsmanager.properties`-Datei vor:
```
drivers.region = region
```
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [
## Verbindung zu einer Datenbank herstellen
](#retrieving-secrets_jdbc_example)
+ [
## Verbindung herstellen, indem Sie den Endpunkt und den Port angeben
](#retrieving-secrets_jdbc_example_replica)
+ [
## c3p0-Verbindungs-Pooling verwenden, um eine Verbindung herzustellen
](#retrieving-secrets_jdbc_example_c3po)
+ [
## c3p0-Verbindungspooling verwenden, indem Sie den Endpunkt und den Port angeben
](#retrieving-secrets_jdbc_example_c3p0_replica)
## Verbindung zu einer Datenbank herstellen
Das folgende Beispiel zeigt, wie Sie mithilfe der Anmeldeinformationen und Verbindungsinformationen in einem Secret eine Verbindung zu einer Datenbank herstellen. Nachdem Sie über die Verbindung verfügen, können Sie JDBC-Aufrufe verwenden, um auf die Datenbank zuzugreifen. Weitere Informationen finden Sie unter [JDBC-Grundlagen](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) auf der Website der Java-Dokumentation.
------
#### [ 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);
```
------
## Verbindung herstellen, indem Sie den Endpunkt und den Port angeben
Das folgende Beispiel zeigt, wie Sie mithilfe der Anmeldeinformationen in einem Secret mit einem von Ihnen angegebenen Endpunkt und Port eine Verbindung zu einer Datenbank herstellen.
Die von [Amazon RDS verwalteten Secrets](integrating_how-services-use-secrets_RDS.md) beinhalten nicht den Endpunkt und den Port der Datenbank. Um mithilfe von Master-Anmeldeinformationen in einem von Amazon RDS verwalteten Secret eine Verbindung zu einer Datenbank herzustellen, geben Sie diese in Ihrem Code an.
[Secrets, die in anderen Regionen repliziert werden](replicate-secrets.md), können die Latenz für die Verbindung zur regionalen Datenbank verbessern, enthalten jedoch keine unterschiedlichen Verbindungsinformationen aus dem Quellsecret. Jedes Replikat ist eine Kopie des Quellsecret. Um regionale Verbindungsinformationen im Secret zu speichern, fügen Sie weitere key/value Paare für den Endpunkt und Portinformationen für die Regionen hinzu.
Nachdem Sie über die Verbindung verfügen, können Sie JDBC-Aufrufe verwenden, um auf die Datenbank zuzugreifen. Weitere Informationen finden Sie unter [JDBC-Grundlagen](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) auf der Website der Java-Dokumentation.
------
#### [ 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);
```
------
## c3p0-Verbindungs-Pooling verwenden, um eine Verbindung herzustellen
Das folgende Beispiel zeigt, wie Sie einen Verbindungspool mit einer `c3p0.properties`-Datei herstellen, die den Treiber verwendet, um Anmeldeinformationen und Verbindungsinformationen aus dem Secret abzurufen. Geben Sie für `user` und `jdbcUrl` die Secret-ID ein, um den Verbindungspool zu konfigurieren. Dann können Sie Verbindungen aus dem Pool abrufen und sie wie andere Datenbankverbindungen verwenden. Weitere Informationen finden Sie unter [JDBC-Grundlagen](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) auf der Website der Java-Dokumentation.
Weitere Informationen zu c3p0 finden Sie unter [c3p0](https://www.mchange.com/projects/c3p0/) auf der Website von 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
```
------
## c3p0-Verbindungspooling verwenden, indem Sie den Endpunkt und den Port angeben
Das folgende Beispiel zeigt, wie Sie einen Verbindungspool mit einer `c3p0.properties` Datei einrichten, die den Treiber zum Abrufen von Anmeldeinformationen in einem geheimen Ordner mit einem von Ihnen angegebenen Endpunkt und Port verwendet. Dann können Sie Verbindungen aus dem Pool abrufen und sie wie andere Datenbankverbindungen verwenden. Weitere Informationen finden Sie unter [JDBC-Grundlagen](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) auf der Website der Java-Dokumentation.
Die von [Amazon RDS verwalteten Secrets](integrating_how-services-use-secrets_RDS.md) beinhalten nicht den Endpunkt und den Port der Datenbank. Um mithilfe von Master-Anmeldeinformationen in einem von Amazon RDS verwalteten Secret eine Verbindung zu einer Datenbank herzustellen, geben Sie diese in Ihrem Code an.
[Secrets, die in anderen Regionen repliziert werden](replicate-secrets.md), können die Latenz für die Verbindung zur regionalen Datenbank verbessern, enthalten jedoch keine unterschiedlichen Verbindungsinformationen aus dem Quellsecret. Jedes Replikat ist eine Kopie des Quellsecret. Um regionale Verbindungsinformationen im Secret zu speichern, fügen Sie weitere key/value Paare für den Endpunkt und Portinformationen für die Regionen hinzu.
------
#### [ 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
```
------
# Rufen Sie mit dem Java AWS SDK einen geheimen Wert von Secrets Manager ab
In Anwendungen können Sie Ihre Geheimnisse abrufen, indem Sie sie aufrufen `GetSecretValue` oder `BatchGetSecretValue` in einem der AWS SDKs. Wir empfehlen jedoch, Ihre Secret-Werte mithilfe des clientseitigen Cachings zu speichern. Das Caching von Secrets verbessert die Geschwindigkeit und senkt Ihre Kosten.
+ Wenn Sie Datenbankanmeldeinformationen im Secret speichern, verwenden Sie die [Secrets-Manager-SQL-Verbindungstreiber](retrieving-secrets_jdbc.md), um mithilfe der Anmeldeinformationen im Secret eine Verbindung zu einer Datenbank herzustellen.
+ Verwenden Sie für andere Arten von Geheimnissen die [Java-basierte Caching-Komponente von Secrets Manager](retrieving-secrets_cache-java.md) oder rufen Sie das SDK direkt mit oder auf. [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)
Die folgenden Code-Beispiele zeigen, wie `GetSecretValue` verwendet wird.
**Erforderliche Berechtigungen: **`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);
}
}
}
```