# Konfigurationsspeicher

Der Konfigurationsspeicher (Storage) ist ein in FIRERPA integrierter, persistenter Schlüssel-Wert-Speicher. Selbst wenn FIRERPA oder das Gerät neu gestartet wird, können Sie diese Variablen beim nächsten Start immer noch lesen. Dieser Storage ermöglicht es Ihnen, Informationen dauerhaft auf dem Gerät zu speichern, damit verschiedene Client-Prozesse sie lesen können, um Gerätekonfigurationen wie Anmeldekonten oder andere unabhängige Informationen zu teilen. Sie können sogar verschlüsselte Konfigurationen auf dem Gerät speichern.

```{attention}
Die Gesamtkapazität des integrierten Storage beträgt 128 MB. Bitte verwenden Sie ihn nicht zur Speicherung großer Datenmengen. Das Auflisten von Containernamen oder Schlüsselnamen im Speicher wird nicht unterstützt. Sie müssen den vollständigen Containernamen und den Schlüsselnamen kennen, um einen Wert aus dem Container zu lesen, andernfalls kann der Wert nicht mehr abgerufen werden.
```

## Storage abrufen

Mit dem folgenden Code können Sie ein Storage-Objekt abrufen, um nachfolgende Operationen durchzuführen.

```python
storage = d.stub("Storage")
```

## Storage leeren

Mit dem folgenden Code können Sie alle Informationen im Storage leeren, einschließlich der Container. Sie können dies als eine Formatierung des Storage verstehen.

```python
storage.clear()
```

## Container abrufen

Mit dem folgenden Code können Sie ein Schlüssel-Wert-Speicher-Container-Objekt abrufen. Der Speicher ist der Speicher, und ein Container ist ein "Bucket" innerhalb des Speichers. Alle nachfolgenden Lese- und Schreibvorgänge werden auf diesen Bucket angewendet.

```python
container = storage.use("container_name")
```

## Verschlüsselten Container abrufen

Wenn Sie Werte sicher speichern müssen, zum Beispiel wenn das Gerät von anderen Personen verwendet wird und Sie nicht möchten, dass Ihre gespeicherten Konfigurationen von anderen gelesen werden, können Sie einen verschlüsselten Container verwenden. Im Gegensatz zum einfachen Abrufen eines Containers speichert ein verschlüsselter Container Ihre Schlüssel-Wert-Paare verschlüsselt. Andere Personen benötigen ein Passwort oder eine andere Form der Authentifizierung, um die Daten korrekt zu lesen.

Unsere Bibliothek enthält einen FernetCryptor für die Ver- und Entschlüsselung. Sie können auch Ihren eigenen einzigartigen Verschlüsselungsalgorithmus implementieren, indem Sie dem Beispiel von FernetCryptor folgen. Sie müssen lediglich die Methoden `encrypt` und `decrypt` implementieren.

```python
from lamda.client import FernetCryptor
container = storage.use("container_name", cryptor=FernetCryptor,
                                          key="this_is_password")
```

## Container löschen

Mit dem folgenden Code können Sie alle im Container mit dem Namen `container_name` gespeicherten Schlüssel-Wert-Paare löschen. Diese Operation entspricht dem Löschen des Buckets.

```python
storage.remove("container_name")
```

## Schlüssel-Wert-Paar in den Container schreiben

Mit den folgenden Beispielaufrufen können Sie den Wert von `key_name` auf "value" setzen. Der Wert unterstützt jede Variable, die mit msgpack serialisierbar ist.

```python
container.set("key_name", [1, 2, 3])
container.set("key_name", {"john": "due"})
container.set("key_name", b"value")
container.set("key_name", "value")
```

## Schlüssel-Wert-Paar aus dem Container lesen

Mit der folgenden Methode können Sie den Wert von `key_name` abrufen. Wenn der Schlüssel nicht existiert, wird `None` zurückgegeben.

```python
container.get("key_name")
```

## Lebensdauer abrufen

Mit dem folgenden Aufruf können Sie die Lebensdauer (TTL) von `key_name` abrufen. `-2` bedeutet, dass der Schlüssel nicht existiert, `-1` bedeutet, dass er nie abläuft, und jede andere positive ganze Zahl gibt die verbleibende Lebensdauer des Schlüssels in Sekunden an.

```python
container.ttl("key_name")
```

## Lebensdauer festlegen

Mit dem folgenden Aufruf können Sie die Lebensdauer eines Schlüssel-Wert-Paares festlegen. Der folgende Aufruf setzt beispielsweise den Schlüssel-Wert und sorgt dafür, dass er nach 10 Sekunden automatisch gelöscht wird.

```python
container.setex("key_name", "value", 10)
```

Wenn Sie den Schlüssel bereits gesetzt haben und nun seine Lebensdauer festlegen möchten, können Sie dies wie folgt tun. Nach 60 Sekunden wird `key_name` automatisch gelöscht.

```python
container.expire("key_name", 60)
```

## Bedingtes Schreiben

Sie können den folgenden Aufruf verwenden, um den Schlüssel-Wert nur dann zu setzen, wenn `key_name` noch nicht existiert. Wenn der Schlüssel bereits vorhanden ist, wird keine Aktion ausgeführt.

```python
container.setnx("key_name", "value")
```

## Existenz prüfen

Mit dem folgenden Aufruf können Sie überprüfen, ob `key_name` im Container vorhanden ist.

```python
container.exists("key_name")
```

## Schlüssel-Wert-Paar aus dem Container löschen

Mit dem folgenden Aufruf können Sie `key_name` und seinen Wert aus dem Container löschen.

```python
container.delete("key_name")
```