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.
# Client-side Verschlüsselung auf Feldebene
Mit der clientseitigen Verschlüsselung auf Feldebene (FLE) von Amazon DocumentDB können Sie sensible Daten in Ihren Client-Anwendungen verschlüsseln, bevor sie in einen Amazon DocumentDB-Cluster übertragen werden. Vertrauliche Daten bleiben verschlüsselt, wenn sie in einem Cluster gespeichert und verarbeitet werden, und werden beim Abrufen in der Client-Anwendung entschlüsselt.
**Topics**
+ [Erste Schritte](#fle-getting-started)
+ [Abfragen in der clientseitigen FLE](#fle-querying)
## Erste Schritte
Die Erstkonfiguration der clientseitigen FLE in Amazon DocumentDB ist ein vierstufiger Prozess, der die Erstellung eines Verschlüsselungsschlüssels, die Zuordnung einer Rolle zur Anwendung, die Konfiguration der Anwendung und die Definition des CRUD-Vorgangs mit Verschlüsselungsoptionen umfasst.
**Topics**
+ [Schritt 1: Erstellen Sie die Verschlüsselungsschlüssel](#fle-step-create-key)
+ [Schritt 2: Ordnen Sie der Anwendung eine Rolle zu](#fle-step-associate-role)
+ [Schritt 3: Konfigurieren Sie die Anwendung](#fle-step-config-app)
+ [Schritt 4: Definieren Sie eine CRUD-Operation](#fle-step-crud-ops)
+ [Beispiel: Konfigurationsdatei für die clientseitige Verschlüsselung auf Feldebene](#fle-config-example)
### Schritt 1: Erstellen Sie die Verschlüsselungsschlüssel
Erstellen Sie mithilfe AWS Key Management Service eines symmetrischen Schlüssels, der zum Verschlüsseln und Entschlüsseln des vertraulichen Datenfeldes verwendet wird, und erteilen Sie ihm die erforderlichen IAM-Nutzungsberechtigungen. AWS KMS speichert den Kundenschlüssel (CK), der zur Verschlüsselung von Datenschlüsseln (DKs) verwendet wird. Speichert den Kundenschlüssel in KMS, um Ihre Sicherheitslage zu stärken. Der Datenschlüssel ist der Sekundärschlüssel, der in einer Amazon DocumentDB-Sammlung gespeichert wird und benötigt wird, um sensible Felder zu verschlüsseln, bevor das Dokument in Amazon DocumentDB gespeichert wird. Der Kundenschlüssel verschlüsselt den Datenschlüssel, der wiederum Ihre Daten ver- und entschlüsselt. Wenn Sie einen globalen Cluster verwenden, können Sie einen Schlüssel für mehrere Regionen erstellen, der von verschiedenen Servicerollen in verschiedenen Regionen verwendet werden kann.
Weitere Informationen zum AWS Key Management Service, einschließlich der Erstellung eines Schlüssels, finden Sie im [AWS Key Management Service Developer Guide](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
### Schritt 2: Ordnen Sie der Anwendung eine Rolle zu
Erstellen Sie eine IAM-Richtlinie mit den entsprechenden AWS KMS Berechtigungen. Diese Richtlinie ermöglicht es IAM-Identitäten, an die sie angehängt ist, den im Ressourcenfeld angegebenen KMS-Schlüssel zu verschlüsseln und zu entschlüsseln. Ihre Anwendung nimmt diese IAM-Rolle für die Authentifizierung an. AWS KMS
Die Richtlinie sollte etwa wie folgt aussehen:
```
{ "Effect": "Allow",
"Action": ["kms:Decrypt", "kms:Encrypt"],
"Resource": "Customer Key ARN"
}
```
### Schritt 3: Konfigurieren Sie die Anwendung
Inzwischen haben Sie einen Kundenschlüssel definiert AWS KMS und eine IAM-Rolle erstellt und ihr die richtigen IAM-Berechtigungen für den Zugriff auf den Kundenschlüssel erteilt. Importieren Sie die erforderlichen Pakete.
```
import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
ClientEncryption)
```
```
# create a session object:
my_session = boto3.session.Session()
# get access_key and secret_key programmatically using get_frozen_credentials() method:
current_credentials = my_session.get_credentials().get_frozen_credentials()
```
1. Geben Sie „aws“ als KMS-Anbietertyp an und geben Sie Ihre Kontoanmeldeinformationen ein, die Sie im vorherigen Schritt abgerufen haben.
```
provider = "aws"
kms_providers = {
provider: {
"accessKeyId": current_credentials.access_key,
"secretAccessKey": current_credentials.secret_key
}
}
```
1. Geben Sie den Kundenschlüssel an, der zur Verschlüsselung des Datenschlüssels verwendet wird:
```
customer_key = {
“region”: “AWS region of the customer_key”,
“key”: “customer_key ARN”
}
key_vault_namespace = "encryption.dataKeys"
key_alt_name = 'TEST_DATA_KEY'
```
1. Konfigurieren Sie das MongoClient Objekt:
```
client = MongoClient(connection_string)
coll = client.test.coll
coll.drop()
client_encryption = ClientEncryption(
kms_providers, # pass in the kms_providers variable from the previous step
key_vault_namespace = key_vault_namespace,
client,
coll.codec_options
)
```
1. Generieren Sie Ihren Datenschlüssel:
```
data_key_id = client_encryption.create_data_key(provider,
customer_key,
key_alt_name = [key_alt_name])
```
1. Rufen Sie Ihren vorhandenen Datenschlüssel ab:
```
data_key = DataKey("aws",
master_key = customer_key)
key_id = data_key["_id"]
data_key_id = client[key_vault_namespace].find_one({"_id": key_id})
```
### Schritt 4: Definieren Sie eine CRUD-Operation
Definieren Sie den CRUD-Vorgang mit Verschlüsselungsoptionen.
1. Definiert die Sammlung so, dass write/read ein einzelnes Dokument gelöscht wird:
```
coll = client.gameinfo.users
```
1. Explizite Verschlüsselung — Felder verschlüsseln und Folgendes einfügen:
**Anmerkung**
Es muss genau einer der Werte „key\_id“ oder „key\_alt\_name“ angegeben werden.
```
encrypted_first_name = client_encryption.encrypt(
"Jane",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_id=data_key_id
)
encrypted_last_name = client_encryption.encrypt(
"Doe",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_id=data_key_id
)
encrypted_dob = client_encryption.encrypt(
"1990-01-01",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Random,
key_id=data_key_id
)
coll.insert_one(
{"gamerTag": "jane_doe90",
"firstName": encrypted_first_name,
"lastName": encrypted_last_name,
"dateOfBirth":encrypted_dob,
"Favorite_games":["Halo","Age of Empires 2","Medal of Honor"]
})
```
### Beispiel: Konfigurationsdatei für die clientseitige Verschlüsselung auf Feldebene
Ersetzen Sie im folgenden Beispiel jede {{placeholder}} durch Ihre eigenen Informationen.
```
# import python packages:
import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
ClientEncryption)
def main():
# create a session object:
my_session = boto3.session.Session()
# get aws_region from session object:
aws_region = my_session.region_name
# get access_key and secret_key programmatically using get_frozen_credentials() method:
current_credentials = my_session.get_credentials().get_frozen_credentials()
provider = "aws"
# define the kms_providers which is later used to create the Data Key:
kms_providers = {
provider: {
"accessKeyId": current_credentials.access_key,
"secretAccessKey": current_credentials.secret_key
}
}
# enter the kms key ARN. Replace the example ARN value.
kms_arn = "{{arn:aws:kms:us-east-1:123456789:key/abcd-efgh-ijkl-mnop}}"
customer_key = {
"region": aws_region,
"key":kms_arn
}
# secrets manager is used to store and retrieve user credentials for connecting to an Amazon DocumentDB cluster.
# retrieve the secret using the secret name. Replace the example secret key.
secret_name = "{{/dev/secretKey}}"
docdb_credentials = json.loads(my_session.client(service_name = 'secretsmanager', region_name = "us-east-1").get_secret_value(SecretId = secret_name)['SecretString'])
connection_params = '/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false'
conn_str = 'mongodb://' + docdb_credentials["username"] + ':' + docdb_credentials["password"] + '@' + docdb_credentials["host"] + ':' + str(docdb_credentials["port"]) + connection_params
client = MongoClient(conn_str)
coll = client.test.coll
coll.drop()
# store the encryption data keys in a key vault collection (having naming convention as db.collection):
key_vault_namespace = "encryption.dataKeys"
key_vault_db_name, key_vault_coll_name = key_vault_namespace.split(".", 1)
# set up the key vault (key_vault_namespace) for this example:
key_vault = client[key_vault_db_name][key_vault_coll_name]
key_vault.drop()
key_vault.create_index("keyAltNames", unique=True)
client_encryption = ClientEncryption(
kms_providers,
key_vault_namespace,
client,
coll.codec_options)
# create a new data key for the encrypted field:
data_key_id = client_encryption.create_data_key(provider, master_key=customer_key, key_alt_names=["some_key_alt_name"], key_material = None)
# explicitly encrypt a field:
encrypted_first_name = client_encryption.encrypt(
"Jane",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_id=data_key_id
)
coll.insert_one(
{"gamerTag": "jane_doe90",
"firstName": encrypted_first_name
})
doc = coll.find_one()
print('Encrypted document: %s' % (doc,))
# explicitly decrypt the field:
doc["firstName"] = client_encryption.decrypt(doc["firstName"])
print('Decrypted document: %s' % (doc,))
# cleanup resources:
client_encryption.close()
client.close()
if __name__ == "__main__":
main()
```
## Abfragen in der clientseitigen FLE
Amazon DocumentDB unterstützt nur Gleichheitsabfragen mit clientseitigen FLE-verschlüsselten Werten.
Um beispielsweise Dokumente abzufragen, bei denen der verschlüsselte Gamerscore 500 entspricht, verwendet der Client eine explizite Verschlüsselungsmethode, um den Abfragewert zu verschlüsseln:
```
encrypted_gamerscore_filter = client_encryption.encrypt(
500,
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_id=data_key_id
)
coll.find( {
"gamerscore" : { "$eq" : encrypted_gamerscore_filter }
} )
```