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