Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Holen Sie sich einen geheimen Secrets Manager Manager-Wert mit Python
<a name="retrieving-secrets-python"></a>

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
<a name="retrieving-secrets_cache-python"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_string"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_binary"></a>

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
<a name="retrieving-secrets_cache-ref-secretcacheconfig"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook_put"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook_get"></a>

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
<a name="retrieving-secrets_cache-decor-string"></a>

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
<a name="retrieving-secrets_cache-decor-keyword"></a>

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
<a name="retrieving-secrets-python-sdk"></a>

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
<a name="retrieving-secrets-python-batch"></a>

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
```