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.
# Hol dir Geheimnisse von AWS Secrets Manager
Secrets Manager generiert einen CloudTrail Protokolleintrag, wenn Sie ein Geheimnis abrufen. Weitere Informationen finden Sie unter [AWS Secrets Manager Ereignisse protokollieren mit AWS CloudTrail](monitoring-cloudtrail.md).
**Topics**
+ [Java](retrieving-secrets-java.md)
+ [Python](retrieving-secrets-python.md)
+ [.NET](retrieving-secrets-net.md)
+ [Go](retrieving-secrets-go.md)
+ [Rust](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Secrets Manager Manager-Agent](secrets-manager-agent.md)
+ [C\$1\$1](retrieving-secrets-cpp.md)
+ [JavaScript](retrieving-secrets-javascript.md)
+ [Kotlin](retrieving-secrets-kotlin.md)
+ [PHP](retrieving-secrets-php.md)
+ [Ruby](retrieving-secrets-ruby.md)
+ [AWS CLI](retrieving-secrets_cli.md)
+ [AWS Konsole](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub Jobs](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Parameter Store](integrating_parameterstore.md)
# 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);
}
}
}
```
# Holen Sie sich einen geheimen Secrets Manager Manager-Wert mit Python
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.
**Topics**
+ [Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Python mit clientseitigem Caching](retrieving-secrets_cache-python.md)
+ [Rufen Sie mit dem AWS Python-SDK einen geheimen Wert von Secrets Manager ab](retrieving-secrets-python-sdk.md)
+ [Holen Sie sich mit dem AWS Python-SDK einen Stapel geheimer Werte von Secrets Manager](retrieving-secrets-python-batch.md)
# Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Python mit clientseitigem Caching
Wenn Sie ein Secret abrufen, können Sie die Python-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-ref-secretcacheconfig.md), und Sie können [den Secret-Abruf anbinden](retrieving-secrets_cache-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:
+ Python 3.6 oder höher.
+ botocore 1.12 oder höher. Siehe [AWS -SDK für Python](https://aws.amazon.com/sdk-for-python/) und [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 oder höher. Siehe [https://pyPi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Informationen zum Herunterladen des Quellcodes finden Sie unter [Secrets Manager Python-basierte Caching-Client-Komponente](https://github.com/aws/aws-secretsmanager-caching-python ) auf. GitHub
Mit dem folgenden Befehl können Sie die Komponente installieren.
```
$ pip install aws-secretsmanager-caching
```
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-ref-secretcache.md)
+ [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)
+ [SecretCacheHook](retrieving-secrets_cache-ref-secretcachehook.md)
+ [@InjectSecretString](retrieving-secrets_cache-decor-string.md)
+ [@InjectKeywordedSecretString](retrieving-secrets_cache-decor-keyword.md)
**Example Ein Secret abrufen**
Das folgende Beispiel zeigt, wie der geheime Wert für ein Secret mit dem Namen abgerufen werden kann. *mysecret*
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Ein In-Memory-Cache für aus Secrets Manager abgerufene Secrets. Sie verwenden [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) oder [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary), um ein Secret aus dem Cache abzurufen. Sie können die Cache-Einstellungen konfigurieren, indem Sie ein [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)-Objekt im Konstruktor übergeben.
Weitere Informationen hierzu einschließlich Beispielen finden Sie unter [Holen Sie sich einen geheimen Secrets Manager-Wert mithilfe von Python mit clientseitigem Caching](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Ruft den Secret-String-Wert ab.
Erforderliche Syntax
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameters
+ `secret_id`(*string*): [Erforderlich] Der Name oder der ARN des Geheimnisses.
+ `version_stage`(*string*): Die Version der Secrets, die Sie abrufen möchten. Weitere Informationen finden Sie unter [Geheime Versionen](whats-in-a-secret.md). Der Standardwert ist 'AWSCURRENT'.
Rückgabetyp
Zeichenfolge
## get\$1secret\$1binary
Ruft den Secret-Binärwert ab.
Erforderliche Syntax
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameters
+ `secret_id`(*string*): [Erforderlich] Der Name oder der ARN des Geheimnisses.
+ `version_stage`(*string*): Die Version der Secrets, die Sie abrufen möchten. Weitere Informationen finden Sie unter [Geheime Versionen](whats-in-a-secret.md). Der Standardwert ist 'AWSCURRENT'.
Rückgabetyp
[base64-kodierte](https://tools.ietf.org/html/rfc4648#section-4) Zeichenfolge
# SecretCacheConfig
Cache-Konfigurationsoptionen für ein [SecretCache](retrieving-secrets_cache-ref-secretcache.md), z. B. maximale Cachegröße und Time to Live (TTL) für gecachete Secrets.Parameters
`max_cache_size` (*int*)
Die maximale Cachegröße. Der Standardwert ist `1024` Secrets.
`exception_retry_delay_base` (*int*)
Die Anzahl der Sekunden, die gewartet werden soll, nachdem eine Ausnahme aufgetreten ist, bevor ein erneuter Versuch gestartet wird. Der Standardwert ist `1`.
`exception_retry_growth_factor` (*int*)pur
Der Wachstumsfaktor, der für die Berechnung der Wartezeit zwischen Wiederholungen fehlgeschlagener Anfragen verwendet werden soll. Der Standardwert ist `2`.
`exception_retry_delay_max` (*int*)
Maximale Wartezeit in Sekunden zwischen fehlgeschlagenen Anfragen. Der Standardwert ist `3600`.
`default_version_stage` (*str*)
Die Version der Secrets, das Sie cachen möchten. Weitere Informationen hierzu finden Sie unter [Secret-Versionen](whats-in-a-secret.md#term_version). Der Standardwert ist `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
Die Anzahl der Sekunden, die zwischen den Aktualisierungen der gecacheten Secret-Informationen gewartet wird. Der Standardwert ist `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Eine Implementierung der `SecretCacheHook`-abstrakten Klasse. Der Standardwert ist `None`.
# SecretCacheHook
Eine Schnittstelle für das Anbinden eines [SecretCache](retrieving-secrets_cache-ref-secretcache.md), um Aktionen mit dem im Cache gespeicherten Secret durchzuführen.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [get](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Bereitet das Objekt für das Speichern im Cache vor.
Erforderliche Syntax
```
response = hook.put(
obj='secret_object'
)
```
Parameters
+ `obj` (*object*) -- [Required] Das Secret oder das Objekt, das das Secret enthält.
Rückgabetyp
object
## get
Leitet das Objekt aus dem gecacheten Objekt ab.
Erforderliche Syntax
```
response = hook.get(
obj='secret_object'
)
```
Parameters
+ `obj`(*Objekt*): [Erforderlich] Das Geheimnis oder Objekt, das das Geheimnis enthält.
Rückgabetyp
object
# @InjectSecretString
Dieser Dekorator erwartet eine Secret-ID-Zeichenfolge und [SecretCache](retrieving-secrets_cache-ref-secretcache.md) als erstes und zweites Argument. Der Dekorator gibt den Secret-Zeichenfolgewert zurück. Das Secret muss eine Zeichenfolge enthalten.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectSecretString ( 'mysecret' , cache )
def function_to_be_decorated( arg1, arg2, arg3):
```
# @InjectKeywordedSecretString
Dieser Dekorator erwartet eine Secret-ID-Zeichenfolge und [SecretCache](retrieving-secrets_cache-ref-secretcache.md) als erstes und zweites Argument. Die verbleibenden Argumente ordnen die Parameter der umschlossenen Funktion den JSON-Schlüsseln im Secret zu. Das Secret muss eine Zeichenfolge in der JSON-Struktur enthalten.
Für ein Secret, das dieses JSON enthält:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
Das folgende Beispiel zeigt, wie Sie die JSON-Werte für `username` und `password` aus dem Secret extrahieren.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectKeywordedSecretString ( secret_id = 'mysecret' , cache = cache , func_username = 'username' , func_password = 'password' )
def function_to_be_decorated( func_username, func_password):
print( 'Do something with the func_username and func_password parameters')
```
# Rufen Sie mit dem AWS Python-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.
Verwenden Sie für Python-Anwendungen die [Secrets-Manager-Python-basierte Caching-Komponente](retrieving-secrets_cache-python.md) oder rufen Sie das SDK direkt mit [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html) oder [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html) auf.
Die folgenden Code-Beispiele zeigen, wie `GetSecretValue` verwendet wird.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
"""
Purpose
Shows how to use the AWS SDK for Python (Boto3) with AWS
Secrets Manager to get a specific of secrets that match a
specified name
"""
import boto3
import logging
from get_secret_value import GetSecretWrapper
# Configure logging
logging.basicConfig(level=logging.INFO)
def run_scenario(secret_name):
"""
Retrieve a secret from AWS Secrets Manager.
:param secret_name: Name of the secret to retrieve.
:type secret_name: str
"""
try:
# Validate secret_name
if not secret_name:
raise ValueError("Secret name must be provided.")
# Retrieve the secret by name
client = boto3.client("secretsmanager")
wrapper = GetSecretWrapper(client)
secret = wrapper.get_secret(secret_name)
# Note: Secrets should not be logged.
return secret
except Exception as e:
logging.error(f"Error retrieving secret: {e}")
raise
class GetSecretWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def get_secret(self, secret_name):
"""
Retrieve individual secrets from AWS Secrets Manager using the get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param secret_name: The name of the secret fetched.
:type secret_name: str
"""
try:
get_secret_value_response = self.client.get_secret_value(
SecretId=secret_name
)
logging.info("Secret retrieved successfully.")
return get_secret_value_response["SecretString"]
except self.client.exceptions.ResourceNotFoundException:
msg = f"The requested secret {secret_name} was not found."
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred: {str(e)}.")
raise
```
# Holen Sie sich mit dem AWS Python-SDK einen Stapel geheimer Werte von Secrets Manager
Das folgende Codebeispiel zeigt, wie Sie einen Stapel geheimer Werte von Secrets Manager abrufen.
**Erforderliche Berechtigungen: **
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`Erlaubnis für jedes Geheimnis, das Sie abrufen möchten.
+ Wenn Sie Filter verwenden, müssen Sie auch `secretsmanager:ListSecrets` haben.
Ein Beispiel für eine Berechtigungsrichtlinie finden Sie unter [Beispiel: Berechtigung zum Abrufen einer Gruppe geheimer Werte in einem Batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Wichtig**
Wenn Sie über eine VPCE-Richtlinie verfügen, die die Berechtigung zum Abrufen eines einzelnen Secrets in der abgerufenen Gruppe verweigert, gibt `BatchGetSecretValue` keine Secrets-Werte zurück, und es wird ein Fehler zurückgegeben.
```
class BatchGetSecretsWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def batch_get_secrets(self, filter_name):
"""
Retrieve multiple secrets from AWS Secrets Manager using the batch_get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param filter_name: The full or partial name of secrets to be fetched.
:type filter_name: str
"""
try:
secrets = []
response = self.client.batch_get_secret_value(
Filters=[{"Key": "name", "Values": [f"{filter_name}"]}]
)
for secret in response["SecretValues"]:
secrets.append(json.loads(secret["SecretString"]))
if secrets:
logger.info("Secrets retrieved successfully.")
else:
logger.info("Zero secrets returned without error.")
return secrets
except self.client.exceptions.ResourceNotFoundException:
msg = f"One or more requested secrets were not found with filter: {filter_name}"
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred:\n{str(e)}.")
raise
```
# Holen Sie sich einen geheimen Wert von Secrets Manager mit .NET
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.
**Topics**
+ [Rufen Sie mithilfe von.NET mit clientseitigem Caching einen geheimen Wert von Secrets Manager ab](retrieving-secrets_cache-net.md)
+ [Holen Sie sich einen geheimen Wert von Secrets Manager mit dem SDK für .NET](retrieving-secrets-net-sdk.md)
# Rufen Sie mithilfe von.NET mit clientseitigem Caching einen geheimen Wert von Secrets Manager ab
Wenn Sie ein Secret abrufen, können Sie die .NET-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-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL), und Sie können [den Secret-Abruf anbinden](retrieving-secrets_cache-net-ISecretCacheHook.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:
+ .NET Framework ab Version 4.6.2 oder .NET Standard aber Version 2.0. Siehe [Download von .NET](https://dotnet.microsoft.com/en-us/download) auf der Microsoft-Website.
+ Das AWS SDK for .NET. Siehe [AWS SDKs](asm_access.md#asm-sdks).
Informationen zum Herunterladen des Quellcodes finden Sie unter [Caching-Client für .NET](https://github.com/aws/aws-secretsmanager-caching-net ) auf GitHub.
Um den Cache zu verwenden, instanziieren Sie ihn zuerst und rufen Sie dann Ihr Secret mit `GetSecretString` oder `GetSecretBinary` auf. Bei aufeinanderfolgenden Abrufen gibt der Cache die gecachete Kopie des Secrets zurück.
**Tun Sie Folgendes, um das Caching-Paket zu erhalten**
+ Führen Sie eine der folgenden Aktionen aus:
+ Führen Sie den folgenden .NET-CLI-Befehl in Ihrem Projektverzeichnis aus.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Fügen Sie die folgende Paketreferenz zu Ihrer `.csproj`-Datei hinzu.
```
```
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)
+ [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
**Example Ein Secret abrufen**
Das folgende Codebeispiel zeigt eine Methode, die ein Geheimnis mit dem Namen abruft. *MySecret*
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName ="MySecret";
private SecretsManagerCache cache = new SecretsManagerCache();
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string MySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
**Example Konfigurieren der Aktualisierungsdauer von Time to Live (TTL)-Caches**
Das folgende Codebeispiel zeigt eine Methode, die ein Geheimnis mit dem Namen abruft *MySecret* und die Aktualisierungsdauer des TTL-Caches auf 24 Stunden festlegt.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName = "MySecret";
private static SecretCacheConfiguration cacheConfiguration = new SecretCacheConfiguration
{
CacheItemTTL = 86400000
};
private SecretsManagerCache cache = new SecretsManagerCache(cacheConfiguration);
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string mySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
# SecretsManagerCache
Ein In-Memory-Cache für von Secrets Manager angeforderte Secrets. Sie verwenden [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) oder [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary), um ein Secret aus dem Cache abzurufen. Sie können die Cache-Einstellungen konfigurieren, indem Sie ein [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)-Objekt im Konstruktor übergeben.
Weitere Informationen hierzu einschließlich Beispielen finden Sie unter [Rufen Sie mithilfe von.NET mit clientseitigem Caching einen geheimen Wert von Secrets Manager ab](retrieving-secrets_cache-net.md).
## Konstruktoren
`public SecretsManagerCache()`
Standardkonstruktor für ein `SecretsManagerCache`-Objekt.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Konstruiert einen neuen Cache mit einem Secrets-Manager-Manager-Client, der mit dem bereitgestellten [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.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.
**Parameters**
secretsManager
Die [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html), aus der Geheimnisse abgerufen werden sollen.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Konstruiert einen neuen Secret-Cache mit dem bereitgestellten [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md). Verwenden Sie diesen Konstruktor, um den Cache zu konfigurieren, z. B. die Anzahl der zu cachenden Secrets und wie oft er aktualisiert wird.
**Parameters**
config
Eine [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md), die Konfigurationsinformationen für den Cache enthält.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Konstruiert einen neuen Cache mit einem Secrets Manager Manager-Client, der mit dem bereitgestellten [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)und einem [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) 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 und den Cache zu konfigurieren, z. B. die Anzahl der zu cachenden Secrets und wie oft er aktualisiert wird.
**Parameters**
secretsManager
Der [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html), aus dem Geheimnisse abgerufen werden sollen.
config
Eine [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md), die Konfigurationsinformationen für den Cache enthält.
## Methoden
### GetSecretString
`public async Task GetSecretString(String secretId)`
Ruft ein String-Secret von Secrets Manager ab.Parameters
secretId
Der ARN oder Name des abzurufenden Secrets.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Ruft ein binäres Secret von Secrets Manager ab.Parameters
secretId
Der ARN oder Name des abzurufenden Secrets.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Fordert den Secret-Wert von Secrets Manager an und aktualisiert den Cache mit allen Änderungen. Wenn kein Cache-Eintrag vorhanden ist, wird ein neuer erstellt. Gibt `true` zurück, wenn die Aktualisierung erfolgreich ist.Parameters
secretId
Der ARN oder Name des abzurufenden Secrets.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Gibt den Cache-Eintrag für das angegebene Secrets zurück, falls er im Cache vorhanden ist. Andernfalls wird das Secret aus Secrets Manager abgerufen und ein neuer Cache-Eintrag erstellt.Parameters
secretId
Der ARN oder Name des abzurufenden Secrets.
# SecretCacheConfiguration
Cache-Konfigurationsoptionen für einen [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), z. B. maximale Cachegröße und Time to Live (TTL) für gecachete Secrets.
## Eigenschaften
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
Die TTL eines Cache-Elements in Millisekunden. Die Standardeinstellung ist `3600000` ms oder 1 Stunde. Das Maximum ist `4294967295` ms, was ungefähr 49,7 Tagen entspricht.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
Die maximale Cachegröße. Der Standardwert ist 1 024 Secrets. Der Höchstwert ist 65,535.
### VersionStage
`public string VersionStage { get; set; }`
Die Version der Secrets, das Sie cachen möchten. Weitere Informationen hierzu finden Sie unter [Secret-Versionen](whats-in-a-secret.md#term_version). Der Standardwert ist `"AWSCURRENT"`.
### Client
`public IAmazonSecretsManager Client { get; set; }`
Das [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html), aus dem Geheimnisse abgerufen werden sollen. Wenn er `null` ist, instanziiert der Cache einen neuen Client. Der Standardwert ist `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
Ein [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
# ISecretCacheHook
Eine Schnittstelle für das Anbinden eines [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), um Aktionen mit dem im Cache gespeicherten Secret durchzuführen.
## Methoden
### Put
`object Put(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(object cachedObject);`
Leitet das Objekt aus dem gecacheten Objekt ab.
Gibt das Objekt zurück, das vom Cache zurückgegeben werden soll.
# Holen Sie sich einen geheimen Wert von Secrets Manager mit dem SDK für .NET
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.
Verwenden Sie für .NET-Anwendungen die [Secrets-Manager-.NET-basierte Caching-Komponente](retrieving-secrets_cache-net.md) oder rufen Sie das SDK direkt mit [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) oder [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html) auf.
Die folgenden Code-Beispiele zeigen, wie `GetSecretValue` verwendet wird.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
///
/// This example uses the Amazon Web Service Secrets Manager to retrieve
/// the secret value for the provided secret name.
///
public class GetSecretValue
{
///
/// The main method initializes the necessary values and then calls
/// the GetSecretAsync and DecodeString methods to get the decoded
/// secret value for the secret named in secretName.
///
public static async Task Main()
{
string secretName = "<<{{MySecretName}}>>";
string secret;
IAmazonSecretsManager client = new AmazonSecretsManagerClient();
var response = await GetSecretAsync(client, secretName);
if (response is not null)
{
secret = DecodeString(response);
if (!string.IsNullOrEmpty(secret))
{
Console.WriteLine($"The decoded secret value is: {secret}.");
}
else
{
Console.WriteLine("No secret value was returned.");
}
}
}
///
/// Retrieves the secret value given the name of the secret to
/// retrieve.
///
/// The client object used to retrieve the secret
/// value for the given secret name.
/// The name of the secret value to retrieve.
/// The GetSecretValueReponse object returned by
/// GetSecretValueAsync.
public static async Task GetSecretAsync(
IAmazonSecretsManager client,
string secretName)
{
GetSecretValueRequest request = new GetSecretValueRequest()
{
SecretId = secretName,
VersionStage = "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified.
};
GetSecretValueResponse response = null;
// For the sake of simplicity, this example handles only the most
// general SecretsManager exception.
try
{
response = await client.GetSecretValueAsync(request);
}
catch (AmazonSecretsManagerException e)
{
Console.WriteLine($"Error: {e.Message}");
}
return response;
}
///
/// Decodes the secret returned by the call to GetSecretValueAsync and
/// returns it to the calling program.
///
/// A GetSecretValueResponse object containing
/// the requested secret value returned by GetSecretValueAsync.
/// A string representing the decoded secret value.
public static string DecodeString(GetSecretValueResponse response)
{
// Decrypts secret using the associated AWS Key Management Service
// Customer Master Key (CMK.) Depending on whether the secret is a
// string or binary value, one of these fields will be populated.
if (response.SecretString is not null)
{
var secret = response.SecretString;
return secret;
}
else if (response.SecretBinary is not null)
{
var memoryStream = response.SecretBinary;
StreamReader reader = new StreamReader(memoryStream);
string decodedBinarySecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(reader.ReadToEnd()));
return decodedBinarySecret;
}
else
{
return string.Empty;
}
}
}
```
# Holen Sie sich mit Go einen geheimen Wert für Secrets Manager
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.
**Topics**
+ [Rufen Sie mithilfe von Go mit clientseitigem Caching einen geheimen Wert für Secrets Manager ab](retrieving-secrets_cache-go.md)
+ [Holen Sie sich mit dem Go AWS SDK einen geheimen Wert für Secrets Manager](retrieving-secrets-go-sdk.md)
# Rufen Sie mithilfe von Go mit clientseitigem Caching einen geheimen Wert für Secrets Manager ab
Wenn Sie ein Secret abrufen, können Sie die Go-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-go_CacheConfig.md), und Sie können [den Secret-Abruf anbinden](retrieving-secrets_cache-go_CacheHook.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:
+ AWS SDK for Go. Siehe [AWS SDKs](asm_access.md#asm-sdks).
Um den Quellcode herunterzuladen, siehe [Secrets Manager Go Caching-Client](https://github.com/aws/aws-secretsmanager-caching-go ) auf GitHub.
Informationen zum Einrichten einer Go-Entwicklungsumgebung finden Sie unter [Golang – Erste Schritte](https://golang.org/doc/install) auf der Website der Go-Programmiersprache.
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [Typ CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [Typ CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Ein Secret abrufen**
Das folgende Codebeispiel zeigt eine Lambda-Funktion, die ein Secret abruft.
```
package main
import (
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-secretsmanager-caching-go/secretcache"
)
var (
secretCache, _ = secretcache.New()
)
func HandleRequest(secretId string) string {
result, _ := secretCache.GetSecretString(secretId)
// Use the secret, return success
}
func main() {
lambda. Start( HandleRequest)
}
```
# type Cache
Ein In-Memory-Cache für von Secrets Manager angeforderte Secrets. Sie verwenden [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) oder [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary), um ein Secret aus dem Cache abzurufen.
Im folgenden Beispiel wird veranschaulicht, wie Sie die Cache-Einstellungen konfigurieren.
```
// Create a custom secretsmanager client
client := getCustomClient()
// Create a custom CacheConfig struct
config := secretcache. CacheConfig{
MaxCacheSize: secretcache.DefaultMaxCacheSize + 10,
VersionStage: secretcache.DefaultVersionStage,
CacheItemTTL: secretcache.DefaultCacheItemTTL,
}
// Instantiate the cache
cache, _ := secretcache.New(
func( c *secretcache.Cache) { c. CacheConfig = config },
func( c *secretcache.Cache) { c. Client = client },
)
```
Weitere Informationen hierzu einschließlich Beispielen finden Sie unter [Rufen Sie mithilfe von Go mit clientseitigem Caching einen geheimen Wert für Secrets Manager ab](retrieving-secrets_cache-go.md).
## Methoden
### Neu
`func New(optFns ...func(*Cache)) (*Cache, error)`
„Neu“ konstruiert einen Secret-Cache mit Funktionsoptionen, verwendet ansonsten Standardwerte. Initialisiert einen SecretsManager Client aus einer neuen Sitzung. Initialisiert CacheConfig auf Standardwerte. Initialisiert LRU-Cache mit einer maximalen Standardgröße.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString ruft den geheimen Zeichenkettenwert aus dem Cache für die angegebene geheime ID ab. Gibt die geheime Zeichenfolge und einen Fehler zurück, wenn der Vorgang fehlgeschlagen ist.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage ruft den geheimen Zeichenkettenwert aus dem Cache für die angegebene geheime ID und die angegebene [Versionsstufe](whats-in-a-secret.md#term_version) ab. Gibt die geheime Zeichenfolge und einen Fehler zurück, wenn der Vorgang fehlgeschlagen ist.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary ruft den geheimen Binärwert aus dem Cache für die angegebene geheime ID ab. Gibt den Secret-Binärwert und einen Fehler zurück, wenn der Vorgang fehlgeschlagen ist.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage ruft den geheimen Binärwert aus dem Cache für die angegebene geheime ID und [Versionsstufe](whats-in-a-secret.md#term_version) ab. Gibt den Secret-Binärwert und einen Fehler zurück, wenn der Vorgang fehlgeschlagen ist.
# Typ CacheConfig
Cache-Konfigurationsoptionen für ein [Cache](retrieving-secrets_cache-go_cache.md), z. B. maximale Cachegröße, Standard-[Versionsstufe](whats-in-a-secret.md#term_version) und Time to Live (TTL) für gecachete Secrets.
```
type CacheConfig struct {
// The maximum cache size. The default is 1024 secrets.
MaxCacheSize int
// The TTL of a cache item in nanoseconds. The default is
// 3.6e10^12 ns or 1 hour.
CacheItemTTL int64
// The version of secrets that you want to cache. The default
// is "AWSCURRENT".
VersionStage string
// Used to hook in-memory cache updates.
Hook CacheHook
}
```
# Typ CacheHook
Eine Schnittstelle für das Anbinden eines [Cache](retrieving-secrets_cache-go_cache.md), um Aktionen mit dem im Cache gespeicherten Secret durchzuführen.
## Methoden
### Put
`Put(data interface{}) interface{}`
Bereitet das Objekt für das Speichern im Cache vor.
### Get
`Get(data interface{}) interface{}`
Leitet das Objekt aus dem gecacheten Objekt ab.
# Holen Sie sich mit dem Go AWS SDK einen geheimen Wert für Secrets Manager
In Anwendungen können Sie Ihre Geheimnisse abrufen, indem Sie anrufen `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.
Verwenden Sie für Go-Anwendungen die [Secrets-Manager-Go-basierte Caching-Komponente](retrieving-secrets_cache-go.md) oder rufen Sie das SDK direkt mit [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue) oder [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue) auf.
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
// Use this code snippet in your app.
// If you need more information about configurations or implementing the sample code, visit the AWS docs:
// https://aws.github.io/aws-sdk-go-v2/docs/getting-started/
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
func main() {
secretName := "<<{{MySecretName}}>>"
region := "<<{{MyRegionName}}>>"
config, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
if err != nil {
log.Fatal(err)
}
// Create Secrets Manager client
svc := secretsmanager.NewFromConfig(config)
input := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretName),
VersionStage: aws.String("AWSCURRENT"), // VersionStage defaults to AWSCURRENT if unspecified
}
result, err := svc.GetSecretValue(context.TODO(), input)
if err != nil {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
log.Fatal(err.Error())
}
// Decrypts secret using the associated KMS key.
var secretString string = *result.SecretString
// Your code goes here.
}
```
# Holen Sie sich mit Rust einen geheimen Wert für Secrets Manager
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.
**Topics**
+ [Holen Sie sich einen geheimen Wert für Secrets Manager mithilfe von Rust mit clientseitigem Caching](retrieving-secrets_cache-rust.md)
+ [Holen Sie sich mit dem Rust AWS SDK einen geheimen Wert für Secrets Manager](retrieving-secrets-rust-sdk.md)
# Holen Sie sich einen geheimen Wert für Secrets Manager mithilfe von Rust mit clientseitigem Caching
Wenn Sie ein Geheimnis abrufen, können Sie es mit der Rust-basierten Caching-Komponente von Secrets Manager zwischenspeichern, um es für die future Verwendung zwischenzuspeichern. 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 lautet First In First Out (FIFO). Wenn der Cache also ein Geheimnis verwerfen muss, verwirft er das älteste Geheimnis. Standardmäßig aktualisiert der Cache Secrets jede Stunde. Sie können Folgendes konfigurieren:
+ `max_size`— Die maximale Anzahl zwischengespeicherter Geheimnisse, die aufbewahrt werden müssen, bevor Geheimnisse gelöscht werden, auf die in letzter Zeit nicht zugegriffen wurde.
+ `ttl`— Die Dauer, für die ein zwischengespeichertes Objekt als gültig angesehen wird, bevor eine Aktualisierung des geheimen Zustands erforderlich ist.
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. die Verschlüsselung von Elementen im Cache, verwenden Sie die bereitgestellten Eigenschaften, um den Cache zu ändern.
Um die Komponente verwenden zu können, benötigen Sie eine Rust 2021-Entwicklungsumgebung mit`tokio`. Weitere Informationen finden Sie unter [Erste Schritte](https://www.rust-lang.org/learn/get-started) auf der Website der Programmiersprache Rust.
Informationen zum Herunterladen des Quellcodes finden Sie unter [Secrets Manager Rust-basierte Caching-Client-Komponente](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) auf. GitHub
Verwenden Sie den folgenden Befehl, um die Caching-Komponente zu installieren.
```
cargo add aws_secretsmanager_caching
```
**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).
**Example Ein Secret abrufen**
Das folgende Beispiel zeigt, wie der geheime Wert für ein Secret mit dem Namen *MyTest* abgerufen wird.
```
use aws_secretsmanager_caching::SecretsManagerCachingClient;
use std::num::NonZeroUsize;
use std::time::Duration;
let client = match SecretsManagerCachingClient::default(
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = match client.get_secret_value("MyTest", None, None).await {
Ok(s) => s.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
**Example Cache mit einer benutzerdefinierten Konfiguration und einem benutzerdefinierten Client instanziieren**
Das folgende Beispiel zeigt, wie Sie den Cache konfigurieren und dann den geheimen Wert für ein Geheimnis mit dem Namen abrufen. *MyTest*
```
let config = aws_config::load_defaults(BehaviorVersion::latest())
.await
.into_builder()
.region(Region::from_static("us-west-2"))
.build();
let asm_builder = aws_sdk_secretsmanager::config::Builder::from(&config);
let client = match SecretsManagerCachingClient::from_builder(
asm_builder,
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = client
.get_secret_value("MyTest", None, None)
.await
{
Ok(c) => c.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
```
# Holen Sie sich mit dem Rust AWS SDK einen geheimen Wert für Secrets Manager
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.
Verwenden Sie für [Rust-Anwendungen die auf Rust basierende Caching-Komponente von Secrets Manager](retrieving-secrets_cache-rust.md) oder rufen Sie das [SDK direkt](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) mit oder auf. GetSecretValue BatchGetSecretValue
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
async fn show_secret(client: &Client, name: &str) -> Result<(), Error> {
let resp = client.get_secret_value().secret_id(name).send().await?;
println!("Value: {}", resp.secret_string().unwrap_or("No value!"));
Ok(())
}
```
# Verwenden Sie AWS Secrets Manager Geheimnisse in Amazon Elastic Kubernetes Service
Um Secrets from AWS Secrets Manager (ASCP) als in Amazon EKS-Pods gemountete Dateien anzuzeigen, können Sie den AWS Secrets and Configuration Provider für den Kubernetes Secrets Store CSI-Treiber verwenden. Das ASCP funktioniert mit Amazon Elastic Kubernetes Service 1.17\$1, auf dem eine Amazon EC2 EC2-Knotengruppe ausgeführt wird. AWS Fargate Knotengruppen werden nicht unterstützt. Mit dem ASCP können Sie Ihre Secrets in Secrets Manager speichern und verwalten und diese dann über Ihre auf Amazon EKS ausgeführten Workloads abrufen. Wenn Ihr Secret mehrere Schlüssel-Wert-Paare im JSON-Format enthält, können Sie wählen, welche in Amazon EKS bereitgestellt werden sollen. ASCP verwendet JMESPath-Syntax, um die Schlüssel-Wert-Paare in Ihrem Secret abzufragen. Der ASCP funktioniert auch mit Parametern des Parameter-Speichers. ASCP bietet zwei Authentifizierungsmethoden mit Amazon EKS. Der erste Ansatz verwendet IAM Roles for Service Accounts (IRSA). Der zweite Ansatz verwendet Pod Identities. Jeder Ansatz hat eigene Vorteile und Anwendungsfälle.
## ASCP mit IAM Roles for Service Accounts (IRSA)
Das ASCP mit IAM-Rollen für Servicekonten (IRSA) ermöglicht es Ihnen, Geheimnisse AWS Secrets Manager als Dateien in Ihren Amazon EKS-Pods zu mounten. Dieser Ansatz ist für folgende Szenarien geeignet:
+ Sie müssen Geheimnisse als Dateien in Ihren Pods bereitstellen.
+ Sie verwenden Amazon-EKS-Version 1.17 oder höher mit Amazon-EC2-Knotengruppen.
+ Sie möchten bestimmte Schlüssel-Wert-Paare aus JSON-formatierten Geheimnissen abrufen.
Weitere Informationen finden Sie unter [Verwenden Sie AWS Secrets and Configuration Provider CSI mit IAM-Rollen für Dienstkonten (IRSA)](integrating_ascp_irsa.md).
## ASCP mit Pod Identity
Die ASCP-Methode mit Pod Identity verbessert die Sicherheit und vereinfacht die Konfiguration für den Zugriff auf geheime Daten in Amazon EKS. Dieser Ansatz bietet Vorteile in folgenden Szenarien:
+ Sie benötigen eine detailliertere Berechtigungsverwaltung auf Pod-Ebene.
+ Sie verwenden Amazon-EKS-Version 1.24 oder höher.
+ Sie benötigen eine höhere Leistung und Skalierbarkeit.
Weitere Informationen finden Sie unter [Verwenden Sie AWS Secrets and Configuration Provider CSI mit Pod Identity für Amazon EKS](ascp-pod-identity-integration.md).
## Den richtigen Ansatz wählen
Bei der Entscheidung zwischen ASCP mit IRSA und ASCP mit Pod Identity sollten Sie die folgenden Faktoren berücksichtigen:
+ Amazon EKSversion: Pod Identity erfordert Amazon EKS 1.24\$1, während der CSI-Treiber mit Amazon EKS 1.17\$1 funktioniert.
+ Sicherheitsanforderungen: Pod Identity bietet eine detailliertere Kontrolle auf Pod-Ebene.
+ Leistung: Pod Identity schneidet in umfassenden Umgebungen im Allgemeinen besser ab.
+ Komplexität: Pod Identity vereinfacht die Einrichtung, da keine separaten Servicekonten erforderlich sind.
Wählen Sie die Methode, die am besten zu Ihren spezifischen Anforderungen und Ihrer Amazon-EKS-Umgebung passt.
# Installieren von ASCP für Amazon EKS
In diesem Abschnitt wird erklärt, wie Sie den AWS Secrets and Configuration Provider für Amazon EKS installieren. Mit ASCP können Sie Geheimnisse aus Secrets Manager und Parameter aus AWS Systems Manager Dateien in Amazon EKS Pods bereitstellen.
## Voraussetzungen
+ Ein Amazon-EKS-Cluster
+ Version 1.24 oder höher für Pod Identity
+ Version 1.17 oder höher für IRSA
+ Das AWS CLI installierte und konfigurierte
+ kubectl, für Ihren Amazon-EKS-Cluster installiert und konfiguriert
+ Helm (Version 3.0 oder höher)
## Installieren und Konfigurieren von ASCP
Das ASCP ist GitHub im [secrets-store-csi-provider-aws-Repository verfügbar.](https://github.com/aws/secrets-store-csi-driver-provider-aws) Das Repo enthält auch YAML-Beispieldateien zum Erstellen und Mounten eines Secrets.
Während der Installation können Sie festlegen, dass ASCP einen FIPS-Endpunkt verwenden soll. Eine Liste der Endpunkte finden Sie unter [AWS Secrets Manager Endpunkte](asm_access.md#endpoints).
**Um das ASCP als EKS-Add-on zu installieren**
1. Installation `eksctl` ([Installationsanweisungen](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Führen Sie den folgenden Befehl aus, um das Add-on mit der [Standardkonfiguration](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml) zu installieren:
```
eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider
```
Wenn Sie das Add-on konfigurieren möchten, führen Sie stattdessen den folgenden Installationsbefehl aus:
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
Die Konfigurationsdatei kann eine YAML- oder JSON-Datei sein. Um das Konfigurationsschema für das Add-on zu sehen:
1. Führen Sie den folgenden Befehl aus und notieren Sie sich die neueste Version des Add-ons:
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Führen Sie den folgenden Befehl aus, um das Konfigurationsschema des Add-ons anzuzeigen, und `` ersetzen Sie es durch die Version aus dem vorherigen Schritt:
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Installieren Sie ASCP mit Helm wie folgt:**
1. Um sicherzustellen, dass das Repository auf die neuesten Diagramme verweist, verwenden Sie `helm repo update.`.
1. Installieren Sie das Diagramm. Das Folgende ist ein Beispiel für den `helm install` Befehl:
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Um einen FIPS-Endpunkt zu verwenden, fügen Sie das folgende Flag hinzu: `--set useFipsEndpoint=true`.
1. Um die Drosselung zu konfigurieren, fügen Sie das folgende Flag hinzu: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`.
1. Wenn der Secrets Store CSI Driver bereits auf Ihrem Cluster installiert ist, fügen Sie das folgende Flag hinzu:`--set secrets-store-csi-driver.install=false`. Dadurch wird die Installation des Secrets Store CSI-Treibers als Abhängigkeit übersprungen.
**Installieren Sie ASCP mit YAML im Repository wie folgt:**
+ Verwenden Sie die folgenden Befehle.
```
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml
```
## Überprüfen der Installationen
Gehen Sie folgendermaßen vor, um die Installationen Ihres EKS-Clusters, des Secrets Store CSI-Treibers und des ASCP-Plug-ins zu überprüfen:
1. Den EKS-Cluster überprüfen:
```
eksctl get cluster --name clusterName
```
Dieser Befehl muss Informationen zu Ihrem Cluster zurückgeben.
1. Die Secrets-Store-CSI-Treiberinstallation überprüfen:
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
Sie sollten ausgeführte Pods mit Namen wie `csi-secrets-store-secrets-store-csi-driver-xxx` sehen.
1. Die ASCP-Plugin-Installation überprüfen:
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Beispielausgabe:
```
NAME READY STATUS RESTARTS AGE
csi-secrets-store-provider-aws-12345 1/1 Running 0 2m
```
------
#### [ Helm installation ]
```
$ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws
```
Beispielausgabe:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
Sie sollten Pods im Status `Running` sehen.
Wenn nach dem Ausführen dieser Befehle alles korrekt eingerichtet ist, sollten alle Komponenten fehlerfrei ausgeführt werden. Wenn Sie auf Probleme stoßen, müssen Sie diese möglicherweise beheben, indem Sie die Protokolle der jeweiligen Pods überprüfen, bei denen Probleme auftreten.
## Fehlerbehebung
1. Führen Sie folgenden Befehl aus, um die Protokolle des ASCP-Anbieters zu überprüfen:
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Überprüfen Sie den Status aller Pods im `kube-system` Namespace:
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Alle Pods, die sich auf den CSI-Treiber und ASCP beziehen, sollten sich im Status „In Ausführung“ befinden.
1. Die Version des CSI-Treibers überprüfen:
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Dieser Befehl muss Informationen zu dem installierten CSI-Treiber zurückgeben.
## Weitere Ressourcen
Weitere Informationen zur Verwendung von ASCP mit Amazon EKS finden Sie in den folgenden Ressourcen:
+ [Verwenden von Pod Identity mit Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Secrets Store CSI-Treiber aktiviert GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Verwenden Sie AWS Secrets and Configuration Provider CSI mit Pod Identity für Amazon EKS
Die AWS Secrets and Configuration Provider-Integration mit dem Pod Identity Agent für Amazon Elastic Kubernetes Service bietet verbesserte Sicherheit, vereinfachte Konfiguration und verbesserte Leistung für Anwendungen, die auf Amazon EKS ausgeführt werden. Pod Identity vereinfacht die IAM-Authentifizierung für Amazon EKS beim Abrufen von Geheimnissen aus Secrets Manager oder Parametern aus dem AWS Systems Manager Parameter Store.
Amazon EKS Pod Identity optimiert die Konfiguration von IAM-Berechtigungen für Kubernetes-Anwendungen, da Berechtigungen direkt über Amazon-EKS-Schnittstellen eingerichtet werden können. Das reduziert die Anzahl der Schritte und der Wechsel zwischen Amazon EKS und IAM-Services entfällt. Pod Identity ermöglicht die Verwendung einer einzigen IAM-Rolle in mehreren Clustern, ohne dass die Vertrauensrichtlinien aktualisiert werden müssen, und unterstützt [Rollensitzungs-Tags](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) für eine detailliertere Zugriffskontrolle. Dieser Ansatz vereinfacht nicht nur die Richtlinienverwaltung, indem er die rollenübergreifende Wiederverwendung von Berechtigungsrichtlinien ermöglicht, sondern erhöht auch die Sicherheit, indem der Zugriff auf AWS Ressourcen auf der Grundlage übereinstimmender Tags ermöglicht wird.
## Funktionsweise
1. Pod Identity weist dem Pod eine IAM-Rolle zu.
1. ASCP verwendet diese Rolle zur Authentifizierung bei. AWS-Services
1. Falls autorisiert, ruft ASCP die angeforderten Geheimnisse ab und stellt sie dem Pod zur Verfügung.
Weitere Informationen finden Sie im *Benutzerhandbuch für Amazon EKS* unter [Funktionsweise von Amazon EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html).
## Voraussetzungen
**Wichtig**
Pod Identity wird nur für Amazon EKS in der Cloud unterstützt. Es wird nicht für [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), [Red Hat OpenShift Service in AWS](https://aws.amazon.com/rosa/) oder selbstverwaltete Kubernetes-Cluster auf Amazon-EC2-Instances unterstützt.
+ Amazon-EKS-Cluster (Version 1.24 oder höher)
+ Zugriff auf AWS CLI einen Amazon EKS-Cluster über `kubectl`
+ Zugriff auf zwei AWS-Konten (für kontoübergreifenden Zugriff)
## Installieren des Pod-Identity-Agents für Amazon EKS
Um Pod Identity in Ihrem Cluster zu verwenden, müssen Sie das Add-on „Amazon EKS Pod Identity Agent“ installieren.
**Installieren des Pod-Identity-Agents**
+ Installieren Sie das Pod Identity Agent-Add-on auf Ihrem Cluster:
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Einrichten von ASCP mit Pod Identity
1. Erstellen Sie eine Berechtigungsrichtlinie, die Zugriff auf die Geheimnisse gewährt`secretsmanager:GetSecretValue`, auf die der Pod zugreifen muss. `secretsmanager:DescribeSecret` Eine Beispielrichtlinie finden Sie unter [Beispiel: Erlaubnis, einzelne Geheimnisse zu lesen und zu beschreiben](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Erstellen Sie eine IAM-Rolle, die vom Amazon-EKS-Service-Prinzipalen für Pod Identity übernommen werden kann:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Hängen Sie die IAM-Richtlinie an die Rolle an:
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Erstellen Sie eine Pod-Identity-Zuordnung. Ein Beispiel finden Sie unter [Erstellen einer Pod-Identity-Zuordnung](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) im *Benutzerhandbuch für Amazon EKS*
1. Erstellen Sie das`SecretProviderClass`, das festlegt, welche Geheimnisse im Pod bereitgestellt werden sollen:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
Der Hauptunterschied in `SecretProviderClass` zwischen IRSA und Pod Identity ist der optionale Parameter `usePodIdentity`. Es ist ein optionales Feld, das den Authentifizierungsansatz bestimmt. Wenn nicht angegeben, wird standardmäßig IAM Roles for Service Accounts (IRSA) verwendet.
+ Verwenden Sie einen der folgenden Werte, um EKS Pod Identity zu verwenden: `"true", "True", "TRUE", "t", "T"`.
+ Wenn Sie explizit IRSA nutzen möchten, verwenden Sie einen der folgenden Werte: `"false", "False", "FALSE", "f", or "F"`.
1. Stellen Sie den Pod, der die Secrets mountet, bereit unter`/mnt/secrets-store`:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Wenn Sie einen privaten Amazon EKS-Cluster verwenden, stellen Sie sicher, dass die VPC, in der sich der Cluster befindet, über einen AWS STS Endpunkt verfügt. Weitere Informationen zum Erstellen eines Endpunktes finden Sie unter [Schnittstellen-VPC-Endpunkte](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) im *Benutzerhandbuch für AWS Identity and Access Management *.
### Überprüfen des Secret-Mountings
Führen Sie den folgenden Befehl aus, um zu überprüfen, ob der geheime Schlüssel ordnungsgemäß bereitgestellt wurde:
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**So richten Sie Amazon EKS Pod Identity für den Zugriff auf Secrets Manager ein**
1. Erstellen Sie eine Berechtigungsrichtlinie, die Zugriff auf die Geheimnisse gewährt`secretsmanager:GetSecretValue`, auf die der Pod zugreifen muss. `secretsmanager:DescribeSecret` Eine Beispielrichtlinie finden Sie unter [Beispiel: Erlaubnis, einzelne Geheimnisse zu lesen und zu beschreiben](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Erstellen Sie ein Geheimnis in Secrets Manager, falls Sie noch keines haben.
## Fehlerbehebung
Sie können die meisten Fehler anzeigen, indem Sie die Pod-Bereitstellung beschreiben.
**Fehlermeldungen für Ihren Container anzeigen**
1. Rufen Sie mit dem folgenden Befehl eine Liste der Pod-Namen ab. Wenn Sie nicht den Standard-Namespace verwenden, verwenden Sie `-n NAMESPACE`.
```
kubectl get pods
```
1. Um den Pod zu beschreiben, *PODID* verwenden Sie im folgenden Befehl die Pod-ID der Pods, die Sie im vorherigen Schritt gefunden haben. Wenn Sie nicht den Standard-Namespace verwenden, verwenden Sie `-n NAMESPACE`.
```
kubectl describe pod/PODID
```
**Fehler für den ASCP anzeigen**
+ Um weitere Informationen in den Anbieterprotokollen zu finden, *PODID* verwenden Sie im folgenden Befehl die ID des Pods *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Verwenden Sie AWS Secrets and Configuration Provider CSI mit IAM-Rollen für Dienstkonten (IRSA)
**Topics**
+ [Voraussetzungen](#prerequisites)
+ [Einrichten der Zugriffssteuerung](#integrating_ascp_irsa_access)
+ [Identifizieren der Secrets, die gemountet werden sollen](#integrating_ascp_irsa_mount)
+ [Fehlerbehebung](#integrating_ascp_irsa_trouble)
## Voraussetzungen
+ Amazon-EKS-Cluster (Version 1.17 oder höher)
+ Zugriff auf AWS CLI einen Amazon EKS-Cluster über `kubectl`
## Einrichten der Zugriffssteuerung
ASCP ruft die Amazon-EKS-Pod-Identität ab und tauscht sie gegen eine IAM-Rolle. Sie legen in einer IAM-Richtlinie Berechtigungen für diese IAM-Rolle fest. Wenn das ASCP die IAM-Rolle übernimmt, erhält es Zugriff auf die von Ihnen autorisierten Geheimnisse. Andere Container können nur auf die Secrets zugreifen, wenn Sie diese auch der IAM-Rolle zuordnen.
**So gewähren Sie Ihrem Amazon EKS Pod Zugriff auf Geheimnisse in Secrets Manager**
1. Erstellen Sie eine Berechtigungsrichtlinie, die Zugriff auf die Geheimnisse gewährt`secretsmanager:GetSecretValue`, auf die der Pod zugreifen muss. `secretsmanager:DescribeSecret` Eine Beispielrichtlinie finden Sie unter [Beispiel: Erlaubnis, einzelne Geheimnisse zu lesen und zu beschreiben](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Erstellen Sie einen IAM OpenID Connect (OIDC)-Anbieter für den Cluster, wenn Sie noch keinen haben. Weitere Informationen finden Sie unter [Erstellen eines IAM-OIDC-Anbieters für Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) im *Benutzerhandbuch für Amazon EKS*.
1. Erstellen Sie eine [IAM-Rolle für das Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) und fügen Sie die Richtlinie an. Weitere Informationen finden Sie unter [Erstellen einer IAM-Rolle für ein Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) im *Benutzerhandbuch für Amazon EKS*.
1. Wenn Sie einen privaten Amazon EKS-Cluster verwenden, stellen Sie sicher, dass die VPC, in der sich der Cluster befindet, über einen AWS STS Endpunkt verfügt. Weitere Informationen zum Erstellen eines Endpunktes finden Sie unter [Schnittstellen-VPC-Endpunkte](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) im *Benutzerhandbuch für AWS Identity and Access Management *.
## Identifizieren der Secrets, die gemountet werden sollen
Um zu bestimmen, welche Secrets der ASCP in Amazon EKS als Dateien im Dateisystem bereitstellt, erstellen Sie eine [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass)-YAML-Datei. Die `SecretProviderClass` listet die Secrets auf, die gemountet werden sollen, und den Dateinamen, unter dem sie bereitgestellt werden sollen. `SecretProviderClass` muss sich im gleichen Namespace wie der Amazon-EKS-Pod befinden, auf den verwiesen wird.
### Hängen Sie die Secrets als Dateien ein
[Die folgenden Anweisungen zeigen, wie Sie Geheimnisse mithilfe der YAML-Beispieldateien .yaml und [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml) als Dateien einhängen. ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)
**So hängen Sie Geheimnisse in Amazon EKS ein**
1. Wenden Sie die `SecretProviderClass` auf den Pod an:
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Stellen Sie den Pod bereit:
```
kubectl apply -f ExampleDeployment.yaml
```
1. ASCP mountet die Dateien.
## Fehlerbehebung
Sie können die meisten Fehler anzeigen, indem Sie die Pod-Bereitstellung beschreiben.
**Fehlermeldungen für Ihren Container anzeigen**
1. Rufen Sie mit dem folgenden Befehl eine Liste der Pod-Namen ab. Wenn Sie nicht den Standard-Namespace verwenden, verwenden Sie `-n nameSpace`.
```
kubectl get pods
```
1. Um den Pod zu beschreiben, *podId* verwenden Sie im folgenden Befehl die Pod-ID der Pods, die Sie im vorherigen Schritt gefunden haben. Wenn Sie nicht den Standard-Namespace verwenden, verwenden Sie `-n nameSpace`.
```
kubectl describe pod/podId
```
**Fehler für den ASCP anzeigen**
+ Um weitere Informationen in den Anbieterprotokollen zu finden, *podId* verwenden Sie im folgenden Befehl die ID des Pods *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Überprüfen Sie, ob die `SecretProviderClass`-CRD installiert wurde:**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Dieser Befehl muss Informationen zur benutzerdefinierten Ressourcendefinition von `SecretProviderClass` zurückgeben.
+
**Stellen Sie sicher, dass das SecretProviderClass Objekt erstellt wurde.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Codebeispiele für Secrets und Configuration Provider
## Beispiele für ASCP-Authentifizierung und Zugriffskontrolle
### Beispiel: IAM-Richtlinie, die dem Service Amazon EKS Pod Identity (pods.eks.amazonaws.com) ermöglicht, die Rolle zu übernehmen und die Sitzung zu taggen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Sie verwenden YAML, um zu beschreiben, welche Secrets mithilfe des ASCP in Amazon EKS gemountet werden sollen. Beispiele finden Sie unter [SecretProviderClass Verwendung](#ascp-scenarios-secretproviderclass).
### SecretProviderClass YAML-Struktur
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
Das Feld Parameter enthält die Details der Mounting-Anfrage:
**Region**
(Optional) Das AWS-Region Geheimnis. Wenn Sie dieses Feld nicht verwenden, sucht der ASCP die Region aus der Anmerkung auf dem Knoten. Diese Suche steigert den Overhead von Mounting-Anfragen. Daher wird empfohlen, die Region für Cluster mit einer großen Anzahl von Pods anzugeben.
Wenn Sie auch `failoverRegion` angeben, versucht der ASCP, das Secret aus beiden Regionen abzurufen. Wenn eine Region einen 4xx-Fehler zurückgibt, z. B. aufgrund eines Authentifizierungsproblems, mountet der ASCP keines der Secrets. Wenn das Secret erfolgreich von `region` abgerufen wurde, mountet der ASCP diesen Secret-Wert. Wenn das Secret nicht erfolgreich von `region` abgerufen wurde, aber efolgreich von `failoverRegion` abgerufen werden konnte, mountet der ASCP diesen Secret-Wert.
**failoverRegion**
(Optional) Wenn Sie dieses Feld angeben, versucht der ASCP, das Secret aus den Regionen abzurufen, die in `region` und diesem Feld definiert sind. Wenn eine Region einen 4xx-Fehler zurückgibt, z. B. aufgrund eines Authentifizierungsproblems, mountet der ASCP keines der Secrets. Wenn das Secret erfolgreich von `region` abgerufen wurde, mountet der ASCP diesen Secret-Wert. Wenn das Secret nicht erfolgreich von `region` abgerufen wurde, aber efolgreich von `failoverRegion` abgerufen werden konnte, mountet der ASCP diesen Secret-Wert. Ein Beispiel für die Nutzung dieses Felds finden Sie unter [Geheimes Failover für mehrere Regionen](#multi-region-failover).
**pathTranslation (Pfadangabe)**
(Optional) Ein einzelnes Ersetzungszeichen, das verwendet werden soll, wenn der Dateiname in Amazon EKS das Pfadtrennzeichen enthält, z. B. Schrägstrich (/) unter Linux. ASCP kann keine gemountete Datei erstellen, die ein Pfadtrennzeichen enthält. Stattdessen ersetzt ASCP das Pfadtrennzeichen durch ein anderes Zeichen. Wenn Sie dieses Feld nicht verwenden, ist das Ersatzzeichen ein Unterstrich (\$1), d. h. `My/Path/Secret` wird als `My_Path_Secret` gemountet.
Um die Zeichenersetzung zu verhindern, geben Sie die Zeichenfolge `False` ein.
**usePodIdentity**
(Optional) Legt den Authentifizierungsansatz fest. Wenn nicht angegeben, wird standardmäßig IAM Roles for Service Accounts (IRSA) verwendet.
+ Verwenden Sie einen der folgenden Werte, um EKS Pod Identity zu verwenden: `"true"`, `"True"`, `"TRUE"`, `"t"` oder `"T"`.
+ Wenn Sie explizit IRSA nutzen möchten, verwenden Sie einen der folgenden Werte: `"false"`, `"False"`, `"FALSE"`, `"f"` oder `"F"`.
**preferredAddressType**
(Optional) Gibt den bevorzugten IP-Adresstyp für die Pod-Identity-Agent-Endpunktkommunikation an. Das Feld ist nur bei Verwendung der EKS-Pod-Identity-Funktion relevant und wird ignoriert, wenn IAM-Roles for Service Accounts verwendet wird. Bei den Werten wird zwischen Groß- und Kleinschreibung unterschieden. Folgende sind gültige Werte:
+ `"ipv4"`, `"IPv4"` „, oder `"IPV4"` — Die Verwendung des Pod Identity IPv4 Agent-Endpunkts erzwingen
+ `"ipv6"`,`"IPv6"`, oder `"IPV6"` — Erzwingen Sie die Verwendung des Pod Identity IPv6 Agent-Endpunkts
+ nicht spezifiziert — auto Endpunktauswahl verwenden, zuerst den IPv4 Endpunkt ausprobieren und bei einem Fehler auf den IPv6 Endpunkt IPv4 zurückgreifen
**objects (Objekte)**
Eine Zeichenfolge, die eine YAML-Deklaration der bereitzustellenden Secrets enthält. Wir empfehlen, eine mehrzeilige YAML-Zeichenfolge oder ein Pipe-Zeichen (\$1) zu verwenden.
**objectName (Objektname)**
Erforderlich Gibt den Namen des Geheimnisses oder Parameters an, der abgerufen werden soll. Für Secrets Manager ist dies der Parameter [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) und kann entweder der Anzeigename oder der vollständige ARN des Secrets sein. Für SSM Parameter Store ist dies [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters)der Parameter und kann entweder der Name oder der vollständige ARN des Parameters sein.
**objectType**
Erforderlich, wenn Sie keinen Secrets Manager ARN für `objectName` verwenden. Kann `secretsmanager` oder `ssmparameter` sein.
**objectAlias (Objektalias)**
(Optional) Der Dateiname des Secrets im Amazon-EKS-Pod. Wenn Sie dieses Feld nicht angeben, wird `objectName` als Dateiname angezeigt.
**Dateiberechtigung**
(Optional) Die vierstellige Oktalzeichenfolge, die die Dateiberechtigung zum Einhängen von Secret angibt. Wenn Sie dieses Feld nicht angeben, wird standardmäßig verwendet. `"0644"`
**objectVersion (Objektversion)**
(Optional) Die Versions-ID des Secrets. Nicht empfohlen, da Sie jedes Mal, wenn Sie das Secret aktualisieren, die Versions-ID aktualisieren müssen. Standardmäßig wird die neueste Version verwendet. Wenn Sie eine `failoverRegion` angeben, stellt dieses Feld den primären `objectVersion` dar.
**objectVersionLabel**
(Optional) Der Alias für die Version. Die Standardversion ist die neueste Version AWSCURRENT. Weitere Informationen finden Sie unter [Geheime Versionen](whats-in-a-secret.md#term_version). Wenn Sie eine `failoverRegion` angeben, stellt dieses Feld den primären `objectVersionLabel` dar.
**jmesPath (jmes-Pfad)**
(Optional) Eine Zuordnung der Schlüssel im Secret zu den Dateien, die in Amazon EKS bereitgestellt werden sollen. Um dieses Feld zu verwenden, muss Ihr Secret-Wert im JSON-Format vorliegen. Wenn Sie dieses Feld verwenden, müssen Sie die Unterfelder `path` und `objectAlias` angeben.
**Pfad**
Ein Schlüssel aus einem Schlüssel-Wert-Paar im JSON des geheimen Werts. Wenn das Feld einen Bindestrich enthält, verwenden Sie einfache Anführungszeichen als Escape-Zeichen. Beispiel: `path: '"hyphenated-path"'`
**objectAlias**
Der Dateiname, der im Amazon-EKS-Pod gemountet werden soll. Wenn das Feld einen Bindestrich enthält, verwenden Sie einfache Anführungszeichen als Escape-Zeichen. Beispiel: `objectAlias: '"hyphenated-alias"'`
**Datei/Berechtigung**
(Optional) Die vierstellige Oktalzeichenfolge, die die Dateiberechtigung zum Einhängen von Secret angibt. Wenn Sie dieses Feld nicht angeben, wird standardmäßig die Dateiberechtigung des übergeordneten Objekts verwendet.
**failoverObject**
(Optional) Wenn Sie dieses Feld angeben, versucht der ASCP, sowohl das im primären `objectName` angegebene Secret als auch das im `failoverObject`-`objectName`-Unterfeld angegebene Secret abzurufen. Wenn eines von beiden einen 4xx-Fehler zurückgibt, z. B. aufgrund eines Authentifizierungsproblems, mountet der ASCP keines der Secrets. Wenn das Secret erfolgreich vom primären `objectName` abgerufen wurde, mountet der ASCP diesen Secret-Wert. Wenn das Secret nicht erfolgreich vom primären `objectName` abgerufen wurde, aber efolgreich vom Failover-`objectName` abgerufen werden konnte, mountet der ASCP diesen Secret-Wert. Wenn Sie dieses Feld angeben, müssen Sie auch das Feld `objectAlias` angeben. Ein Beispiel für die Nutzung dieses Felds finden Sie unter [Failover auf ein anderes Geheimnis](#failover-secret).
In der Regel verwenden Sie dieses Feld, wenn es sich bei dem Failover-Secret nicht um ein Replikat handelt. Ein Beispiel dazu, wie Sie ein Replikat angeben, finden Sie unter [Geheimes Failover für mehrere Regionen](#multi-region-failover).
**objectName (Objektname)**
Der Name oder vollständige ARN des Failover-Secrets. Wenn Sie einen ARN verwenden, muss die Region im ARN mit dem Feld `failoverRegion` übereinstimmen.
**objectVersion (Objektversion)**
(Optional) Die Versions-ID des Secrets. Muss mit der primären `objectVersion` übereinstimmen. Nicht empfohlen, da Sie jedes Mal, wenn Sie das Secret aktualisieren, die Versions-ID aktualisieren müssen. Standardmäßig wird die neueste Version verwendet.
**objectVersionLabel**
(Optional) Der Alias für die Version. Die Standardversion ist die neueste Version AWSCURRENT. Weitere Informationen finden Sie unter [Geheime Versionen](whats-in-a-secret.md#term_version).
### Erstellen Sie eine SecretProviderClass Basiskonfiguration, um Secrets in Ihren Amazon EKS-Pods zu mounten.
------
#### [ Pod Identity ]
SecretProviderClass um ein Geheimnis im selben Amazon EKS-Cluster zu verwenden:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets-manager
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
usePodIdentity: "true"
```
------
#### [ IRSA ]
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: deployment-aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "MySecret"
objectType: "secretsmanager"
```
------
### SecretProviderClass Verwendung
Verwenden Sie diese Beispiele, um SecretProviderClass Konfigurationen für verschiedene Szenarien zu erstellen.
#### Beispiel: Secrets nach Namen oder ARN mounten
Dieses Beispiel zeigt, wie drei verschiedene Arten von Geheimnissen bereitgestellt werden:
+ Ein durch den vollständigen ARN spezifiziertes Geheimnis
+ Ein namentlich angegebenes Geheimnis
+ Eine bestimmte Version eines Geheimnisses
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6"
- objectName: "MySecret3"
objectType: "secretsmanager"
- objectName: "MySecret4"
objectType: "secretsmanager"
objectVersionLabel: "AWSCURRENT"
```
#### Beispiel: Hängen Sie Schlüssel-Wert-Paare aus einem Secret ein
Dieses Beispiel zeigt, wie bestimmte Schlüssel-Wert-Paare aus einem Geheimnis im JSON-Format gemountet werden:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3"
jmesPath:
- path: username
objectAlias: dbusername
- path: password
objectAlias: dbpassword
```
#### Beispiel: Einhängen von Geheimnissen mit Dateiberechtigungen
Dieses Beispiel zeigt, wie ein Secret mit einer bestimmten Dateiberechtigung bereitgestellt wird
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
filePermission: "0600"
jmesPath:
- path: username
objectAlias: dbusername
filePermission: "0400"
```
#### Beispiel: verschiedene Failover-Konfigurationen
Diese Beispiele zeigen, wie ein Failover für geheime Daten konfiguriert wird.
##### Geheimes Failover für mehrere Regionen
Dieses Beispiel zeigt, wie ein automatisches Failover für ein Geheimnis konfiguriert wird, das in mehreren Regionen repliziert wird:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "MySecret"
```
##### Failover auf ein anderes Geheimnis
Dieses Beispiel zeigt, wie ein Failover auf ein anderes Geheimnis (kein Replikat) konfiguriert wird:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3"
objectAlias: "MyMountedSecret"
failoverObject:
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6"
```
## Weitere Ressourcen
Weitere Informationen zur Verwendung von ASCP mit Amazon EKS finden Sie in den folgenden Ressourcen:
+ [Verwenden von Pod Identity mit Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Verwendung von AWS Geheimnissen und Configuration Provider](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Secrets Store CSI-Treiber aktiviert GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Verwenden Sie AWS Secrets Manager Geheimnisse in AWS Lambda Funktionen
AWS Lambda ist ein serverloser Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Parameter Store, eine Funktion von AWS Systems Manager, bietet sicheren, hierarchischen Speicher für die Verwaltung von Konfigurationsdaten und Geheimnissen. Sie können die Lambda-Erweiterung AWS Parameters and Secrets verwenden, um AWS Secrets Manager Secrets und Parameter Store-Parameter in Lambda-Funktionen abzurufen und zwischenzuspeichern, ohne ein SDK zu verwenden. Ausführliche Informationen zur Verwendung dieser Erweiterung finden Sie unter [Verwenden von Secrets Manager Manager-Geheimnissen in Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) im *Lambda Developer Guide*.
## Secrets Manager Manager-Geheimnisse mit Lambda verwenden
Das Lambda Developer Guide enthält umfassende Anweisungen zur Verwendung von Secrets Manager Manager-Geheimnissen in Lambda-Funktionen. Erste Schritte:
1. Folgen Sie dem step-by-step Tutorial unter [Secrets Manager Manager-Geheimnisse in Lambda-Funktionen verwenden](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), das Folgendes beinhaltet:
+ Erstellen einer Lambda-Funktion mit Ihrer bevorzugten Laufzeit (Python, Node.js, Java)
+ Hinzufügen der Lambda-Erweiterung AWS Parameters and Secrets als Ebene
+ Konfiguration der erforderlichen Berechtigungen
+ Code schreiben, um Geheimnisse aus der Erweiterung abzurufen
+ Testen Sie Ihre Funktion
1. Erfahren Sie mehr über Umgebungsvariablen zur Konfiguration des Verhaltens der Erweiterung, einschließlich Cache-Einstellungen und Timeouts
1. Machen Sie sich mit bewährten Methoden für die Arbeit mit geheimer Rotation vertraut
### Secrets Manager und Lambda in einer VPC verwenden
Wenn Ihre Lambda-Funktion in einer VPC ausgeführt wird, müssen Sie einen VPC-Endpunkt erstellen, damit die Erweiterung Secrets Manager aufrufen kann. Weitere Informationen finden Sie unter [Verwenden eines AWS Secrets Manager VPC-Endpunkts](vpc-endpoint-overview.md).
## Verwenden der Lambda-Erweiterung AWS Parameters and Secrets
Die Erweiterung kann sowohl Secrets-Manager-Secrets als auch Parameter-Store-Parameter abrufen. Ausführliche Informationen zur Verwendung von Parameter Store-Parametern mit der Erweiterung finden Sie [unter Verwenden von Parameter Store-Parametern in Lambda-Funktionen](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) im *AWS Systems Manager Benutzerhandbuch*.
Die Systems Manager Manager-Dokumentation umfasst:
+ Ausführliche Erklärung, wie die Erweiterung mit Parameter Store funktioniert
+ Anweisungen zum Hinzufügen der Erweiterung zu einer Lambda-Funktion
+ Umgebungsvariablen für die Konfiguration der Erweiterung
+ Beispielbefehle zum Abrufen von Parametern
+ Vollständige Liste der Erweiterungen ARNs für alle unterstützten Architekturen und Regionen
# Den AWS Secrets Manager Agenten verwenden
## So funktioniert der Secrets Manager Agent
Der AWS Secrets Manager Agent ist ein clientseitiger HTTP-Dienst, mit dem Sie standardisieren können, wie Sie Secrets aus Secrets Manager in Ihren Computerumgebungen verwenden. Sie können ihn mit den folgenden Diensten verwenden:
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
Der Secrets Manager Agent ruft Secrets ab und speichert sie im Speicher, sodass Ihre Anwendungen Secrets von localhost abrufen können, anstatt Secrets Manager direkt aufzurufen. Der Secrets Manager Agent kann nur Geheimnisse lesen — er kann sie nicht ändern.
**Wichtig**
Der Secrets Manager Agent verwendet die AWS Anmeldeinformationen aus Ihrer Umgebung, um Secrets Manager aufzurufen. Es bietet Schutz vor Server Side Request Forgery (SSRF), um die Sicherheit geheimer Daten zu verbessern. Der Secrets Manager Agent verwendet standardmäßig den ML-KEM-Schlüsselaustausch nach dem Quantenverfahren als Schlüsselaustausch mit der höchsten Priorität.
## Grundlegendes zum Secrets Manager Agent-Caching
Der Secrets Manager Agent verwendet einen In-Memory-Cache, der zurückgesetzt wird, wenn der Secrets Manager Agent neu gestartet wird. Er aktualisiert in regelmäßigen Abständen zwischengespeicherte geheime Werte auf der Grundlage der folgenden Kriterien:
+ Die Standard-Aktualisierungsfrequenz (TTL) beträgt 300 Sekunden
+ Sie können die TTL mithilfe einer Konfigurationsdatei ändern
+ Die Aktualisierung erfolgt, wenn Sie nach Ablauf der TTL ein Geheimnis anfordern
**Anmerkung**
Der Secrets Manager Agent beinhaltet keine Cache-Invalidierung. Wenn ein Geheimnis rotiert, bevor der Cache-Eintrag abläuft, gibt der Secrets Manager Agent möglicherweise einen veralteten geheimen Wert zurück.
Der Secrets Manager Agent gibt geheime Werte im gleichen Format zurück wie die Antwort von`GetSecretValue`. Geheime Werte werden im Cache nicht verschlüsselt.
**Topics**
+ [So funktioniert der Secrets Manager Agent](#agent-overview)
+ [Grundlegendes zum Secrets Manager Agent-Caching](#agent-caching)
+ [Den Secrets Manager Agent erstellen](#secrets-manager-agent-build)
+ [Installieren Sie den Secrets Manager Agent](#secrets-manager-agent-install)
+ [Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab](#secrets-manager-agent-call)
+ [Den Parameter verstehen `refreshNow`](#secrets-manager-agent-refresh)
+ [Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config)
+ [Optionale Funktionen](#secrets-manager-agent-features)
+ [Protokollierung](#secrets-manager-agent-log)
+ [Sicherheitsüberlegungen](#secrets-manager-agent-security)
## Den Secrets Manager Agent erstellen
Bevor Sie beginnen, stellen Sie sicher, dass Sie die Standard-Entwicklungstools und Rust-Tools für Ihre Plattform installiert haben.
**Anmerkung**
Um den Agenten mit aktivierter `fips` Funktion auf macOS zu erstellen, ist derzeit die folgende Problemumgehung erforderlich:
Erstellen Sie eine Umgebungsvariable namens`SDKROOT`, die auf das Ergebnis der Ausführung gesetzt ist `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Um auf RPM-basierten Systemen aufzubauen**
1. Verwenden Sie das im `install` Repository bereitgestellte Skript.
Das Skript generiert beim Start ein zufälliges SSRF-Token und speichert es in der Datei`/var/run/awssmatoken`. Das Token ist für die `awssmatokenreader` Gruppe lesbar, die das Installationsskript erstellt.
1. Damit Ihre Anwendung die Tokendatei lesen kann, müssen Sie der `awssmatokenreader` Gruppe das Benutzerkonto hinzufügen, unter dem Ihre Anwendung ausgeführt wird. Beispielsweise können Sie Ihrer Anwendung mit dem folgenden usermod-Befehl Berechtigungen zum Lesen der Tokendatei gewähren. Dabei ** handelt es sich um die Benutzer-ID, unter der Ihre Anwendung ausgeführt wird.
```
sudo usermod -aG awssmatokenreader
```
**Installieren Sie Entwicklungstools**
Installieren Sie auf RPM-basierten Systemen wie AL2023 z. B. die Gruppe Entwicklungstools:
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Installieren Sie Rust**
Folgen Sie den Anweisungen unter [Rust installieren](https://www.rust-lang.org/tools/install) in der *Rust-Dokumentation*:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Erstellen Sie den Agenten**
Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build:
```
cargo build --release
```
Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent`.
------
#### [ Debian-based systems ]
**Um auf Debian-basierten Systemen aufzubauen**
1.
**Installieren Sie Entwicklungstools**
Installieren Sie auf Debian-basierten Systemen wie Ubuntu das Paket build-essential:
```
sudo apt install build-essential
```
1.
**Installieren Sie Rust**
Folgen Sie den Anweisungen unter [Rust installieren](https://www.rust-lang.org/tools/install) in der *Rust-Dokumentation*:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Erstellen Sie den Agenten**
Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build:
```
cargo build --release
```
Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent`.
------
#### [ Windows ]
**Um unter Windows zu bauen**
1.
**Richten Sie die Entwicklungsumgebung ein**
Folgen Sie den Anweisungen unter [Einrichten Ihrer Entwicklungsumgebung unter Windows für Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) in der *Microsoft Windows-Dokumentation*.
1.
**Erstellen Sie den Agenten**
Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build:
```
cargo build --release
```
Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross-compile natively ]
**Um nativ übergreifend zu kompilieren**
1.
**Installieren Sie Cross-Compile-Tools**
Installieren Sie auf Distributionen, auf denen das mingw-w64-Paket verfügbar ist, wie z. B. Ubuntu, die Cross-Compile-Toolchain:
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Rust-Build-Ziele hinzufügen**
Installieren Sie das Windows GNU-Build-Ziel:
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Für Windows erstellen**
Den Agenten für Windows kreuzkompilieren:
```
cargo build --release --target x86_64-pc-windows-gnu
```
Sie finden die ausführbare Datei unter`target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross compile with Rust cross ]
**Zur Cross-Kompilierung mit Rust Cross**
Wenn die Cross-Compile-Tools nicht nativ auf dem System verfügbar sind, können Sie das Rust-Cross-Projekt verwenden. [Weitere Informationen finden Sie unter https://github.com/cross-rs/ Cross.](https://github.com/cross-rs/cross)
**Wichtig**
Wir empfehlen 32 GB Festplattenspeicher für die Build-Umgebung.
1.
**Richten Sie Docker ein**
Installieren und konfigurieren Sie Docker:
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Docker-Berechtigungen konfigurieren**
Fügen Sie Ihren Benutzer zur Docker-Gruppe hinzu:
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Für Windows erstellen**
Installieren Sie Cross und erstellen Sie die ausführbare Datei:
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Installieren Sie den Secrets Manager Agent
Wählen Sie Ihre Computerumgebung aus den folgenden Installationsoptionen aus.
------
#### [ Amazon EC2 ]
**So installieren Sie den Secrets Manager Agent auf Amazon EC2**
1.
**Navigieren Sie zum Konfigurationsverzeichnis**
Wechseln Sie in das Konfigurationsverzeichnis:
```
cd aws_secretsmanager_agent/configuration
```
1.
**Installationsskript ausführen**
Führen Sie das im Repository bereitgestellte `install` Skript aus.
Das Skript generiert beim Start ein zufälliges SSRF-Token und speichert es in der Datei`/var/run/awssmatoken`. Das Token ist für die `awssmatokenreader` Gruppe lesbar, die das Installationsskript erstellt.
1.
**Konfigurieren Sie Anwendungsberechtigungen**
Fügen Sie das Benutzerkonto, unter dem Ihre Anwendung läuft, der `awssmatokenreader` Gruppe hinzu:
```
sudo usermod -aG awssmatokenreader APP_USER
```
*APP\$1USER*Ersetzen Sie es durch die Benutzer-ID, unter der Ihre Anwendung ausgeführt wird.
------
#### [ Container Sidecar ]
Sie können den Secrets Manager Agent als Sidecar-Container neben Ihrer Anwendung ausführen, indem Sie Docker verwenden. Dann kann Ihre Anwendung Secrets von dem lokalen HTTP-Server abrufen, den der Secrets Manager Agent bereitstellt. Informationen zu Docker finden Sie in der [Docker-Dokumentation](https://docs.docker.com).
**Um einen Sidecar-Container für den Secrets Manager Agent zu erstellen**
1.
**Erstellen Sie ein Agenten-Dockerfile**
Erstellen Sie ein Dockerfile für den Secrets Manager Agent Sidecar-Container:
```
# Use the latest Debian image as the base
FROM debian:latest
# Set the working directory inside the container
WORKDIR /app
# Copy the Secrets Manager Agent binary to the container
COPY secrets-manager-agent .
# Install any necessary dependencies
RUN apt-get update && apt-get install -y ca-certificates
# Set the entry point to run the Secrets Manager Agent binary
ENTRYPOINT ["./secrets-manager-agent"]
```
1.
**Anwendung (Dockerfile) erstellen**
Erstellen Sie ein Dockerfile für Ihre Client-Anwendung.
1.
**Erstellen Sie eine Docker Compose-Datei**
Erstellen Sie eine Docker Compose-Datei, um beide Container mit einer gemeinsamen Netzwerkschnittstelle auszuführen:
**Wichtig**
Sie müssen AWS Anmeldeinformationen und das SSRF-Token laden, damit die Anwendung den Secrets Manager Agent verwenden kann. Informationen zu Amazon EKS und Amazon ECS finden Sie im Folgenden:
[Zugriff im *Amazon EKS-Benutzerhandbuch* verwalten](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html)
Die [IAM-Rolle der Amazon ECS-Aufgabe](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) im *Amazon ECS-Entwicklerhandbuch*
```
version: '3'
services:
client-application:
container_name: client-application
build:
context: .
dockerfile: Dockerfile.client
command: tail -f /dev/null # Keep the container running
secrets-manager-agent:
container_name: secrets-manager-agent
build:
context: .
dockerfile: Dockerfile.agent
network_mode: "container:client-application" # Attach to the client-application container's network
depends_on:
- client-application
```
1.
**Agent-Binärdatei kopieren**
Kopieren Sie die `secrets-manager-agent` Binärdatei in dasselbe Verzeichnis, das Ihre Dockerfiles und die Docker Compose-Datei enthält.
1.
**Container erstellen und ausführen**
Erstellen und führen Sie die Container mit Docker Compose aus:
```
docker-compose up --build
```
1.
**Nächste Schritte**
Sie können jetzt den Secrets Manager Agent verwenden, um Geheimnisse aus Ihrem Client-Container abzurufen. Weitere Informationen finden Sie unter [Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab](#secrets-manager-agent-call).
------
#### [ Lambda ]
Sie können [den Secrets Manager Agent als Lambda-Erweiterung verpacken](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Dann können Sie [es Ihrer Lambda-Funktion als Ebene hinzufügen](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) und den Secrets Manager Agent von Ihrer Lambda-Funktion aus aufrufen, um Geheimnisse abzurufen.
Die folgenden Anweisungen zeigen, wie Sie *MyTest*mithilfe des Beispielskripts `secrets-manager-agent-extension.sh` in ein Secret einen Namen erhalten [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent), um den Secrets Manager Agent als Lambda-Erweiterung zu installieren.
**Um eine Lambda-Erweiterung für den Secrets Manager Agent zu erstellen**
1.
**Verpacken Sie die Agentenschicht**
Führen Sie im Stammverzeichnis des Secrets Manager Agent-Codepakets die folgenden Befehle aus:
```
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID
LAMBDA_ARN=LAMBDA_ARN
# Build the release binary
cargo build --release --target=x86_64-unknown-linux-gnu
# Copy the release binary into the `bin` folder
mkdir -p ./bin
cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent
# Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder.
mkdir -p ./extensions
cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions
# Zip the extension shell script and the binary
zip secrets-manager-agent-extension.zip bin/* extensions/*
# Publish the layer version
LAYER_VERSION_ARN=$(aws lambda publish-layer-version \
--layer-name secrets-manager-agent-extension \
--zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn')
```
1.
**Konfigurieren Sie das SSRF-Token**
Die Standardkonfiguration des Agenten setzt das SSRF-Token automatisch auf den Wert, der in den voreingestellten Variablen `AWS_SESSION_TOKEN` oder `AWS_CONTAINER_AUTHORIZATION_TOKEN` Umgebungsvariablen festgelegt ist (letztere Variable für Lambda-Funktionen mit SnapStart aktivierter Option). Alternativ können Sie die `AWS_TOKEN` Umgebungsvariable stattdessen mit einem beliebigen Wert für Ihre Lambda-Funktion definieren, da diese Variable Vorrang vor den anderen beiden hat. Wenn Sie die `AWS_TOKEN` Umgebungsvariable verwenden möchten, müssen Sie diese Umgebungsvariable mit einem `lambda:UpdateFunctionConfiguration` Aufruf festlegen.
1.
**Ebene an Funktion anhängen**
Hängen Sie die Layer-Version an Ihre Lambda-Funktion an:
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Funktionscode aktualisieren**
Aktualisieren Sie Ihre Lambda-Funktion so, dass `http://localhost:2773/secretsmanager/get?secretId=MyTest` der `X-Aws-codes-Secrets-Token` Header-Wert auf den Wert des SSRF-Tokens gesetzt ist, das aus einer der oben genannten Umgebungsvariablen stammt, um das Geheimnis abzurufen. Stellen Sie sicher, dass Sie die Wiederholungslogik in Ihrem Anwendungscode implementieren, um Verzögerungen bei der Initialisierung und Registrierung der Lambda-Erweiterung zu vermeiden.
1.
**Testen der Funktion**
Rufen Sie die Lambda-Funktion auf, um zu überprüfen, ob das Geheimnis korrekt abgerufen wurde.
------
## Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab
Um ein Geheimnis abzurufen, rufen Sie den lokalen Secrets Manager Agent-Endpunkt mit dem geheimen Namen oder ARN als Abfrageparameter auf. Standardmäßig ruft der Secrets Manager Agent die `AWSCURRENT` Version des Secrets ab. Um eine andere Version abzurufen, verwenden Sie entweder den VersionStage- oder den VersionID-Parameter.
**Wichtig**
Um den Secrets Manager Agent zu schützen, müssen Sie jeder Anfrage einen SSRF-Token-Header beifügen:`X-Aws-Parameters-Secrets-Token`. Der Secrets Manager Agent lehnt Anfragen ab, die diesen Header nicht haben oder die ein ungültiges SSRF-Token haben. Sie können den Namen des SSRF-Headers in der anpassen. [Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config)
### Erforderliche Berechtigungen
Der Secrets Manager Agent verwendet das AWS SDK für Rust, das die [AWS Credential Provider Chain](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) verwendet. Die Identität dieser IAM-Anmeldeinformationen bestimmt die Berechtigungen, die der Secrets Manager Agent zum Abrufen von Geheimnissen hat.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Weitere Informationen zu Berechtigungen finden Sie unter [Referenz zu Berechtigungen für AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**Wichtig**
Nachdem der geheime Wert in den Secrets Manager Agent abgerufen wurde, kann jeder Benutzer mit Zugriff auf die Rechenumgebung und das SSRF-Token aus dem Secrets Manager Agent-Cache auf das Geheimnis zugreifen. Weitere Informationen finden Sie unter [Sicherheitsüberlegungen](#secrets-manager-agent-security).
### Beispielanfragen
------
#### [ curl ]
**Example Beispiel — Holen Sie sich ein Geheimnis mit curl**
Das folgende Curl-Beispiel zeigt, wie Sie ein Geheimnis vom Secrets Manager Agent abrufen können. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Beispiel — Holen Sie sich ein Geheimnis mit Python**
Das folgende Python-Beispiel zeigt, wie ein Secret vom Secrets Manager Agent abgerufen wird. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Den Parameter verstehen `refreshNow`
Der Secrets Manager Agent verwendet einen In-Memory-Cache, um geheime Werte zu speichern, die er regelmäßig aktualisiert. Standardmäßig erfolgt diese Aktualisierung, wenn Sie nach Ablauf der Gültigkeitsdauer (Time to Live, TTL), in der Regel alle 300 Sekunden, ein Geheimnis anfordern. Dieser Ansatz kann jedoch manchmal zu veralteten Geheimwerten führen, insbesondere wenn ein Geheimnis rotiert, bevor der Cache-Eintrag abläuft.
Um diese Einschränkung zu umgehen, unterstützt der Secrets Manager Agent einen Parameter, der `refreshNow` in der URL aufgerufen wird. Sie können diesen Parameter verwenden, um eine sofortige Aktualisierung des Werts eines Geheimnisses zu erzwingen, den Cache zu umgehen und sicherzustellen, dass Sie über die meisten up-to-date Informationen verfügen.
**Standardverhalten (ohne`refreshNow`)**
+ Verwendet zwischengespeicherte Werte, bis TTL abläuft
+ Aktualisiert Geheimnisse erst nach TTL (Standard 300 Sekunden)
+ Kann veraltete Werte zurückgeben, wenn die Geheimnisse rotieren, bevor der Cache abläuft
**Verhalten mit `refreshNow=true`**
+ Umgeht den Cache vollständig
+ Ruft den neuesten geheimen Wert direkt aus Secrets Manager ab
+ Aktualisiert den Cache mit dem neuen Wert und setzt die TTL zurück
+ Stellt sicher, dass Sie immer den aktuellsten geheimen Wert erhalten
### Force-Aktualisierung eines geheimen Werts
**Wichtig**
Der Standardwert von `refreshNow` ist `false`. Wenn auf gesetzt`true`, überschreibt es die in der Secrets Manager Agent-Konfigurationsdatei angegebene TTL und führt einen API-Aufruf an Secrets Manager durch.
------
#### [ curl ]
**Example Beispiel — Force-Aktualisierung eines Secrets mithilfe von curl**
Das folgende Curl-Beispiel zeigt, wie Sie den Secrets Manager Agent zwingen können, den Secret zu aktualisieren. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\
echo
```
------
#### [ Python ]
**Example Beispiel — Force-Aktualisierung eines Secrets mit Python**
Das folgende Python-Beispiel zeigt, wie ein Secret vom Secrets Manager Agent abgerufen wird. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Den Secrets Manager Agent konfigurieren
Um die Konfiguration des Secrets Manager Agent zu ändern, erstellen Sie eine [TOML-Konfigurationsdatei](https://toml.io/en/) und rufen Sie `./aws_secretsmanager_agent --config config.toml` dann auf.Konfigurationsoptionen
**`log_level`**
Die Detailebene, die in den Protokollen für den Secrets Manager Agent gemeldet wird: DEBUG, INFO, WARN, ERROR oder NONE. Die Standardeinstellung ist INFO.
**`log_to_file`**
Ob in einer Datei oder stdout/stderr protokolliert werden soll: oder. `true` `false` Der Standardwert ist `true`.
**`http_port`**
Der Port für den lokalen HTTP-Server im Bereich 1024 bis 65535. Die Standardeinstellung ist 2773.
**`region`**
Die AWS Region, die für Anfragen verwendet werden soll. Wenn keine Region angegeben ist, bestimmt der Secrets Manager Agent die Region aus dem SDK. Weitere Informationen finden [Sie unter Geben Sie Ihre Anmeldeinformationen und die Standardregion](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) an im *AWS SDK for Rust Developer Guide*.
**`ttl_seconds`**
Die TTL in Sekunden für die zwischengespeicherten Elemente im Bereich 0 bis 3600. Die Standardeinstellung ist 300. 0 gibt an, dass kein Caching stattfindet.
**`cache_size`**
Die maximale Anzahl von Geheimnissen, die im Cache gespeichert werden können, liegt im Bereich von 1 bis 1000. Der Standardwert ist 1000.
**`ssrf_headers`**
Eine Liste von Header-Namen, die der Secrets Manager Agent auf das SSRF-Token überprüft. Die Standardeinstellung ist „X-Aws-Parameters-Secrets-Token,“. X-Vault-Token
**`ssrf_env_variables`**
Eine Liste von Umgebungsvariablennamen, die der Secrets Manager Agent in sequentieller Reihenfolge nach dem SSRF-Token sucht. Die Umgebungsvariable kann das Token oder einen Verweis auf die Tokendatei enthalten, wie in:. `AWS_TOKEN=file:///var/run/awssmatoken` Die Standardeinstellung ist "AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN“.
**`path_prefix`**
Das URI-Präfix, das verwendet wird, um festzustellen, ob es sich bei der Anfrage um eine pfadbasierte Anfrage handelt. Die Standardeinstellung ist „/v1/“.
**`max_conn`**
Die maximale Anzahl von Verbindungen von HTTP-Clients, die der Secrets Manager Agent zulässt, im Bereich von 1 bis 1000. Die Standardeinstellung ist 800.
## Optionale Funktionen
Der Secrets Manager Agent kann mit optionalen Funktionen erstellt werden, indem das `--features` Flag an übergeben wird`cargo build`. Die verfügbaren Funktionen sind:Build-Funktionen
**`prefer-post-quantum`**
Stellt `X25519MLKEM768` den Schlüsselaustausch-Algorithmus mit der höchsten Priorität her. Andernfalls ist er verfügbar, hat aber nicht die höchste Priorität. `X25519MLKEM768`ist ein hybrider Algorithmus für den post-quantum-secure Schlüsselaustausch.
**`fips`**
Schränkt die vom Agenten verwendeten Verschlüsselungssammlungen auf FIPS-zugelassene Verschlüsselungen ein.
## Protokollierung
**Lokale Protokollierung**
Der Secrets Manager Agent protokolliert Fehler lokal in der Datei `logs/secrets_manager_agent.log` oder in stdout/stderr, abhängig von der Konfigurationsvariablen. `log_to_file` Wenn Ihre Anwendung den Secrets Manager Agent aufruft, um ein Geheimnis zu erhalten, werden diese Aufrufe im lokalen Protokoll angezeigt. Sie erscheinen nicht in den CloudTrail Protokollen.
**Rotation der Protokolle**
Der Secrets Manager Agent erstellt eine neue Protokolldatei, wenn die Datei 10 MB erreicht, und speichert insgesamt bis zu fünf Protokolldateien.
**AWS Dienstprotokollierung**
Das Protokoll geht nicht an Secrets Manager, CloudTrail, oder CloudWatch. Anfragen zum Abrufen von Geheimnissen vom Secrets Manager Agent werden in diesen Protokollen nicht angezeigt. Wenn der Secrets Manager Agent Secrets Manager aufruft, um ein Geheimnis zu erhalten, wird dieser Anruf CloudTrail mit einer Benutzer-Agent-Zeichenfolge aufgezeichnet, die enthält`aws-secrets-manager-agent`.
Sie können die Protokollierungsoptionen in der konfigurieren[Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config).
## Sicherheitsüberlegungen
**Domäne des Vertrauens**
Bei einer Agentenarchitektur ist die Vertrauensdomäne der Ort, an dem der Agentenendpunkt und das SSRF-Token zugänglich sind, was normalerweise der gesamte Host ist. Die Vertrauensdomäne für den Secrets Manager Agent sollte mit der Domäne übereinstimmen, in der die Secrets Manager Manager-Anmeldeinformationen verfügbar sind, um den gleichen Sicherheitsstatus aufrechtzuerhalten. Auf Amazon EC2 wäre die Vertrauensdomäne für den Secrets Manager Agent beispielsweise dieselbe wie die Domäne der Anmeldeinformationen, wenn Rollen für Amazon EC2 verwendet werden.
**Wichtig**
Sicherheitsbewusste Anwendungen, die noch keine Agentenlösung verwenden, bei der die Secrets Manager Manager-Anmeldeinformationen für die Anwendung gesperrt sind, sollten die Verwendung sprachspezifischer Lösungen AWS SDKs oder Caching-Lösungen in Betracht ziehen. [Weitere Informationen finden Sie unter Geheime Informationen abrufen.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)
# Rufen Sie mit dem AWS C\$1\$1-SDK einen geheimen Wert von Secrets Manager ab
Rufen Sie das SDK für C\$1\$1-Anwendungen direkt mit [GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)oder auf [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue).
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
//! Retrieve an AWS Secrets Manager encrypted secret.
/*!
\param secretID: The ID for the secret.
\return bool: Function succeeded.
*/
bool AwsDoc::SecretsManager::getSecretValue(const Aws::String &secretID,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SecretsManager::SecretsManagerClient secretsManagerClient(clientConfiguration);
Aws::SecretsManager::Model::GetSecretValueRequest request;
request.SetSecretId(secretID);
Aws::SecretsManager::Model::GetSecretValueOutcome getSecretValueOutcome = secretsManagerClient.GetSecretValue(
request);
if (getSecretValueOutcome.IsSuccess()) {
std::cout << "Secret is: "
<< getSecretValueOutcome.GetResult().GetSecretString() << std::endl;
}
else {
std::cerr << "Failed with Error: " << getSecretValueOutcome.GetError()
<< std::endl;
}
return getSecretValueOutcome.IsSuccess();
}
```
# Rufen Sie mithilfe des JavaScript AWS SDK einen geheimen Wert von Secrets Manager ab
Rufen Sie das SDK für JavaScript Anwendungen direkt mit [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)oder auf [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property).
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
# Holen Sie sich mit dem Kotlin AWS SDK einen geheimen Wert für Secrets Manager
Rufen Sie für Kotlin-Anwendungen das SDK direkt mit [GetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)oder auf. [BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
suspend fun getValue(secretName: String?) {
val valueRequest =
GetSecretValueRequest {
secretId = secretName
}
SecretsManagerClient.fromEnvironment { region = "us-east-1" }.use { secretsClient ->
val response = secretsClient.getSecretValue(valueRequest)
val secret = response.secretString
println("The secret value is $secret")
}
}
```
# Holen Sie sich mit dem AWS PHP-SDK einen geheimen Wert für Secrets Manager
Rufen Sie für PHP-Anwendungen das SDK direkt mit [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue) oder [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue) auf.
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
>/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
// Create a Secrets Manager Client
$client = new SecretsManagerClient([
'profile' => 'default',
'version' => '2017-10-17',
'region' => '<<{{MyRegionName}}>>',
]);
$secret_name = '<<{{MySecretName}}>>';
try {
$result = $client->getSecretValue([
'SecretId' => $secret_name,
]);
} catch (AwsException $e) {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
throw $e;
}
// Decrypts secret using the associated KMS key.
$secret = $result['SecretString'];
// Your code goes here
```
# Holen Sie sich mit dem Ruby AWS SDK einen geheimen Wert für Secrets Manager
Rufen Sie für Ruby-Anwendungen das SDK direkt mit [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method) oder [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method) auf.
Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
```
# Use this code snippet in your app.
# If you need more information about configurations or implementing the sample code, visit the AWS docs:
# https://aws.amazon.com/developer/language/ruby/
require 'aws-sdk-secretsmanager'
def get_secret
client = Aws::SecretsManager::Client.new(region: '<<{{MyRegionName}}>>')
begin
get_secret_value_response = client.get_secret_value(secret_id: '<<{{MySecretName}}>>')
rescue StandardError => e
# For a list of exceptions thrown, see
# https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
raise e
end
secret = get_secret_value_response.secret_string
# Your code goes here.
end
```
# Holen Sie sich einen geheimen Wert mit dem AWS CLI
**Erforderliche Berechtigungen: **`secretsmanager:GetSecretValue`
**Example Den verschlüsselten Secret-Wert eines Secrets abrufen**
Im folgenden [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html)-Beispiel wird der aktuelle Secret-Wert abgerufen.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Den vorherigen Secret-Wert abrufen**
Im folgenden [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html)-Beispiel wird der vorherige Secret-Wert abgerufen.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Holen Sie sich eine Gruppe von Geheimnissen in einem Batch mit dem AWS CLI
**Erforderliche Berechtigungen: **
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`Erlaubnis für jedes Geheimnis, das Sie abrufen möchten.
+ Wenn Sie Filter verwenden, müssen Sie auch `secretsmanager:ListSecrets` haben.
Ein Beispiel für eine Berechtigungsrichtlinie finden Sie unter [Beispiel: Berechtigung zum Abrufen einer Gruppe geheimer Werte in einem Batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Wichtig**
Wenn Sie über eine VPCE-Richtlinie verfügen, die die Berechtigung zum Abrufen eines einzelnen Secrets in der abgerufenen Gruppe verweigert, gibt `BatchGetSecretValue` keine Secrets-Werte zurück, und es wird ein Fehler zurückgegeben.
**Example Ruft den Secrets-Wert für eine Gruppe von Secrets ab, die nach Namen aufgelistet sind**
Im folgenden [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html)-Beispiel wird der aktuelle Secret-Wert für drei Secrets abgerufen.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Ruft den Secrets-Wert für eine Gruppe von Secrets ab, die durch Filter ausgewählt sind**
Im folgenden [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html)-Beispiel wird der Secret-Wert für die Secrets abgerufen, die über ein Tag mit dem Namen „Test“ verfügen.
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Rufen Sie mithilfe der AWS Konsole einen geheimen Wert ab
**Ein Secret abrufen (Konsole)**
1. Öffnen Sie die Secrets Manager Manager-Konsole unter [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Wählen Sie in der Secret-Liste das Secret aus, das Sie abrufen möchten.
1. Wählen Sie im Bereich **Secret value (Secret-Wert)** die Option **Retrieve secret value (Secret-Wert abrufen)**.
Secrets Manager zeigt die aktuelle Version (`AWSCURRENT`) des Secrets an. Um [andere Versionen](whats-in-a-secret.md#term_version) des Secrets anzuzeigen, z. B. `AWSPREVIOUS` oder Versionen mit benutzerdefinierter Bezeichnung, verwenden Sie [Holen Sie sich einen geheimen Wert mit dem AWS CLI](retrieving-secrets_cli.md).
# Benutze AWS Secrets Manager Geheimnisse in AWS Batch
AWS Batch hilft Ihnen beim Ausführen von Batch-Computing-Workloads auf dem AWS Cloud. Mit können Sie vertrauliche Daten in Ihre Jobs einfügen AWS Batch, indem Sie Ihre sensiblen Daten geheim speichern und dann in AWS Secrets Manager Ihrer Jobdefinition darauf verweisen. Weitere Informationen finden Sie unter [Angeben sensibler Daten mit Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Holen Sie sich ein AWS Secrets Manager Geheimnis in einer CloudFormation Ressource
Mit können Sie ein Geheimnis abrufen CloudFormation, um es in einer anderen CloudFormation Ressource zu verwenden. Ein häufiges Szenario besteht darin, zuerst ein Secret mit einem von Secrets Manager generierten Passwort zu erstellen und dann den Benutzernamen und das Passwort aus dem Secret abzurufen, um sie als Anmeldeinformationen für eine neue Datenbank zu verwenden. Hinweise zum Erstellen von Geheimnissen mit CloudFormation finden Sie unter[Erstelle AWS Secrets Manager Geheimnisse in AWS CloudFormation](cloudformation.md).
Um ein Geheimnis in einer CloudFormation Vorlage abzurufen, verwenden Sie eine *dynamische Referenz*. Wenn Sie den Stack erstellen, überträgt die dynamische Referenz den geheimen Wert in die CloudFormation Ressource, sodass Sie die geheimen Informationen nicht fest codieren müssen. Sie können das Secret stattdessen anhand des Namens oder des ARN referenzieren. Sie können eine dynamische Referenz für ein Secret in jeder Ressourceneigenschaft verwenden. Sie können keine dynamische Referenz für ein Secret in Ressourcenmetadaten verwenden, z. B. [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html), weil dadurch der Secret-Wert in der Konsole sichtbar würde.
Eine dynamische Referenz für ein Secret hat das folgende Muster:
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**secret-id**
Der Name oder ARN des Secrets. Um auf ein Geheimnis in Ihrem AWS Konto zuzugreifen, können Sie den geheimen Namen verwenden. Um auf ein Geheimnis in einem anderen AWS Konto zuzugreifen, verwenden Sie den ARN des Geheimnisses.
**json-key** (Optional)
Der Schlüsselname des Schlüssel/Wert-Paares, dessen Wert Sie abrufen möchten. Wenn Sie kein a angeben`json-key`, wird der gesamte geheime Text CloudFormation abgerufen. Dieses Segment darf nicht das Doppelpunktzeichen (`:`) enthalten.
**version-stage** (Optional)
Die [Version](whats-in-a-secret.md#term_version) des zu verwendenden Secrets. Secrets Manager verwendet Staging-Markierungen, um während des Rotationsprozesses den Überblick über verschiedene Versionen zu behalten. Wenn Sie `version-stage` verwenden, geben Sie `version-id` nicht an. Wenn Sie weder `version-stage` noch `version-id` angeben, dann ist der Standard die `AWSCURRENT`-Version. Dieses Segment darf nicht das Doppelpunktzeichen (`:`) enthalten.
**version-id** (Optional)
Die eindeutige ID der Version des zu verwendenden Secrets. Wenn Sie `version-id` angeben, dürfen Sie `version-stage` nicht angeben. Wenn Sie weder `version-stage` noch `version-id` angeben, dann ist der Standard die `AWSCURRENT`-Version. Dieses Segment darf nicht das Doppelpunktzeichen (`:`) enthalten.
Weitere Informationen finden Sie unter [Verwenden dynamischer Referenzen, um Secrets-Manager-Geheimnisse anzugeben](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Anmerkung**
Erstellen Sie keinen dynamischen Verweis mit einem umgekehrten Schrägstrich `(\)` als Endwert. CloudFormation kann diese Verweise nicht auflösen, was zu einem Ressourcenausfall führt.
# Verwenden Sie AWS Secrets Manager Geheimnisse in GitHub Jobs
Um ein Geheimnis in einem GitHub Job zu verwenden, können Sie eine GitHub Aktion verwenden, um Geheimnisse abzurufen AWS Secrets Manager und sie als maskierte [Umgebungsvariablen](https://docs.github.com/en/actions/learn-github-actions/environment-variables) in Ihrem GitHub Workflow hinzuzufügen. Weitere Informationen zu GitHub Aktionen finden Sie in der *GitHub Dokumentation* unter [Grundlegendes zu GitHub Aktionen](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions).
Wenn Sie Ihrer GitHub Umgebung ein Geheimnis hinzufügen, steht es für alle anderen Schritte Ihres GitHub Jobs zur Verfügung. Folgen Sie den Anweisungen unter [Sicherheitshärtung für GitHub Maßnahmen](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions), um zu verhindern, dass geheime Daten in Ihrer Umgebung missbraucht werden.
Sie können die gesamte Zeichenfolge im Secret-Wert als Umgebungsvariablenwert festlegen, oder wenn die Zeichenfolge JSON ist, können Sie den JSON-Code analysieren, um einzelne Umgebungsvariablen für jedes JSON-Schlüsselwertpaar festzulegen. Wenn der Secret-Wert ein Binärwert ist, wandelt die Aktion ihn in eine Zeichenfolge um.
Um die aus Ihren Secrets erstellten Umgebungsvariablen anzuzeigen, aktivieren Sie die Debug-Protokollierung. *Weitere Informationen finden Sie in der Dokumentation unter [Aktivieren der Debug-Protokollierung](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging). GitHub *
Informationen zur Verwendung der aus Ihren Geheimnissen erstellten Umgebungsvariablen finden Sie in der *GitHub Dokumentation* unter [Umgebungsvariablen](https://docs.github.com/en/actions/learn-github-actions/environment-variables).
## Voraussetzungen
Um diese Aktion verwenden zu können, müssen Sie zunächst AWS Anmeldeinformationen konfigurieren und diese AWS-Region in Ihrer GitHub Umgebung einrichten, indem Sie den `configure-aws-credentials` Schritt ausführen. Folgen Sie den Anweisungen unter [Aktion „ AWS Anmeldeinformationen für GitHub Aktionen konfigurieren](https://github.com/aws-actions/configure-aws-credentials)“, um die **Rolle direkt über den GitHub OIDC-Anbieter zu übernehmen**. Auf diese Weise können Sie Anmeldeinformationen mit kurzer Lebensdauer verwenden und vermeiden, dass zusätzliche Zugriffsschlüssel außerhalb von Secrets Manager gespeichert werden.
Die IAM-Rolle, die die Aktion annimmt, muss über die folgenden Berechtigungen verfügen:
+ `GetSecretValue` auf den Secrets, die Sie abrufen möchten.
+ `ListSecrets` auf allen Secrets.
+ (Optional)`Decrypt`, KMS key ob die Geheimnisse mit einem verschlüsselt sind. Kundenverwalteter Schlüssel
Weitere Informationen finden Sie unter [Authentifizierung und Zugriffskontrolle für AWS Secrets Manager](auth-and-access.md).
## Usage
Um die Aktion zu verwenden, fügen Sie Ihrem Workflow einen Schritt hinzu, der die folgende Syntax verwendet.
```
- name: Step name
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
secretId1
ENV_VAR_NAME, secretId2
name-transformation: (Optional) uppercase|lowercase|none
parse-json-secrets: (Optional) true|false
```Parameters
`secret-ids`
Geheime ARNS, Namen und Namenspräfixe.
Um den Namen der Umgebungsvariablen festzulegen, geben Sie ihn vor der Secret-ID ein, gefolgt von einem Komma. Beispielsweise erstellt `ENV_VAR_1, secretId` eine Umgebungsvariable namens **ENV\$1VAR\$11** aus der Secret-`secretId`. Die Namen von Umgebungsvariablen können Buchstaben, Zahlen und den Unterstriche enthalten.
Um ein Präfix zu verwenden, geben Sie mindestens drei Zeichen gefolgt von einem Sternchen ein. Zum Beispiel entspricht `dev*` allen Secrets mit einem Namen, der mit **dev** beginnt. Die maximale Anzahl übereinstimmender Secrets, die abgerufen werden können, ist 100. Wenn Sie den Variablennamen festlegen und das Präfix mit mehreren Secrets übereinstimmt, schlägt die Aktion fehl.
`name-transformation`
Standardmäßig erstellt der Schritt jeden Umgebungsvariablennamen aus dem Secret-Namen, der so umgewandelt wird, dass er nur Großbuchstaben, Zahlen und Unterstriche enthält, sodass er nicht mit einer Zahl beginnt. Für die Buchstaben im Namen können Sie den Schritt so konfigurieren, dass Kleinbuchstaben zusammen verwendet werden `lowercase` oder dass die Groß- und Kleinschreibung der Buchstaben mit `none` nicht geändert wird. Der Standardwert ist `uppercase`.
`parse-json-secrets`
(Optional) Standardmäßig legt die Aktion den Wert der Umgebungsvariablen auf die gesamte JSON-Zeichenfolge im Secret-Wert fest. Stellen Sie `parse-json-secrets` auf ein`true`, um Umgebungsvariablen für jedes Schlüssel-Wert-Paar im JSON zu erstellen.
Beachten Sie, dass die Aktion doppelte Namenskonflikte aufweist, wenn JSON Schlüssel wie „name“ und „Name“ verwendet, bei denen die Groß-/Kleinschreibung beachtet wird. Setzen Sie in diesem Fall `parse-json-secrets` auf `false` und analysieren Sie den JSON-Secret-Wert separat.
## Benennung von Umgebungsvariablen
Die durch die Aktion erstellten Umgebungsvariablen haben den gleichen Namen wie die Geheimnisse, aus denen sie stammen. Für Umgebungsvariablen gelten strengere Benennungsanforderungen als für Geheimnisse, sodass die Aktion geheime Namen so transformiert, dass sie diese Anforderungen erfüllen. Die Aktion wandelt beispielsweise Kleinbuchstaben in Großbuchstaben um. Wenn Sie den JSON-Code des Geheimnisses analysieren, enthält der Name der Umgebungsvariablen beispielsweise sowohl den geheimen Namen als auch den JSON-Schlüsselnamen. `MYSECRET_KEYNAME` Sie können die Aktion so konfigurieren, dass Kleinbuchstaben nicht umgewandelt werden.
Wenn zwei Umgebungsvariablen am Ende denselben Namen haben würden, schlägt die Aktion fehl. In diesem Fall müssen Sie die Namen, die Sie für die Umgebungsvariablen verwenden möchten, als *Aliase* angeben.
Beispiele dafür, wann die Namen in Konflikt geraten könnten:
+ Ein Geheimnis mit dem Namen "MySecret" und ein Geheimnis mit dem Namen „mysecret“ würden beide zu Umgebungsvariablen mit dem Namen „MYSECRET“ werden.
+ Ein Geheimnis namens „Secret\$1KeyName“ und ein von JSON analysiertes Geheimnis namens „Secret“ mit einem Schlüssel namens „keyname“ würden beide zu Umgebungsvariablen mit dem Namen „SECRET\$1KEYNAME“ werden.
Sie können den Namen der Umgebungsvariablen festlegen, indem Sie einen *Alias angeben, wie im folgenden Beispiel gezeigt, wodurch* eine Variable mit dem Namen erstellt wird. `ENV_VAR_NAME`
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Leere Aliase**
+ Wenn Sie einen leeren Alias, gefolgt von einem Komma und dann der geheimen ID, festlegen `parse-json-secrets: true` und eingeben, benennt die Aktion die Umgebungsvariable genauso wie die analysierten JSON-Schlüssel. Die Variablennamen enthalten nicht den geheimen Namen.
Wenn das Geheimnis kein gültiges JSON enthält, erstellt die Aktion eine Umgebungsvariable und benennt sie genauso wie den geheimen Namen.
+ Wenn Sie einen leeren Alias, gefolgt von einem Komma und der geheimen ID, festlegen `parse-json-secrets: false` und eingeben, benennt die Aktion die Umgebungsvariablen so, als ob Sie keinen Alias angegeben hätten.
Das folgende Beispiel zeigt einen leeren Alias.
```
,secret2
```
## Beispiele
**Example 1 Erhalten Sie Secrets nach Namen und ARN**
Im folgenden Beispiel werden Umgebungsvariablen für Secrets erstellt, die durch Name und ARN identifiziert werden.
```
- name: Get secrets by name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
exampleSecretName
arn:aws:secretsmanager:us-east-2:123456789012:secret:test1-a1b2c3
0/test/secret
/prod/example/secret
SECRET_ALIAS_1,test/secret
SECRET_ALIAS_2,arn:aws:secretsmanager:us-east-2:123456789012:secret:test2-a1b2c3
,secret2
```
Erstellte Umgebungsvariablen:
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2 Erhalten Sie alle Secrets, die mit einem Präfix beginnen**
Im folgenden Beispiel werden Umgebungsvariablen für alle Secrets erstellt, deren Namen mit beginnen*beta*.
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Erstellte Umgebungsvariablen:
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3 Analysieren Sie JSON im Secret**
Im folgenden Beispiel werden Umgebungsvariablen erstellt, indem das JSON im Secret analysiert wird.
```
- name: Get Secrets by Name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
test/secret
,secret2
parse-json-secrets: true
```
Das Secret `test/secret` hat den folgenden Secret-Wert.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
Das Secret `secret2` hat den folgenden Secret-Wert.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Erstellte Umgebungsvariablen:
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 Verwenden Sie Kleinbuchstaben für Namen von Umgebungsvariablen**
Im folgenden Beispiel wird eine Umgebungsvariable mit einem Namen in Kleinbuchstaben erstellt.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Die Umgebungsvariable wurde erstellt:
```
examplesecretname: secretValue
```
# Verwenden Sie AWS Secrets Manager in GitLab
AWS Secrets Manager integriert mit GitLab. Sie können Secrets Manager Secrets nutzen, um Ihre GitLab Anmeldeinformationen zu schützen, sodass sie nicht mehr fest codiert sind. GitLab Stattdessen ruft [GitLab Runner](https://docs.gitlab.com/runner/) diese Secrets aus Secrets Manager ab, wenn Ihre Anwendung einen Job in den GitLab CI/CD-Pipelines ausführt.
Um diese Integration zu nutzen, erstellen Sie einen [OpenID Connect (OIDC) -Identitätsanbieter in IAM AWS Identity and Access Management und eine IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html). Dadurch kann GitLab Runner auf Ihr Secrets Manager Manager-Geheimnis zugreifen. [Weitere Informationen zu GitLab CI/CD und OIDC finden Sie in der Dokumentation. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Überlegungen
Wenn Sie eine nicht öffentliche GitLab Instanz verwenden, können Sie diese Secrets Manager Manager-Integration nicht verwenden. Sehen Sie sich stattdessen die [GitLab Dokumentation für nicht öffentliche Instanzen an](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Voraussetzungen
Um Secrets Manager mit zu integrieren GitLab, müssen Sie die folgenden Voraussetzungen erfüllen:
1.
**Erstellen Sie ein AWS Secrets Manager Geheimnis**
Sie benötigen ein Secrets Manager Manager-Geheimnis, das bei Ihrem GitLab Job abgerufen wird und das Festcodieren dieser Anmeldeinformationen überflüssig macht. Sie benötigen die geheime ID von Secrets Manager, wenn Sie [Ihre GitLab Pipeline konfigurieren](#configure-gitlab-pipeline). Weitere Informationen finden Sie unter [Erstelle ein AWS Secrets Manager Geheimnis](create_secret.md).
1.
**Geben Sie in der IAM-Konsole GitLab Ihren OIDC-Anbieter an.**
In diesem Schritt erstellen Sie GitLab Ihren OIDC-Anbieter in der IAM-Konsole. [Weitere Informationen finden Sie unter [Erstellen eines OpenID Connect (OIDC) -Identitätsanbieters](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html) und in der Dokumentation. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Verwenden Sie beim Erstellen des OIDC-Anbieters in der IAM-Konsole die folgenden Konfigurationen:
1. Stellen Sie das auf Ihre Instanz `provider URL` ein. GitLab Beispiel, **gitlab.example.com**.
1. Setzen Sie das `audience` oder `aud` auf**sts.amazonaws.com**.
1.
**Erstellen Sie eine IAM-Rolle und -Richtlinie**
Sie müssen eine IAM-Rolle und -Richtlinie erstellen. Diese Rolle wird von GitLab with [AWS -Security-Token-Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) übernommen. Weitere Informationen finden [Sie unter Erstellen einer Rolle mithilfe benutzerdefinierter Vertrauensrichtlinien](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html).
1. Verwenden Sie in der IAM-Konsole die folgenden Einstellungen, wenn Sie die IAM-Rolle erstellen:
+ Setzen Sie `Trusted entity type` auf **Web identity**.
+ Setzen Sie `Group` auf **your GitLab group**.
+ Stellen `Identity provider` Sie dieselbe Anbieter-URL (die [GitLab Instanz](#step2-oidc-provider)) ein, die Sie in Schritt 2 verwendet haben.
+ Stellen `Audience` Sie dieselbe [Zielgruppe](#step2-oidc-audience) ein, die Sie in Schritt 2 verwendet haben.
1. Im Folgenden finden Sie ein Beispiel für eine Vertrauensrichtlinie, die es ermöglicht GitLab , Rollen zu übernehmen. Ihre Vertrauensrichtlinie sollte Ihren AWS-Konto GitLab URL und Ihren [Projektpfad](https://docs.gitlab.com/user/project/) auflisten.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRoleWithWebIdentity",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/gitlab.example.com"
},
"Condition": {
"StringEquals": {
"gitlab.example.com:aud": [
"sts.amazon.com"
]
},
"StringLike": {
"gitlab.example.com:sub": [
"project_path:mygroup/project-*:ref_type:branch-*:ref:main*"
]
}
}
}
]
}
```
1. Sie müssen außerdem eine IAM-Richtlinie erstellen, um den GitLab Zugriff darauf zu AWS Secrets Manager ermöglichen. Sie können diese Richtlinie zu Ihrer Vertrauensrichtlinie hinzufügen. Weitere Informationen finden Sie unter [IAM-Richtlinien erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:your-secret"
}
]
}
```
## Integration AWS Secrets Manager mit GitLab
Nachdem Sie die Voraussetzungen erfüllt haben, können Sie konfigurieren, GitLab dass Secrets Manager zum Schutz Ihrer Anmeldeinformationen verwendet wird.
### GitLab Pipeline für die Verwendung von Secrets Manager konfigurieren
Sie müssen Ihre [GitLab CI/CD-Konfigurationsdatei](https://docs.gitlab.com/ci/yaml/yaml_optimization/) mit den folgenden Informationen aktualisieren:
+ Die Zielgruppe des Tokens ist auf STS festgelegt.
+ Die geheime ID von Secrets Manager.
+ Die IAM-Rolle, die GitLab Runner bei der Ausführung von Jobs in der GitLab Pipeline übernehmen soll.
+ Der AWS-Region Ort, an dem das Geheimnis gespeichert ist.
GitLab ruft das Geheimnis aus Secrets Manager ab und speichert den Wert in einer temporären Datei. Der Pfad zu dieser Datei wird in einer CI/CD Variablen gespeichert, ähnlich wie [CI/CD-Variablen vom Dateityp](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
Das Folgende ist ein Auszug aus der YAML-Datei für eine CI/CD-Konfigurationsdatei: GitLab
```
variables:
AWS_REGION: us-east-1
AWS_ROLE_ARN: 'arn:aws:iam::111122223333:role/gitlab-role'
job:
id_tokens:
AWS_ID_TOKEN:
aud: 'sts.amazonaws.com'
secrets:
DATABASE_PASSWORD:
aws_secrets_manager:
secret_id: "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
```
Weitere Informationen finden Sie in der [GitLabSecrets Manager Manager-Integrationsdokumentation](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Optional können Sie Ihre OIDC-Konfiguration in testen. GitLab Weitere Informationen finden Sie in der [GitLab Dokumentation zum Testen der OIDC-Konfiguration](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration).
## Fehlerbehebung
Die folgenden Informationen können Ihnen helfen, häufig auftretende Probleme zu beheben, die bei der Integration von Secrets Manager auftreten können GitLab.
### GitLab Probleme mit der Pipeline
Wenn Sie Probleme mit der GitLab Pipeline haben, stellen Sie Folgendes sicher:
+ Ihre YAML-Datei ist ordnungsgemäß formatiert. Weitere Informationen finden Sie in der [GitLab-Dokumentation](https://docs.gitlab.com/ee/ci/yaml/).
+ Ihre GitLab Pipeline nimmt die richtige Rolle ein, verfügt über die entsprechenden Berechtigungen und hat Zugriff auf das richtige AWS Secrets Manager Geheimnis.
### Weitere Ressourcen
Die folgenden Ressourcen können Ihnen bei der Behebung von Problemen mit GitLab und helfen AWS Secrets Manager:
+ [GitLab OIDC-Fehlerbehebung](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [Debuggen GitLab der CI/CD-Pipeline](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Fehlerbehebung](ascp-eks-installation.md#troubleshooting)
# Benutze AWS Secrets Manager Geheimnisse in AWS IoT Greengrass
AWS IoT Greengrass ist eine Software, die Cloud-Funktionen auf lokale Geräte erweitert. Dies ermöglicht es Geräten, Daten näher an der Informationsquelle zu erfassen und zu analysieren, selbstständig auf lokale Ereignisse zu reagieren und in lokalen Netzwerken sicher untereinander zu kommunizieren.
AWS IoT Greengrass ermöglicht es Ihnen, sich mit Diensten und Anwendungen von AWS IoT Greengrass Geräten aus zu authentifizieren, ohne Passwörter, Token oder andere Geheimnisse fest codieren zu müssen. Sie können AWS Secrets Manager es verwenden, um Ihre Geheimnisse sicher in der Cloud zu speichern und zu verwalten. AWS IoT Greengrass erweitert Secrets Manager auf AWS IoT Greengrass Kerngeräte, sodass Ihre Konnektoren und Lambda-Funktionen lokale Geheimnisse verwenden können, um mit Diensten und Anwendungen zu interagieren.
Um ein Geheimnis in eine AWS IoT Greengrass Gruppe zu integrieren, erstellen Sie eine Gruppenressource, die auf das Secrets Manager Manager-Geheimnis verweist. Diese Secret-Ressource verweist über den zugehörigen ARN auf das Cloud-Secret . Informationen zum Erstellen, Verwalten und Verwenden geheimer Ressourcen finden Sie unter [Arbeiten mit geheimen Ressourcen](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) im AWS IoT Entwicklerhandbuch.
Informationen zum Bereitstellen von Geheimnissen im AWS IoT Greengrass Core finden Sie unter [Bereitstellen von Geheimnissen im AWS IoT Greengrass Core.](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# Verwenden Sie AWS Secrets Manager Geheimnisse im Parameterspeicher
AWS Systems Manager Parameter Store bietet sicheren, hierarchischen Speicher für die Verwaltung von Konfigurationsdaten und Geheimnissen. Sie können Daten wie Passwörter, Datenbankzeichenfolgen und Lizenzcodes als Parameterwerte speichern. Allerdings bietet Parameter Store keine automatischen Rotationsservices für gespeicherte Secrets. Stattdessen können Sie mit Parameter Store Ihr Secret in Secrets Manager speichern und dann als Parameter-Store-Parameter referenzieren.
Wenn Sie Parameter Store mit Secrets Manager konfigurieren, erfordert der `secret-id` Parameter Store einen Schrägstrich (/) vor der Name-Zeichenfolge.
Weitere Informationen finden Sie im *AWS Systems Manager Benutzerhandbuch* unter [Referenzieren von AWS Secrets Manager Geheimnissen aus Parameterspeicherparametern](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html).