Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Protection des données dans Amazon DocumentDB
Le modèle de [responsabilité AWS partagée Le modèle](https://aws.amazon.com/compliance/shared-responsibility-model/) s'applique à la protection des données dans Amazon DocumentDB (avec compatibilité avec MongoDB). Comme décrit dans ce modèle, AWS est chargé de protéger l'infrastructure mondiale qui gère tous les AWS Cloud. La gestion du contrôle de votre contenu hébergé sur cette infrastructure relève de votre responsabilité. Vous êtes également responsable des tâches de configuration et de gestion de la sécurité des Services AWS que vous utilisez. Pour plus d’informations sur la confidentialité des données, consultez [Questions fréquentes (FAQ) sur la confidentialité des données](https://aws.amazon.com/compliance/data-privacy-faq/). Pour en savoir plus sur la protection des données en Europe, consultez le billet de blog Modèle de responsabilité partagée [AWS et RGPD (Règlement général sur la protection des données)](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) sur le *Blog de sécuritéAWS *.
À des fins de protection des données, nous vous recommandons de protéger les Compte AWS informations d'identification et de configurer les utilisateurs individuels avec AWS IAM Identity Center ou Gestion des identités et des accès AWS (IAM). Ainsi, chaque utilisateur se voit attribuer uniquement les autorisations nécessaires pour exécuter ses tâches. Nous vous recommandons également de sécuriser vos données comme indiqué ci-dessous :
+ Utilisez l’authentification multifactorielle (MFA) avec chaque compte.
+ Utilisez le protocole SSL/TLS pour communiquer avec les ressources. AWS Nous exigeons TLS 1.2 et recommandons TLS 1.3.
+ Configurez l'API et la journalisation de l'activité des utilisateurs avec AWS CloudTrail. Pour plus d'informations sur l'utilisation des CloudTrail sentiers pour capturer AWS des activités, consultez la section [Utilisation des CloudTrail sentiers](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) dans le *guide de AWS CloudTrail l'utilisateur*.
+ Utilisez des solutions de AWS chiffrement, ainsi que tous les contrôles de sécurité par défaut qu'ils contiennent Services AWS.
+ Utilisez des services de sécurité gérés avancés tels qu’Amazon Macie, qui contribuent à la découverte et à la sécurisation des données sensibles stockées dans Amazon S3.
+ Si vous avez besoin de modules cryptographiques validés par la norme FIPS 140-3 pour accéder AWS via une interface de ligne de commande ou une API, utilisez un point de terminaison FIPS. Pour plus d’informations sur les points de terminaison FIPS disponibles, consultez [Norme FIPS (Federal Information Processing Standard) 140-3](https://aws.amazon.com/compliance/fips/).
Nous vous recommandons fortement de ne jamais placer d’informations confidentielles ou sensibles, telles que les adresses e-mail de vos clients, dans des balises ou des champs de texte libre tels que le champ **Nom**. Cela inclut lorsque vous travaillez avec Amazon DocumentDB ou autre à Services AWS l'aide de la console, de l'API ou. AWS CLI AWS SDKs Toutes les données que vous entrez dans des balises ou des champs de texte de forme libre utilisés pour les noms peuvent être utilisées à des fins de facturation ou dans les journaux de diagnostic. Si vous fournissez une adresse URL à un serveur externe, nous vous recommandons fortement de ne pas inclure d’informations d’identification dans l’adresse URL permettant de valider votre demande adressée à ce serveur.
**Topics**
+ [Chiffrement au niveau des champs côté client](field-level-encryption.md)
+ [Chiffrement de données au repos](encryption-at-rest.md)
+ [chiffrement des données en transit](security.encryption.ssl.md)
+ [Gestion des clés](security.encryption.ssl.public-key.md)
# Chiffrement au niveau des champs côté client
Le chiffrement au niveau du champ (FLE) côté client Amazon DocumentDB vous permet de chiffrer les données sensibles dans vos applications clientes avant qu'elles ne soient transférées vers un cluster Amazon DocumentDB. Les données sensibles restent cryptées lorsqu'elles sont stockées et traitées dans un cluster et sont déchiffrées dans l'application cliente lorsqu'elles sont récupérées.
**Topics**
+ [Premiers pas](#fle-getting-started)
+ [Interrogation dans un fichier FLE côté client](#fle-querying)
+ [Limites](#fle-limitationa)
## Premiers pas
La configuration initiale du FLE côté client dans Amazon DocumentDB est un processus en quatre étapes qui comprend la création d'une clé de chiffrement, l'association d'un rôle à l'application, la configuration de l'application et la définition du fonctionnement du CRUD avec des options de chiffrement.
**Topics**
+ [Étape 1 : Création des clés de chiffrement](#fle-step-create-key)
+ [Étape 2 : associer un rôle à l'application](#fle-step-associate-role)
+ [Étape 3 : Configuration de l'application](#fle-step-config-app)
+ [Étape 4 : Définition d'une opération CRUD](#fle-step-crud-ops)
+ [Exemple : fichier de configuration du chiffrement des champs côté client](#fle-config-example)
### Étape 1 : Création des clés de chiffrement
À l'aide de AWS Key Management Service, créez une clé symétrique utilisée pour chiffrer et déchiffrer le champ de données sensibles et fournissez-lui les autorisations d'utilisation IAM nécessaires. AWS KMS stocke la clé client (CK) qui est utilisée pour chiffrer les clés de données (DKs). Nous vous recommandons de stocker la clé client dans KMS pour renforcer votre niveau de sécurité. La clé de données est la clé secondaire qui est stockée dans une collection Amazon DocumentDB et qui est requise pour chiffrer les champs sensibles avant de stocker le document dans Amazon DocumentDB. La clé client chiffre la clé de données qui, à son tour, chiffre et déchiffre vos données. Si vous utilisez un cluster mondial, vous pouvez créer une clé multirégionale qui peut être utilisée par différents rôles de service dans différentes régions.
Pour plus d'informations sur le AWS Key Management Service, notamment sur la façon de créer une clé, consultez le [Guide du développeur du service de gestion des AWS clés](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
### Étape 2 : associer un rôle à l'application
Créez une politique IAM avec les AWS KMS autorisations appropriées. Cette politique permet aux identités IAM auxquelles elle est attachée de chiffrer et de déchiffrer la clé KMS spécifiée dans le champ de ressource. Votre application assume ce rôle IAM pour s'authentifier. AWS KMS
La politique doit ressembler à ceci :
```
{ "Effect": "Allow",
"Action": ["kms:Decrypt", "kms:Encrypt"],
"Resource": "Customer Key ARN"
}
```
### Étape 3 : Configuration de l'application
À ce jour, vous avez défini une clé client, créé un rôle IAM et lui avez fourni les autorisations IAM appropriées pour accéder à la clé client. AWS KMS Importez les packages obligatoires.
```
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. Spécifiez « aws » comme type de fournisseur KMS et saisissez les informations d'identification de votre compte qui ont été récupérées à l'étape précédente.
```
provider = "aws"
kms_providers = {
provider: {
"accessKeyId": current_credentials.access_key,
"secretAccessKey": current_credentials.secret_key
}
}
```
1. Spécifiez la clé client qui est utilisée pour chiffrer la clé de données :
```
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. Configurez MongoClient l'objet :
```
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. Générez votre clé de données :
```
data_key_id = client_encryption.create_data_key(provider,
customer_key,
key_alt_name = [key_alt_name])
```
1. Récupérez votre clé de données existante :
```
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})
```
### Étape 4 : Définition d'une opération CRUD
Définissez l'opération CRUD avec les options de chiffrement.
1. Définissez la collection en write/read/delete un seul document :
```
coll = client.gameinfo.users
```
1. Chiffrement explicite : cryptez les champs et insérez :
**Note**
Exactement l'un des « key\$1id » ou « key\$1alt\$1name » doit être fourni.
```
encrypted_first_name = client_encryption.encrypt(
"Jane",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
encrypted_last_name = client_encryption.encrypt(
"Doe",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
encrypted_dob = client_encryption.encrypt(
"1990-01-01",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Random,
key_alt_name=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"]
})
```
### Exemple : fichier de configuration du chiffrement des champs côté client
Dans l'exemple suivant, remplacez chacune *user input placeholder* par vos propres informations.
```
# 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 strore 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["encryptedField"] = client_encryption.decrypt(doc["encryptedField"])
print('Decrypted document: %s' % (doc,))
# cleanup resources:
client_encryption.close()
client.close()
if __name__ == "__main__":
main()
```
## Interrogation dans un fichier FLE côté client
Amazon DocumentDB prend en charge les requêtes d'égalité de points avec le FLE côté client. Les requêtes d'inégalité et de comparaison peuvent renvoyer des résultats inexacts. Les opérations de lecture et d'écriture peuvent avoir un comportement inattendu ou incorrect par rapport à l'exécution de la même opération sur la valeur déchiffrée.
Par exemple, pour interroger les filtres de documents dont le score de joueur est supérieur à 500 :
```
db.users.find( {
"gamerscore" : { $gt : 500 }
})
```
Le client utilise une méthode de chiffrement explicite pour chiffrer la valeur de la requête :
```
encrypted_gamerscore_filter = client_encryption.encrypt(
500,
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
db.users.find( {
"gamerscore" : { $gt : encrypted_gamerscore_filter }
} )
```
Lors de l'opération de recherche, Amazon DocumentDB compare la valeur chiffrée de 500 aux valeurs de champ chiffrées stockées dans chaque document à l'aide du contrôle supérieur à l'inégalité. Le contrôle d'inégalité dans l'opération de recherche peut renvoyer un résultat différent lorsqu'il est effectué à l'aide de données et de valeurs déchiffrées, même si l'opération parvient à générer des résultats.
## Limites
Les limites suivantes s'appliquent au chiffrement des champs côté client Amazon DocumentDB :
+ Amazon DocumentDB ne prend en charge que les requêtes d'égalité de points. Les requêtes d'inégalité et de comparaison peuvent renvoyer des résultats inexacts. Les opérations de lecture et d'écriture peuvent avoir un comportement inattendu ou incorrect par rapport à l'exécution de la même opération sur la valeur déchiffrée. Pour interroger les filtres pour les documents dont le score de joueur est supérieur à 500.
```
db.users.find( {
"gamerscore" : { $gt : 500 }
})
```
Le client utilise une méthode de chiffrement explicite pour chiffrer la valeur de la requête.
```
encrypted_gamerscore_filter = client_encryption.encrypt(
500,
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
db.users.find({
"gamerscore" : { $gt : encrypted_gamerscore_filter }
})
```
Lors de l'opération de recherche, Amazon DocumentDB compare la valeur chiffrée de 500 aux valeurs de champ chiffrées stockées dans chaque document à l'aide du contrôle supérieur à l'inégalité. Le contrôle d'inégalité dans l'opération de recherche peut renvoyer un résultat différent lorsqu'il est effectué à l'aide de données et de valeurs déchiffrées, même si l'opération parvient à générer des résultats.
+ Amazon DocumentDB ne prend pas en charge le FLE explicite côté client à partir du Mongo Shell. Cependant, cette fonctionnalité fonctionne avec tous nos pilotes pris en charge.
# Chiffrement des données Amazon DocumentDB au repos
**Note**
AWS KMS remplace le terme *clé principale du client (CMK)* par *AWS KMS key**clé KMS*. Le concept n'a pas changé. Pour éviter des modifications AWS KMS intempestives, certaines variantes de ce terme sont conservées.
Vous cryptez les données au repos dans votre cluster Amazon DocumentDB en spécifiant l'option de chiffrement du stockage lorsque vous créez votre cluster. Le chiffrement du stockage est activé au niveau du cluster et appliqué à toutes les instances, y compris l'instance principale et toutes les réplicas. Elle est également appliquée au volume de stockage, aux données, aux index, aux journaux, aux sauvegardes automatisées et aux instantanés de votre cluster.
Amazon DocumentDB utilise la norme de chiffrement avancée 256 bits (AES-256) pour chiffrer vos données à l'aide des clés de chiffrement stockées dans (). AWS Key Management Service AWS KMS Lorsque vous utilisez un cluster Amazon DocumentDB avec le chiffrement au repos activé, vous n'avez pas besoin de modifier la logique de votre application ou votre connexion client. Amazon DocumentDB gère le chiffrement et le déchiffrement de vos données de manière transparente, avec un impact minimal sur les performances.
Amazon DocumentDB intègre AWS KMS et utilise une méthode connue sous le nom de chiffrement d'enveloppe pour protéger vos données. Lorsqu'un cluster Amazon DocumentDB est chiffré avec un AWS KMS, Amazon DocumentDB vous AWS KMS demande d'utiliser votre clé KMS pour [générer une clé de données chiffrée afin de chiffrer le](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) volume de stockage. La clé de données chiffrée est chiffrée à l'aide de la clé KMS que vous définissez et est stockée avec les données chiffrées et les métadonnées de stockage. Lorsqu'Amazon DocumentDB a besoin d'accéder à vos données chiffrées, elle demande de déchiffrer la clé de données chiffrée AWS KMS à l'aide de votre clé KMS et met en cache la clé de données en texte brut en mémoire pour chiffrer et déchiffrer efficacement les données du volume de stockage.
La fonction de chiffrement du stockage d'Amazon DocumentDB est disponible pour toutes les tailles d'instance prises en charge et partout Régions AWS où Amazon DocumentDB est disponible.
## Activation du chiffrement au repos pour un cluster Amazon DocumentDB
Vous pouvez activer ou désactiver le chiffrement au repos sur un cluster Amazon DocumentDB lorsque le cluster est provisionné à l'aide du AWS Management Console ou du AWS Command Line Interface ().AWS CLI Le chiffrement au repos est activé par défaut pour les clusters que vous créez à l'aide de la console. Le chiffrement au repos est désactivé par défaut pour AWS CLI les clusters que vous créez à l'aide du. Par conséquent, vous devez activer explicitement le chiffrement au repos à l'aide du paramètre `--storage-encrypted`. Dans les deux cas, une fois le cluster créé, vous ne pouvez pas modifier l'option de chiffrement au repos.
Amazon DocumentDB permet AWS KMS de récupérer et de gérer les clés de chiffrement, ainsi que de définir les politiques qui contrôlent la manière dont ces clés peuvent être utilisées. Si vous ne spécifiez aucun identifiant de AWS KMS clé, Amazon DocumentDB utilise la clé KMS du service AWS géré par défaut. Amazon DocumentDB crée une clé KMS distincte pour chaque Région AWS élément de votre. Compte AWS Pour plus d'informations, consultez [Concepts AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html).
Pour commencer à créer votre propre clé KMS, consultez [Getting Started](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) dans le *guide du AWS Key Management Service développeur*.
**Important**
Vous devez utiliser une clé KMS de chiffrement symétrique pour chiffrer votre cluster car Amazon DocumentDB ne prend en charge que les clés KMS de chiffrement symétriques. N'utilisez pas de clé KMS asymétrique pour tenter de chiffrer les données de vos clusters Amazon DocumentDB. Pour plus d'informations, consultez la section [Clés asymétriques AWS KMS dans](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) le *guide du AWS Key Management Service développeur*.
Si Amazon DocumentDB ne peut plus accéder à la clé de chiffrement d'un cluster, par exemple, lorsque l'accès à une clé est révoqué, le cluster chiffré passe à l'état terminal. Dans ce cas, vous pouvez uniquement restaurer le cluster à partir d'une sauvegarde. Pour Amazon DocumentDB, les sauvegardes sont toujours activées pendant 1 jour.
En outre, si vous désactivez la clé d'un cluster Amazon DocumentDB chiffré, vous finirez par perdre l'accès en lecture et en écriture à ce cluster. Lorsqu'Amazon DocumentDB rencontre un cluster chiffré par une clé à laquelle il n'a pas accès, le cluster passe à l'état terminal. Dans cet état, le cluster n'est plus disponible et l'état actuel de la base de données ne peut pas être récupéré. Pour restaurer le cluster, vous devez réactiver l'accès à la clé de chiffrement pour Amazon DocumentDB, puis restaurer le cluster à partir d'une sauvegarde.
**Important**
Vous ne pouvez pas modifier la clé KMS d'un cluster chiffré une fois que vous l'avez déjà créé. Assurez-vous donc de déterminer vos besoins en termes de clés de chiffrement avant de créer votre cluster chiffré.
------
#### [ Using the AWS Management Console ]
Vous spécifiez l'option chiffrement au repos lorsque vous créez un cluster. Le chiffrement au repos est activé par défaut lorsque vous créez un cluster à l'aide de la AWS Management Console. Il ne peut pas être modifié après la création du cluster.
**Pour spécifier l'option de chiffrement au repos, lors de la création de votre cluster**
1. Créez un cluster Amazon DocumentDB comme décrit dans la section [Getting Started](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.launch-cluster.html). Toutefois, à l'étape 6, ne choisissez pas **Create cluster (Créer un cluster)**.
1. Sous la section **Authentication (Authentification** ), choisissez **Show advanced settings (Afficher les paramètres avancés)**.
1. Faites défiler la page vers le bas jusqu'à ncryption-at-rest la section **E.**
1. Choisissez l'option souhaitée pour le chiffrement au repos. Quelle que soit l'option choisie, vous ne pouvez pas la modifier après la création du cluster.
+ Pour chiffrer les données au repos dans ce cluster, choisissez **Enable encryption (Activer le chiffrement)**.
+ Si vous ne souhaitez pas chiffrer les données au repos dans ce cluster, choisissez **Disable encryption (Désactiver le chiffrement)**.
1. Choisissez la clé primaire que vous souhaitez. Amazon DocumentDB utilise le AWS Key Management Service (AWS KMS) pour récupérer et gérer les clés de chiffrement, et pour définir les politiques qui contrôlent la manière dont ces clés peuvent être utilisées. Si vous ne spécifiez aucun identifiant de AWS KMS clé, Amazon DocumentDB utilise la clé KMS du service AWS géré par défaut. Pour plus d'informations, consultez [Concepts AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html).
**Note**
Après avoir créé un cluster chiffré, vous ne pouvez pas modifier la clé KMS de ce cluster. Assurez-vous donc de déterminer vos besoins en termes de clés de chiffrement avant de créer votre cluster chiffré.
1. Complétez les autres sections selon vos besoins et créez votre cluster.
------
#### [ Using the AWS CLI ]
Pour chiffrer un cluster Amazon DocumentDB à l'aide de, exécutez AWS CLI la commande et spécifiez [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html)`--storage-encrypted`l'option. Les clusters Amazon DocumentDB créés à l'aide de l'option AWS CLI Ne pas activer le chiffrement du stockage par défaut.
L'exemple suivant crée un cluster Amazon DocumentDB avec le chiffrement du stockage activé.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
**Example**
Pour Linux, macOS ou Unix :
```
aws docdb create-db-cluster \
--db-cluster-identifier mydocdbcluster \
--port 27017 \
--engine docdb \
--master-username SampleUser1 \
--master-user-password primaryPassword \
--storage-encrypted
```
Pour Windows :
```
aws docdb create-db-cluster ^
--db-cluster-identifier SampleUser1 ^
--port 27017 ^
--engine docdb ^
--master-username SampleUser1 ^
--master-user-password primaryPassword ^
--storage-encrypted
```
Lorsque vous créez un cluster Amazon DocumentDB chiffré, vous pouvez spécifier un identifiant de AWS KMS clé, comme dans l'exemple suivant.
**Example**
Pour Linux, macOS ou Unix :
```
aws docdb create-db-cluster \
--db-cluster-identifier SampleUser1 \
--port 27017 \
--engine docdb \
--master-username primaryUsername \
--master-user-password yourPrimaryPassword \
--storage-encrypted \
--kms-key-id key-arn-or-alias
```
Pour Windows :
```
aws docdb create-db-cluster ^
--db-cluster-identifier SampleUser1 ^
--port 27017 ^
--engine docdb ^
--master-username SampleUser1 ^
--master-user-password primaryPassword ^
--storage-encrypted ^
--kms-key-id key-arn-or-alias
```
**Note**
Après avoir créé un cluster chiffré, vous ne pouvez pas modifier la clé KMS de ce cluster. Assurez-vous donc de déterminer vos besoins en termes de clés de chiffrement avant de créer votre cluster chiffré.
------
## Limitations applicables aux clusters chiffrés Amazon DocumentDB
Les limitations suivantes s'appliquent aux clusters chiffrés Amazon DocumentDB.
+ Vous pouvez activer ou désactiver le chiffrement au repos pour un cluster Amazon DocumentDB uniquement au moment de sa création, et non après la création du cluster. Toutefois, vous pouvez créer une copie chiffrée d'un cluster non chiffré en créant un instantané du cluster non chiffré, puis en restaurant l'instantané non chiffré en tant que nouveau cluster tout en spécifiant l'option de chiffrement au repos.
Pour plus d’informations, consultez les rubriques suivantes :
+ [Création d'un instantané de cluster manuel](backup_restore-create_manual_cluster_snapshot.md)
+ [Restauration à partir d'un instantané de cluster](backup_restore-restore_from_snapshot.md)
+ [Copier des instantanés du cluster Amazon DocumentDB](backup_restore-copy_cluster_snapshot.md)
+ Les clusters Amazon DocumentDB sur lesquels le chiffrement du stockage est activé ne peuvent pas être modifiés pour désactiver le chiffrement.
+ Toutes les instances, les sauvegardes automatisées, les instantanés et les index d'un cluster Amazon DocumentDB sont chiffrés avec la même clé KMS.
# chiffrement des données en transit
Vous pouvez utiliser le protocole TLS (Transport Layer Security) pour chiffrer la connexion entre votre application et un cluster Amazon DocumentDB. Par défaut, le chiffrement en transit est activé pour les clusters Amazon DocumentDB nouvellement créés. Il peut éventuellement être désactivé lors de la création du cluster, ou ultérieurement. Lorsque le chiffrement en transit est activé, des connexions sécurisées à l'aide de TLS sont nécessaires pour se connecter au cluster. Pour plus d'informations sur la connexion à Amazon DocumentDB à l'aide de TLS, veuillez consulter [Connexion par programmation à Amazon DocumentDB](connect_programmatically.md).
## Gestion des paramètres TLS du cluster Amazon DocumentDB
Le chiffrement en transit pour un cluster Amazon DocumentDB est géré via le paramètre TLS dans un [groupe de paramètres de cluster](https://docs.aws.amazon.com/documentdb/latest/developerguide/cluster_parameter_groups.html). Vous pouvez gérer les paramètres TLS de votre cluster Amazon DocumentDB à l'aide du AWS Management Console ou du AWS Command Line Interface ().AWS CLI Consultez les sections suivantes pour savoir comment vérifier et modifier vos paramètres TLS actuels.
------
#### [ Using the AWS Management Console ]
Suivez ces étapes pour effectuer les tâches de gestion du chiffrement TLS à l'aide de la console, telles que l'identification des groupes de paramètres, la vérification de la valeur TLS et les modifications nécessaires.
**Note**
À moins de le spécifier différemment lors de la création d’un cluster, votre cluster est créé avec le groupe de paramètres de cluster par défaut. Les paramètres du groupe de paramètres de cluster `default` ne peuvent pas être modifiés (par exemple, `tls` activé/désactivé). Par conséquent, si votre cluster utilise un groupe de paramètres de cluster `default`, vous devez modifier le cluster pour utiliser un groupe de paramètres de cluster autre que par défaut. Tout d'abord, vous allez peut-être devoir créer un groupe de paramètres de cluster personnalisé. Pour de plus amples informations, veuillez consulter [Création de groupes de paramètres de cluster Amazon DocumentDB](cluster_parameter_groups-create.md).
1. **Déterminez le groupe de paramètres de cluster utilisé par votre cluster.**
1. [Ouvrez la console Amazon DocumentDB à https://console.aws.amazon.com l'adresse /docdb.](https://console.aws.amazon.com/docdb)
1. Dans le panneau de navigation, choisissez **Clusters**.
**Astuce**
Si vous ne voyez pas le volet de navigation sur le côté gauche de votre écran, choisissez l'icône de menu (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/fr_fr/documentdb/latest/developerguide/images/docdb-menu-icon.png)) dans le coin supérieur gauche de la page.
1. Notez que dans la zone de navigation **Clusters**, la colonne **Cluster Identifier** indique à la fois les clusters et les instances. Les instances sont répertoriées sous les clusters. Voir la capture d'écran ci-dessous pour référence.
![\[Image de la boîte de navigation Clusters présentant une liste des liens de cluster existants et leurs liens d'instance correspondants.\]](http://docs.aws.amazon.com/fr_fr/documentdb/latest/developerguide/images/clusters.png)
1. Choisissez le cluster qui vous intéresse.
1. Choisissez l'onglet **Configuration**, faites défiler la page jusqu'en bas de la section **Détails du cluster** et localisez le **groupe de paramètres du cluster**. Notez le nom du groupe de paramètres de cluster.
Si le nom du groupe de paramètres du cluster est `default`, par exemple `default.docdb3.6`, vous devez créer un groupe de paramètres de cluster personnalisé et le désigner groupe de paramètres du cluster avant de continuer. Pour plus d’informations, consultez les ressources suivantes :
1. [Création de groupes de paramètres de cluster Amazon DocumentDB](cluster_parameter_groups-create.md)— Si vous ne disposez pas d'un groupe de paramètres de cluster personnalisé que vous pouvez utiliser, créez-en un.
1. [Modification d'un cluster Amazon DocumentDB](db-cluster-modify.md)— Modifiez votre cluster pour utiliser le groupe de paramètres de cluster personnalisé.
1. **Déterminez la valeur actuelle du paramètre de cluster `tls`.**
1. [Ouvrez la console Amazon DocumentDB à https://console.aws.amazon.com l'adresse /docdb.](https://console.aws.amazon.com/docdb)
1. Dans le panneau de navigation, choisissez **Groupes de paramètres**.
1. Dans la liste des groupes de paramètres de cluster, choisissez le nom du groupe qui vous intéresse.
1. Recherchez la section **Cluster parameters (Paramètres de cluster)**. Dans la liste des paramètres de cluster, recherchez la ligne de paramètre de cluster `tls`. À ce stade, les quatre colonnes suivantes sont importantes :
+ **Nom du paramètre du cluster** : nom des paramètres du cluster. Pour gérer TLS, intéressez-vous au paramètre de cluster `tls`.
+ **Valeurs** — La valeur actuelle de chaque paramètre de cluster.
+ **Valeurs autorisées** : liste de valeurs pouvant être appliquées à un paramètre de cluster.
+ **Type d'application** : **statique** ou **dynamique**. Les modifications apportées aux paramètres de cluster statiques ne peuvent être appliquées que lorsque les instances sont redémarrées. Les modifications apportées aux paramètres de cluster dynamiques peuvent être appliquées immédiatement ou lorsque les instances sont redémarrées.
1. **Modifiez la valeur du paramètre de cluster `tls`.**
Si la valeur de `tls` n'est pas la valeur requise, modifiez-la pour ce groupe de paramètres de cluster. Pour modifier la valeur du paramètre de cluster `tls`, continuez à partir de la section précédente en suivant les étapes ci-dessous.
1. Choisissez le bouton à gauche du nom du paramètre de cluster (`tls`).
1. Choisissez **Modifier**.
1. Pour modifier la valeur de`tls`, dans la boîte de `tls` dialogue **Modifier**, choisissez la valeur que vous souhaitez pour le paramètre de cluster dans la liste déroulante.
Les valeurs valides sont :
+ **désactivé — Désactive** le protocole TLS
+ **activé** — Active les versions TLS 1.0 à 1.3.
+ **fips-140-3** — Active le protocole TLS avec FIPS. Le cluster accepte uniquement les connexions sécurisées conformément aux exigences de la publication 140-3 des Federal Information Processing Standards (FIPS). Ceci n'est pris en charge qu'à partir des clusters Amazon DocumentDB 5.0 (moteur version 3.0.3727) dans les régions suivantes : ca-central-1, us-west-2, us-east-1, us-east-2, -1, -1. us-gov-east us-gov-west
+ **tls1.2\$1** — Active TLS version 1.2 et supérieure. Ceci n'est pris en charge qu'à partir d'Amazon DocumentDB 4.0 (version du moteur 2.0.10980) et Amazon DocumentDB (version du moteur 3.0.11051).
+ **tls1.3\$1** — Active TLS version 1.3 et supérieure. Ceci n'est pris en charge qu'à partir d'Amazon DocumentDB 4.0 (version du moteur 2.0.10980) et Amazon DocumentDB (version du moteur 3.0.11051).
![\[Image d'une boîte de dialogue de modification TLS spécifique au cluster.\]](http://docs.aws.amazon.com/fr_fr/documentdb/latest/developerguide/images/modify-tls.png)
1. Choisissez **Modifier le paramètre de cluster**. La modification est appliquée à chaque instance de cluster lors de son redémarrage.
1. **Redémarrez l'instance Amazon DocumentDB.**
Redémarrez chaque instance du cluster de sorte que la modification s'applique à toutes les instances du cluster.
1. [Ouvrez la console Amazon DocumentDB à https://console.aws.amazon.com l'adresse /docdb.](https://console.aws.amazon.com/docdb)
1. Dans le panneau de navigation, choisissez **Instances**.
1. Pour spécifier une instance à redémarrer, recherchez celle-ci dans la liste des instances et choisissez le bouton à gauche de son nom.
1. Choisissez **Actions**, puis **Reboot (Redémarrer)**. Confirmez que vous souhaitez redémarrer en choisissant **Reboot (Redémarrer)**.
------
#### [ Using the AWS CLI ]
Suivez ces étapes pour effectuer des tâches de gestion du chiffrement TLS à l'aide du, AWS CLI telles que l'identification des groupes de paramètres, la vérification de la valeur TLS et les modifications nécessaires.
**Note**
À moins de le spécifier différemment lors de la création d’un cluster, le cluster est créé avec le groupe de paramètres de cluster par défaut. Les paramètres du groupe de paramètres de cluster `default` ne peuvent pas être modifiés (par exemple, `tls` activé/désactivé). Par conséquent, si votre cluster utilise un groupe de paramètres de cluster `default`, vous devez modifier le cluster pour utiliser un groupe de paramètres de cluster autre que par défaut. Tout d'abord, vous allez peut-être devoir créer un groupe de paramètres de cluster personnalisé. Pour de plus amples informations, veuillez consulter [Création de groupes de paramètres de cluster Amazon DocumentDB](cluster_parameter_groups-create.md).
1. **Déterminez le groupe de paramètres de cluster utilisé par votre cluster.**
Exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html)commande avec les options suivantes :
+ `--db-cluster-identifier`
+ `--query`
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
aws docdb describe-db-clusters \
--db-cluster-identifier mydocdbcluster \
--query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'
```
Le résultat de cette opération ressemble à ce qui suit (format JSON) :
```
[
[
"mydocdbcluster",
"myparametergroup"
]
]
```
Si le nom du groupe de paramètres du cluster est `default`, par exemple `default.docdb3.6`, vous devez disposer d'un groupe de paramètres de cluster personnalisé et le désigner groupe de paramètres du cluster avant de continuer. Pour plus d’informations, consultez les rubriques suivantes :
1. [Création de groupes de paramètres de cluster Amazon DocumentDB](cluster_parameter_groups-create.md)— Si vous ne disposez pas d'un groupe de paramètres de cluster personnalisé que vous pouvez utiliser, créez-en un.
1. [Modification d'un cluster Amazon DocumentDB](db-cluster-modify.md)— Modifiez votre cluster pour utiliser le groupe de paramètres de cluster personnalisé.
1. **Déterminez la valeur actuelle du paramètre de cluster `tls`.**
Pour obtenir plus d'informations sur ce groupe de paramètres de cluster, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-cluster-parameters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-cluster-parameters.html)commande avec les options suivantes :
+ `--db-cluster-parameter-group-name`
+ `--query`
Limite le résultat aux seuls champs d'intérêt : `ParameterName``ParameterValue`,`AllowedValues`, et`ApplyType`.
Dans l'exemple suivant, remplacez chacune *user input placeholder* par les informations de votre cluster.
```
aws docdb describe-db-cluster-parameters \
--db-cluster-parameter-group-name myparametergroup \
--query 'Parameters[*].[ParameterName,ParameterValue,AllowedValues,ApplyType]'
```
Le résultat de cette opération ressemble à ce qui suit (format JSON) :
```
[
[
"audit_logs",
"disabled",
"enabled,disabled",
"dynamic"
],
[
"tls",
"disabled",
"disabled,enabled,fips-140-3,tls1.2+,tls1.3+",
"static"
],
[
"ttl_monitor",
"enabled",
"disabled,enabled",
"dynamic"
]
]
```
1. **Modifiez la valeur du paramètre de cluster `tls`.**
Si la valeur de `tls` n'est pas la valeur requise, modifiez-la pour ce groupe de paramètres de cluster. Pour modifier la valeur du paramètre de `tls` cluster, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/modify-db-cluster-parameter-group.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/modify-db-cluster-parameter-group.html)commande avec les options suivantes :
+ `--db-cluster-parameter-group-name` — Obligatoire. Nom du groupe de paramètres de cluster à modifier. Il ne peut pas s'agir d'un groupe de paramètres de cluster `default.*`.
+ `--parameters` — Obligatoire. Liste des paramètres du groupe de paramètres de cluster à modifier.
+ `ParameterName` — Obligatoire. Nom du paramètre de cluster à modifier.
+ `ParameterValue` — Obligatoire. Nouvelle valeur pour ce paramètre de cluster. Il doit s'agir de l'une des valeurs `AllowedValues` des paramètres de cluster.
+ `enabled`— Le cluster accepte les connexions sécurisées utilisant les versions TLS 1.0 à 1.3.
+ `disabled`— Le cluster n'accepte pas les connexions sécurisées utilisant le protocole TLS.
+ `fips-140-3`— Le cluster accepte uniquement les connexions sécurisées conformément aux exigences de la publication 140-3 des Federal Information Processing Standards (FIPS). Ceci n'est pris en charge qu'à partir des clusters Amazon DocumentDB 5.0 (moteur version 3.0.3727) dans les régions suivantes : ca-central-1, us-west-2, us-east-1, us-east-2, -1, -1. us-gov-east us-gov-west
+ `tls1.2+`— Le cluster accepte les connexions sécurisées utilisant le protocole TLS version 1.2 ou ultérieure. Ceci n'est pris en charge qu'à partir d'Amazon DocumentDB 4.0 (version du moteur 2.0.10980) et Amazon DocumentDB 5.0 (version du moteur 3.0.11051).
+ `tls1.3+`— Le cluster accepte les connexions sécurisées utilisant le protocole TLS version 1.3 ou supérieure. Ceci n'est pris en charge qu'à partir d'Amazon DocumentDB 4.0 (version du moteur 2.0.10980) et Amazon DocumentDB 5.0 (version du moteur 3.0.11051).
+ `ApplyMethod`— Quand cette modification doit être appliquée. Pour les paramètres de cluster statiques, tels que `tle`, cette valeur doit être `pending-reboot`.
+ `pending-reboot`— La modification n'est appliquée à une instance qu'après son redémarrage. Vous devez redémarrer chaque instance de cluster individuellement pour que cette modification soit appliquée sur l'ensemble des instances du cluster.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
Le code suivant *est désactivé`tls`,* en appliquant la modification à chaque instance lors de son redémarrage.
```
aws docdb modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name myparametergroup \
--parameters "ParameterName=tls,ParameterValue=disabled,ApplyMethod=pending-reboot"
```
Le code suivant *permet* `tls` (versions 1.0 à 1.3) d'appliquer la modification à chaque instance lors de son redémarrage.
```
aws docdb modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name myparametergroup \
--parameters "ParameterName=tls,ParameterValue=enabled,ApplyMethod=pending-reboot"
```
Le code suivant *active* TLS with`fips-140-3`, en appliquant la modification à chaque instance lors de son redémarrage.
```
aws docdb modify-db-cluster-parameter-group \
‐‐db-cluster-parameter-group-name myparametergroup2 \
‐‐parameters "ParameterName=tls,ParameterValue=fips-140-3,ApplyMethod=pending-reboot"
```
Le résultat de cette opération ressemble à ce qui suit (format JSON) :
```
{
"DBClusterParameterGroupName": "myparametergroup"
}
```
1. **Redémarrez votre instance Amazon DocumentDB.**
Redémarrez chaque instance du cluster de sorte que la modification s'applique à toutes les instances du cluster. Pour redémarrer une instance Amazon DocumentDB, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/reboot-db-instance.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/reboot-db-instance.html)commande avec l'option suivante :
+ `--db-instance-identifier`
Le code suivant redémarre l'instance `mydocdbinstance`.
Dans les exemples suivants, remplacez chacun *user input placeholder* par les informations de votre cluster.
**Example**
Pour Linux, macOS ou Unix :
```
aws docdb reboot-db-instance \
--db-instance-identifier mydocdbinstance
```
Pour Windows :
```
aws docdb reboot-db-instance ^
--db-instance-identifier mydocdbinstance
```
Le résultat de cette opération ressemble à ce qui suit (format JSON) :
```
{
"DBInstance": {
"AutoMinorVersionUpgrade": true,
"PubliclyAccessible": false,
"PreferredMaintenanceWindow": "fri:09:32-fri:10:02",
"PendingModifiedValues": {},
"DBInstanceStatus": "rebooting",
"DBSubnetGroup": {
"Subnets": [
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1a"
},
"SubnetIdentifier": "subnet-4e26d263"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1c"
},
"SubnetIdentifier": "subnet-afc329f4"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1e"
},
"SubnetIdentifier": "subnet-b3806e8f"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1d"
},
"SubnetIdentifier": "subnet-53ab3636"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1b"
},
"SubnetIdentifier": "subnet-991cb8d0"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1f"
},
"SubnetIdentifier": "subnet-29ab1025"
}
],
"SubnetGroupStatus": "Complete",
"DBSubnetGroupDescription": "default",
"VpcId": "vpc-91280df6",
"DBSubnetGroupName": "default"
},
"PromotionTier": 2,
"DBInstanceClass": "db.r5.4xlarge",
"InstanceCreateTime": "2018-11-05T23:10:49.905Z",
"PreferredBackupWindow": "00:00-00:30",
"KmsKeyId": "arn:aws:kms:us-east-1:012345678901:key/0961325d-a50b-44d4-b6a0-a177d5ff730b",
"StorageEncrypted": true,
"VpcSecurityGroups": [
{
"Status": "active",
"VpcSecurityGroupId": "sg-77186e0d"
}
],
"EngineVersion": "3.6.0",
"DbiResourceId": "db-SAMPLERESOURCEID",
"DBInstanceIdentifier": "mydocdbinstance",
"Engine": "docdb",
"AvailabilityZone": "us-east-1a",
"DBInstanceArn": "arn:aws:rds:us-east-1:012345678901:db:sample-cluster-instance-00",
"BackupRetentionPeriod": 1,
"Endpoint": {
"Address": "mydocdbinstance.corcjozrlsfc.us-east-1.docdb.amazonaws.com",
"Port": 27017,
"HostedZoneId": "Z2R2ITUGPM61AM"
},
"DBClusterIdentifier": "mydocdbcluster"
}
}
```
Le redémarrage de votre instance prend quelques minutes. Vous pouvez uniquement utiliser l'instance lorsqu'elle présente le statut *disponible*. Vous pouvez surveiller l'état de l'instance en utilisant la console ou la AWS CLI. Pour de plus amples informations, veuillez consulter [Surveillance de l'état d'une instance Amazon DocumentDB](monitoring_docdb-instance_status.md).
------
# Gestion des clés
Amazon DocumentDB utilise AWS Key Management Service (AWS KMS) pour récupérer et gérer les clés de chiffrement. AWS KMS combine du matériel et des logiciels sécurisés et hautement disponibles pour fournir un système de gestion des clés adapté au cloud. À l'aide de AWS KMS, vous pouvez créer des clés de chiffrement et définir les politiques qui contrôlent la manière dont ces clés peuvent être utilisées. AWS KMS prend en charge AWS CloudTrail, afin que vous puissiez auditer l'utilisation des clés pour vérifier que les clés sont utilisées de manière appropriée.
Vos AWS KMS clés peuvent être utilisées en combinaison avec Amazon DocumentDB et les AWS services pris en charge tels qu'Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS), Amazon Elastic Block Store (Amazon EBS) et Amazon Redshift. Pour obtenir la liste des services compatibles AWS KMS, consultez la section [Comment les AWS services sont utilisés AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/service-integration.html) dans le *Guide du AWS Key Management Service développeur*. Pour plus d'informations AWS KMS, voir [Qu'est-ce que c'est AWS Key Management Service ?](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)