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. # Configuration des balises **** | | | --- | | Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). | Il existe deux types de balises qui prennent en charge le chiffrement consultable. Les balises standard effectuent des recherches d'égalité. Ils constituent le moyen le plus simple d'implémenter le chiffrement consultable dans votre base de données. Les balises composées combinent des chaînes de texte en clair littérales et des balises standard pour effectuer des requêtes plus complexes. Les balises sont conçues pour être mises en œuvre dans de nouvelles bases de données non peuplées. Toute balise configurée dans une base de données existante ne mappera que les nouveaux enregistrements écrits dans la base de données. Les balises sont calculées à partir de la valeur en texte brut d'un champ. Une fois le champ crypté, il n'est plus possible pour la balise de mapper les données existantes. Une fois que vous avez écrit de nouveaux enregistrements avec une balise, vous ne pouvez pas mettre à jour la configuration de la balise. Cependant, vous pouvez ajouter de nouvelles balises pour les nouveaux champs que vous ajoutez à votre enregistrement. Après avoir déterminé vos modèles d'accès, la configuration des balises doit être la deuxième étape de l'implémentation de votre base de données. Ensuite, après avoir configuré toutes vos balises, vous devez créer un jeu de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md), définir la version de la balise, [configurer un index secondaire pour chaque balise](ddb-searchable-encryption.md#ddb-beacon-indexes), définir vos [actions cryptographiques](concepts.md#crypt-actions) et configurer votre base de données et le client du SDK AWS Database Encryption. Pour plus d'informations, consultez la section [Utilisation de balises](using-beacons.md). Pour faciliter la définition de la version des balises, nous vous recommandons de créer des listes pour les balises standard et composées. Ajoutez chaque balise que vous créez à la liste de balises standard ou composée correspondante au fur et à mesure de sa configuration. **Topics** + [Configuration des balises standard](#config-standard-beacons) + [Configuration de balises composées](#config-compound-beacons) + [Exemples de configuration](beacon-config-examples.md) ## Configuration des balises standard Les [balises standard](beacons.md#standard-beacon-overview) constituent le moyen le plus simple d'implémenter un chiffrement consultable dans votre base de données. Ils ne peuvent effectuer des recherches d'égalité que pour un seul champ crypté ou virtuel. ### Exemple de syntaxe de configuration ------ #### [ Java ] ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("beaconName") .length(beaconLengthInBits) .build(); standardBeaconList.add(exampleStandardBeacon); ``` ------ #### [ C\$1 / .NET ] ``` var standardBeaconList = new List(); StandardBeacon exampleStandardBeacon = new StandardBeacon { Name = "beaconName", Length = 10 }; standardBeaconList.Add(exampleStandardBeacon); ``` ------ #### [ Rust ] ``` let standard_beacon_list = vec![ StandardBeacon::builder().name("beacon_name").length(beacon_length_in_bits).build()?, ``` ------ Pour configurer une balise standard, fournissez les valeurs suivantes. **Nom de la balise** Le nom que vous utilisez lorsque vous interrogez un champ chiffré. Le nom d'une balise peut être le même que celui d'un champ crypté ou d'un champ virtuel, mais il ne peut pas être le même que celui d'un champ non chiffré. Nous vous recommandons vivement d'utiliser le nom du champ crypté ou du [champ virtuel](beacons.md#virtual-field) à partir duquel votre balise standard est construite dans la mesure du possible. Deux balises différentes ne peuvent pas porter le même nom de balise. Pour obtenir de l'aide pour déterminer le meilleur nom de balise pour votre implémentation, consultez [Choisir un nom de balise](choosing-beacon-name.md). **Longueur de la balise** Nombre de bits de la valeur de hachage de la balise conservés après la troncature. La longueur de la balise détermine le nombre moyen de faux positifs produits par une balise donnée. Pour plus d'informations et pour vous aider à déterminer la longueur de balise appropriée pour votre implémentation, consultez la section [Détermination de la longueur de balise](choosing-beacon-length.md). **Source de balise (facultatif)** Champ à partir duquel une balise standard est construite. La source de la balise doit être un nom de champ ou un index faisant référence à la valeur d'un champ imbriqué. Lorsque le nom de votre balise est identique à celui de la source de la balise, vous pouvez omettre la source de la balise dans votre configuration et le SDK de chiffrement de AWS base de données utilisera automatiquement le nom de la balise comme source de balise. ### Création d'un champ virtuel Pour créer un [champ virtuel](beacons.md#virtual-field), vous devez fournir un nom pour le champ virtuel et une liste des champs sources. L'ordre dans lequel vous ajoutez les champs source à la liste des pièces virtuelles détermine l'ordre dans lequel ils sont concaténés pour créer le champ virtuel. L'exemple suivant concatène deux champs source dans leur intégralité pour créer un champ virtuel. **Note** Nous vous recommandons de vérifier que vos champs virtuels produisent le résultat attendu avant de remplir votre base de données. Pour plus d'informations, consultez la section [Tester les sorties des balises](ddb-searchable-encryption.md#ddb-beacon-testing). ------ #### [ Java ] **Voir l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/VirtualBeaconSearchableEncryptionExample.java) ``` List virtualPartList = new ArrayList<>(); virtualPartList.add(sourceField1); virtualPartList.add(sourceField2); VirtualField virtualFieldName = VirtualField.builder() .name("virtualFieldName") .parts(virtualPartList) .build(); List virtualFieldList = new ArrayList<>(); virtualFieldList.add(virtualFieldName); ``` ------ #### [ C\$1 / .NET ] **Voir l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/VirtualBeaconSearchableEncryptionExample.cs) ``` var virtualPartList = new List { sourceField1, sourceField2 }; var virtualFieldName = new VirtualField { Name = "virtualFieldName", Parts = virtualPartList }; var virtualFieldList = new List { virtualFieldName }; ``` ------ #### [ Rust ] **Voir l'exemple de code complet** : [virtual\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/virtual_beacon_searchable_encryption.rs) ``` let virtual_part_list = vec![source_field_one, source_field_two]; let state_and_has_test_result_field = VirtualField::builder() .name("virtual_field_name") .parts(virtual_part_list) .build()?; let virtual_field_list = vec![virtual_field_name]; ``` ------ Pour créer un champ virtuel avec un segment spécifique d'un champ source, vous devez définir cette transformation avant d'ajouter le champ source à votre liste de pièces virtuelles. #### Considérations relatives à la sécurité des champs virtuels Les balises ne modifient pas l'état chiffré du champ. Cependant, lorsque vous utilisez des balises, il existe un compromis inhérent entre l'efficacité de vos requêtes et la quantité d'informations révélées sur la distribution de vos données. La façon dont vous configurez votre balise détermine le niveau de sécurité préservé par cette balise. Évitez de créer un champ virtuel dont les champs source se chevauchent avec les balises standard existantes. La création de champs virtuels incluant un champ source qui a déjà été utilisé pour créer une balise standard peut réduire le niveau de sécurité des deux balises. L'ampleur de la réduction de la sécurité dépend du niveau d'entropie ajouté par les champs source supplémentaires. Le niveau d'entropie est déterminé par la distribution de valeurs uniques dans le champ source supplémentaire et par le nombre de bits que le champ source supplémentaire contribue à la taille globale du champ virtuel. Vous pouvez utiliser la population et la [longueur des balises](choosing-beacon-length.md) pour déterminer si les champs source d'un champ virtuel préservent la sécurité de votre ensemble de données. La population est le nombre attendu de valeurs uniques dans un champ. Votre population n'a pas besoin d'être précise. Pour obtenir de l'aide pour estimer la population d'un champ, voir [Estimer la population](choosing-beacon-length.md#estimate-population). Examinez l'exemple suivant lorsque vous examinez la sécurité de vos champs virtuels. + Beacon1 est construit à partir de. `FieldA` `FieldA`a une population supérieure à **2 (longueur de Beacon1**). + Beacon2 est construit à partir de`VirtualField`, qui est construit à partir de`FieldA`, `FieldB``FieldC`, et. `FieldD` Ensemble, `FieldB``FieldC`, et `FieldD` ont une population supérieure à **2 N** Beacon2 préserve la sécurité de Beacon1 et de Beacon2 si les affirmations suivantes sont vraies : ``` N ≥ (Beacon1 length)/2 ``` and ``` N ≥ (Beacon2 length)/2 ``` ### Définition des styles de balises Les balises standard peuvent être utilisées pour effectuer des recherches d'égalité pour un champ crypté ou virtuel. Ils peuvent également être utilisés pour créer des balises composées afin d'effectuer des opérations de base de données plus complexes. Pour vous aider à organiser et à gérer les balises standard, le SDK AWS de chiffrement de base de données fournit les *styles de balises facultatifs suivants qui définissent l'utilisation prévue d'une balise* standard. **Note** Pour définir les styles de balises, vous devez utiliser la version 3.2 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant d'ajouter des styles de balises à vos configurations de balises. ------ #### [ PartOnly ] Une balise standard définie comme ne `PartOnly` peut être utilisée que pour définir une [partie cryptée](#encrypted-parts) d'une balise composée. Vous ne pouvez pas interroger directement une balise `PartOnly` standard. **Java** ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("beaconName") .length(beaconLengthInBits) .style( BeaconStyle.builder() .partOnly(PartOnly.builder().build()) .build() ) .build(); standardBeaconList.add(exampleStandardBeacon); ``` **C\$1//.NET** ``` new StandardBeacon { Name = "beaconName", Length = beaconLengthInBits, Style = new BeaconStyle { PartOnly = new PartOnly() } } ``` **Rust** ``` StandardBeacon::builder() .name("beacon_name") .length(beacon_length_in_bits) .style(BeaconStyle::PartOnly(PartOnly::builder().build()?)) .build()? ``` ------ #### [ Shared ] Par défaut, chaque balise standard génère une clé HMAC unique pour le calcul de la balise. Par conséquent, vous ne pouvez pas effectuer de recherche d'égalité sur les champs chiffrés à partir de deux balises standard distinctes. Une balise standard définie comme `Shared` utilise la clé HMAC d'une autre balise standard pour ses calculs. Par exemple, si vous devez comparer des `beacon1` champs à des `beacon2` champs, `beacon2` définissez-les comme une `Shared` balise qui utilise la clé HMAC de `beacon1` pour ses calculs. **Note** Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `Shared` balises. `Shared`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler quels champs partagés contiennent la même valeur en texte brut. **Java** ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("beacon2") .length(beaconLengthInBits) .style( BeaconStyle.builder() .shared(Shared.builder().other("beacon1").build()) .build() ) .build(); standardBeaconList.add(exampleStandardBeacon); ``` **C\$1//.NET** ``` new StandardBeacon { Name = "beacon2", Length = beaconLengthInBits, Style = new BeaconStyle { Shared = new Shared { Other = "beacon1" } } } ``` **Rust** ``` StandardBeacon::builder() .name("beacon2") .length(beacon_length_in_bits) .style(BeaconStyle::Shared( Shared::builder().other("beacon1").build()?, )) .build()? ``` ------ #### [ AsSet ] Par défaut, si la valeur d'un champ est un ensemble, le SDK AWS de chiffrement de base de données calcule une balise standard unique pour l'ensemble. Par conséquent, vous ne pouvez pas exécuter la requête `CONTAINS(a, :value)` où se `a` trouve un champ crypté. Une balise standard définie comme `AsSet` calcule des valeurs de balise standard individuelles pour chaque élément individuel de l'ensemble et stocke la valeur de balise dans l'élément sous forme d'ensemble. Cela permet au SDK AWS de chiffrement de base de données d'exécuter la requête`CONTAINS(a, :value)`. Pour définir une balise `AsSet` standard, les éléments de l'ensemble doivent appartenir à la même population afin qu'ils puissent tous utiliser la même [longueur de balise](choosing-beacon-length.md). L'ensemble de balises peut comporter moins d'éléments que le jeu de texte en clair en cas de collisions lors du calcul des valeurs des balises. **Note** Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `AsSet` balises. `AsSet`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler la taille de l'ensemble de texte en clair. **Java** ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("beaconName") .length(beaconLengthInBits) .style( BeaconStyle.builder() .asSet(AsSet.builder().build()) .build() ) .build(); standardBeaconList.add(exampleStandardBeacon); ``` **C\$1//.NET** ``` new StandardBeacon { Name = "beaconName", Length = beaconLengthInBits, Style = new BeaconStyle { AsSet = new AsSet() } } ``` **Rust** ``` StandardBeacon::builder() .name("beacon_name") .length(beacon_length_in_bits) .style(BeaconStyle::AsSet(AsSet::builder().build()?)) .build()? ``` ------ #### [ SharedSet ] Une balise standard définie comme `SharedSet` combine les `AsSet` fonctions `Shared` et afin que vous puissiez effectuer des recherches d'égalité sur les valeurs cryptées d'un ensemble et d'un champ. Cela permet au SDK AWS de chiffrement de base de données d'exécuter la requête `CONTAINS(a, b)` lorsqu'il `a` s'agit d'un ensemble chiffré et `b` d'un champ chiffré. **Note** Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `Shared` balises. `SharedSet`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler la taille de l'ensemble de texte en clair ou les champs partagés contenant la même valeur en texte brut. **Java** ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("beacon2") .length(beaconLengthInBits) .style( BeaconStyle.builder() .sharedSet(SharedSet.builder().other("beacon1").build()) .build() ) .build(); standardBeaconList.add(exampleStandardBeacon); ``` **C\$1//.NET** ``` new StandardBeacon { Name = "beacon2", Length = beaconLengthInBits, Style = new BeaconStyle { SharedSet = new SharedSet { Other = "beacon1" } } } ``` **Rust** ``` StandardBeacon::builder() .name("beacon2") .length(beacon_length_in_bits) .style(BeaconStyle::SharedSet( SharedSet::builder().other("beacon1").build()?, )) .build()? ``` ------ ## Configuration de balises composées Les balises composées combinent des chaînes de texte brut littérales et des balises standard pour effectuer des opérations de base de données complexes, telles que l'interrogation de deux types d'enregistrement différents à partir d'un seul index ou l'interrogation d'une combinaison de champs à l'aide d'une clé de tri. Les balises composées peuvent être construites à partir de `ENCRYPT_AND_SIGN``SIGN_ONLY`, et de `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champs. Vous devez créer une balise standard pour chaque champ chiffré inclus dans la balise composée. **Note** Nous vous recommandons de vérifier que vos balises composées produisent le résultat attendu avant de remplir votre base de données. Pour plus d'informations, consultez la section [Tester les sorties des balises](ddb-searchable-encryption.md#ddb-beacon-testing). ### Exemple de syntaxe de configuration ------ #### [ Java ] **Configuration de balise composée** L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées. ``` List compoundBeaconList = new ArrayList<>(); CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder() .name("compoundBeaconName") .split(".") .encrypted(encryptedPartList) .signed(signedPartList) .constructors(constructorList) .build(); compoundBeaconList.add(exampleCompoundBeacon); ``` **Définition de la version de la balise** L'exemple suivant définit les listes de pièces chiffrées et signées de manière globale dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section [Utilisation des balises](using-beacons.md). ``` List beaconVersions = new ArrayList<>(); beaconVersions.add( BeaconVersion.builder() .standardBeacons(standardBeaconList) .compoundBeacons(compoundBeaconList) .encryptedParts(encryptedPartList) .signedParts(signedPartList) .version(1) // MUST be 1 .keyStore(keyStore) .keySource(BeaconKeySource.builder() .single(SingleKeyStore.builder() .keyId(branchKeyId) .cacheTTL(6000) .build()) .build()) .build() ); ``` ------ #### [ C\$1 / .NET ] **Voir l'exemple de code complet** : [BeaconConfig.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/complexexample/BeaconConfig.cs) **Configuration de balise composée** L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées. ``` var compoundBeaconList = new List(); var exampleCompoundBeacon = new CompoundBeacon { Name = "compoundBeaconName", Split = ".", Encrypted = encryptedPartList, Signed = signedPartList, Constructors = constructorList }; compoundBeaconList.Add(exampleCompoundBeacon); ``` **Définition de la version de la balise** L'exemple suivant définit les listes de pièces chiffrées et signées de manière globale dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section [Utilisation des balises](using-beacons.md). ``` var beaconVersions = new List { new BeaconVersion { StandardBeacons = standardBeaconList, CompoundBeacons = compoundBeaconList, EncryptedParts = encryptedPartsList, SignedParts = signedPartsList, Version = 1, // MUST be 1 KeyStore = keyStore, KeySource = new BeaconKeySource { Single = new SingleKeyStore { KeyId = branchKeyId, CacheTTL = 6000 } } } }; ``` ------ #### [ Rust ] **Voir l'exemple de code complet** : [beacon\$1config.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/complexexample/beacon_config.rs) **Configuration de balise composée** L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées. ``` let compound_beacon_list = vec![ CompoundBeacon::builder() .name("compound_beacon_name") .split(".") .encrypted(encrypted_parts_list) .signed(signed_parts_list) .constructors(constructor_list) .build()? ``` **Définition de la version de la balise** L'exemple suivant définit les listes de pièces chiffrées et signées de manière globale dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section [Utilisation des balises](using-beacons.md). ``` let beacon_versions = BeaconVersion::builder() .standard_beacons(standard_beacon_list) .compound_beacons(compound_beacon_list) .encrypted_parts(encrypted_parts_list) .signed_parts(signed_parts_list) .version(1) // MUST be 1 .key_store(key_store.clone()) .key_source(BeaconKeySource::Single( SingleKeyStore::builder() .key_id(branch_key_id) .cache_ttl(6000) .build()?, )) .build()?; let beacon_versions = vec![beacon_versions]; ``` ------ Vous pouvez définir vos [parties chiffrées](#encrypted-parts) et vos [parties signées](#signed-parts) dans des listes définies localement ou globalement. Nous vous recommandons de définir vos parties cryptées et signées dans une liste globale dans la [version balise](using-beacons.md#beacon-version) dans la mesure du possible. En définissant les parties chiffrées et signées de manière globale, vous pouvez définir chaque partie une seule fois, puis les réutiliser dans plusieurs configurations de balises composées. Si vous n'avez l'intention d'utiliser une pièce chiffrée ou signée qu'une seule fois, vous pouvez la définir dans une liste locale dans la configuration des balises composées. Vous pouvez référencer des pièces locales et globales dans votre [liste de constructeurs](#constructor-parts). Si vous définissez vos listes de pièces chiffrées et signées de manière globale, vous devez fournir une liste de composants du constructeur identifiant toutes les manières possibles dont la balise composée peut assembler les champs dans votre configuration de balise composée. **Note** Pour définir des listes de pièces chiffrées et signées de manière globale, vous devez utiliser la version 3.2 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de définir de nouvelles pièces de manière globale. Vous ne pouvez pas mettre à jour les configurations de balises existantes pour définir des listes de pièces chiffrées et signées dans le monde entier. Pour configurer une balise composée, fournissez les valeurs suivantes. **Nom de la balise** Le nom que vous utilisez lorsque vous interrogez un champ chiffré. Le nom d'une balise peut être le même que celui d'un champ crypté ou d'un champ virtuel, mais il ne peut pas être le même que celui d'un champ non chiffré. Deux balises ne peuvent pas porter le même nom de balise. Pour obtenir de l'aide pour déterminer le meilleur nom de balise pour votre implémentation, consultez [Choisir un nom de balise](choosing-beacon-name.md). **Caractère divisé** Le caractère utilisé pour séparer les parties qui composent votre balise composée. Le caractère divisé ne peut apparaître dans les valeurs en texte brut d'aucun des champs à partir desquels la balise composée est construite. **Liste de pièces cryptée** Identifie les `ENCRYPT_AND_SIGN` champs inclus dans la balise composée. Chaque partie doit inclure un nom et un préfixe. Le nom de pièce doit être le nom de la balise standard construite à partir du champ crypté. Le préfixe peut être n'importe quelle chaîne, mais il doit être unique. Une pièce chiffrée ne peut pas avoir le même préfixe qu'une pièce signée. Nous recommandons d'utiliser une valeur courte qui distingue la pièce des autres parties desservies par la balise composée. Nous vous recommandons de définir vos parties cryptées de manière globale dans la mesure du possible. Vous pouvez envisager de définir une partie chiffrée localement si vous avez l'intention de ne l'utiliser que dans une seule balise composée. Une partie cryptée définie localement ne peut pas avoir le même préfixe ou le même nom qu'une partie cryptée définie globalement. ``` List encryptedPartList = new ArrayList<>(); EncryptedPart encryptedPartExample = EncryptedPart.builder() .name("standardBeaconName") .prefix("E-") .build(); encryptedPartList.add(encryptedPartExample); ``` ``` var encryptedPartList = new List(); var encryptedPartExample = new EncryptedPart { Name = "compoundBeaconName", Prefix = "E-" }; encryptedPartList.Add(encryptedPartExample); ``` ``` let encrypted_parts_list = vec![ EncryptedPart::builder() .name("standard_beacon_name") .prefix("E-") .build()? ]; ``` **Liste de pièces signée** Identifie les champs signés inclus dans la balise composée. Les pièces signées sont facultatives. Vous pouvez configurer une balise composée qui ne fait référence à aucune pièce signée. Chaque partie doit inclure un nom, une source et un préfixe. La source est le `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champ `SIGN_ONLY` ou que l'article identifie. La source doit être un nom de champ ou un index faisant référence à la valeur d'un champ imbriqué. Si le nom de votre pièce identifie la source, vous pouvez omettre la source et le SDK AWS de chiffrement de base de données utilisera automatiquement le nom comme source. Nous recommandons de spécifier la source comme nom de pièce dans la mesure du possible. Le préfixe peut être n'importe quelle chaîne, mais il doit être unique. Une pièce signée ne peut pas avoir le même préfixe qu'une pièce chiffrée. Nous recommandons d'utiliser une valeur courte qui distingue la pièce des autres parties desservies par la balise composée. Nous vous recommandons de définir vos pièces signées de manière globale dans la mesure du possible. Vous pouvez envisager de définir une pièce signée localement si vous avez l'intention de ne l'utiliser que dans une seule balise composée. Une pièce signée définie localement ne peut pas avoir le même préfixe ou le même nom qu'une pièce signée définie globalement. ``` List signedPartList = new ArrayList<>(); SignedPart signedPartExample = SignedPart.builder() .name("signedFieldName") .prefix("S-") .build(); signedPartList.add(signedPartExample); ``` ``` var signedPartsList = new List { new SignedPart { Name = "signedFieldName1", Prefix = "S-" }, new SignedPart { Name = "signedFieldName2", Prefix = "SF-" } }; ``` ``` let signed_parts_list = vec![ SignedPart::builder() .name("signed_field_name_1") .prefix("S-") .build()?, SignedPart::builder() .name("signed_field_name_2") .prefix("SF-") .build()?, ]; ``` **Liste des constructeurs** Identifie les *constructeurs* qui définissent les différentes manières dont les pièces cryptées et signées peuvent être assemblées par la balise composée. Vous pouvez référencer des pièces locales et globales dans votre liste de constructeurs. Si vous créez votre balise composée à partir de pièces chiffrées et signées définies globalement, vous devez fournir une liste de constructeurs. Si vous n'utilisez aucune pièce chiffrée ou signée définie globalement pour construire votre balise composée, la liste des constructeurs est facultative. Si vous ne spécifiez pas de liste de constructeurs, le SDK AWS Database Encryption assemble la balise composée avec le constructeur par défaut suivant. + Toutes les pièces signées dans l'ordre dans lequel elles ont été ajoutées à la liste des pièces signées + Toutes les pièces cryptées dans l'ordre dans lequel elles ont été ajoutées à la liste des pièces cryptées + Toutes les pièces sont requises **Constructeurs** Chaque constructeur est une liste ordonnée de *pièces du constructeur* qui définit une manière dont la balise composée peut être assemblée. Les pièces du constructeur sont assemblées dans l'ordre dans lequel elles sont ajoutées à la liste, chaque partie étant séparée par le caractère divisé spécifié. Chaque partie du constructeur nomme une partie chiffrée ou une partie signée, et définit si cette partie est obligatoire ou facultative dans le constructeur. Par exemple, si vous souhaitez interroger une balise composée sur`Field1`,`Field1.Field2`, et`Field1.Field2.Field3`, marquer `Field2` et `Field3` comme facultatif et créer un constructeur. Chaque constructeur doit avoir au moins une pièce requise. Nous vous recommandons de rendre obligatoire la première partie de chaque constructeur afin que vous puissiez utiliser l'`BEGINS_WITH`opérateur dans vos requêtes. Un constructeur réussit si toutes ses pièces requises sont présentes dans l'enregistrement. Lorsque vous écrivez un nouvel enregistrement, la balise composée utilise la liste des constructeurs pour déterminer si la balise peut être assemblée à partir des valeurs fournies. Il tente d'assembler la balise dans l'ordre dans lequel les constructeurs ont été ajoutés à la liste des constructeurs, et il utilise le premier constructeur qui réussit. Si aucun constructeur ne réussit, la balise n'est pas écrite dans l'enregistrement. Tous les lecteurs et rédacteurs doivent spécifier le même ordre de constructeurs pour s'assurer que les résultats de leurs requêtes sont corrects. Utilisez les procédures suivantes pour spécifier votre propre liste de constructeurs. 1. Créez une partie constructeur pour chaque pièce chiffrée et pièce signée afin de définir si cette partie est requise ou non. Le nom de la partie constructeur doit être le nom de la balise standard ou du champ signé qu'il représente. ------ #### [ Java ] ``` ConstructorPart field1ConstructorPart = ConstructorPart.builder() .name("Field1") .required(true) .build(); ``` ------ #### [ C\$1 / .NET ] ``` var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true }; ``` ------ #### [ Rust ] ``` let field_1_constructor_part = ConstructorPart::builder() .name("field_1") .required(true) .build()?; ``` ------ 1. Créez un constructeur pour chaque manière possible d'assembler la balise composée à l'aide des pièces du constructeur que vous avez créées à l'**étape** 1. Par exemple, si vous souhaitez effectuer une requête sur `Field1.Field2.Field3` et`Field4.Field2.Field3`, vous devez créer deux constructeurs. `Field1`et `Field4` peuvent tous deux être requis car ils sont définis dans deux constructeurs distincts. ------ #### [ Java ] ``` // Create a list for Field1.Field2.Field3 queries List field123ConstructorPartList = new ArrayList<>(); field123ConstructorPartList.add(field1ConstructorPart); field123ConstructorPartList.add(field2ConstructorPart); field123ConstructorPartList.add(field3ConstructorPart); Constructor field123Constructor = Constructor.builder() .parts(field123ConstructorPartList) .build(); // Create a list for Field4.Field2.Field1 queries List field421ConstructorPartList = new ArrayList<>(); field421ConstructorPartList.add(field4ConstructorPart); field421ConstructorPartList.add(field2ConstructorPart); field421ConstructorPartList.add(field1ConstructorPart); Constructor field421Constructor = Constructor.builder() .parts(field421ConstructorPartList) .build(); ``` ------ #### [ C\$1 / .NET ] ``` // Create a list for Field1.Field2.Field3 queries var field123ConstructorPartList = new Constructor { Parts = new List { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart } }; // Create a list for Field4.Field2.Field1 queries var field421ConstructorPartList = new Constructor { Parts = new List { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart } }; ``` ------ #### [ Rust ] ``` // Create a list for field1.field2.field3 queries let field1_field2_field3_constructor = Constructor::builder() .parts(vec![ field1_constructor_part, field2_constroctor_part.clone(), field3_constructor_part, ]) .build()?; // Create a list for field4.field2.field1 queries let field4_field2_field1_constructor = Constructor::builder() .parts(vec![ field4_constructor_part, field2_constroctor_part.clone(), field1_constructor_part, ]) .build()?; ``` ------ 1. Créez une liste de constructeurs qui inclut tous les constructeurs que vous avez créés à l'**étape** 2. ------ #### [ Java ] ``` List constructorList = new ArrayList<>(); constructorList.add(field123Constructor); constructorList.add(field421Constructor); ``` ------ #### [ C\$1 / .NET ] ``` var constructorList = new List { field123Constructor, field421Constructor }; ``` ------ #### [ Rust ] ``` let constructor_list = vec![ field1_field2_field3_constructor, field4_field2_field1_constructor, ]; ``` ------ 1. Spécifiez le `constructorList` moment où vous créez votre balise composée. # Exemples de configuration **** | | | --- | | Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). | Les exemples suivants montrent comment configurer des balises standard et composées. Les configurations suivantes ne fournissent pas de longueur de balise. Pour obtenir de l'aide pour déterminer la longueur de balise adaptée à votre configuration, voir [Choisir une longueur de balise](choosing-beacon-length.md). Pour voir des exemples de code complets qui montrent comment configurer et utiliser des balises, consultez les exemples de chiffrement consultables [Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption), [.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/) et [Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/) dans le référentiel aws-database-encryption-sdk -dynamodb sur. GitHub **Topics** + [Balises standard](#standard-config-examples) + [Balises composées](#compound-config-examples) ## Balises standard Si vous souhaitez interroger le `inspector_id_last4` champ pour obtenir des correspondances exactes, créez une balise standard en utilisant la configuration suivante. ------ #### [ Java ] ``` List standardBeaconList = new ArrayList<>(); StandardBeacon exampleStandardBeacon = StandardBeacon.builder() .name("inspector_id_last4") .length(beaconLengthInBits) .build(); standardBeaconList.add(exampleStandardBeacon); ``` ------ #### [ C\$1 / .NET ] ``` var standardBeaconList = new List>); StandardBeacon exampleStandardBeacon = new StandardBeacon { Name = "inspector_id_last4", Length = 10 }; standardBeaconList.Add(exampleStandardBeacon); ``` ------ #### [ Rust ] ``` let last4_beacon = StandardBeacon::builder() .name("inspector_id_last4") .length(10) .build()?; let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?; let standard_beacon_list = vec![last4_beacon, unit_beacon]; ``` ------ ## Balises composées Si vous souhaitez interroger la `UnitInspection` base de données sur `inspector_id_last4` et`inspector_id_last4.unit`, créez une balise composée avec la configuration suivante. Cette balise composée ne nécessite que des [parties cryptées](configure-beacons.md#encrypted-parts). ------ #### [ Java ] ``` // 1. Create standard beacons for the inspector_id_last4 and unit fields. List standardBeaconList = new ArrayList<>(); StandardBeacon inspectorBeacon = StandardBeacon.builder() .name("inspector_id_last4") .length(beaconLengthInBits) .build(); standardBeaconList.add(inspectorBeacon); StandardBeacon unitBeacon = StandardBeacon.builder() .name("unit") .length(beaconLengthInBits) .build(); standardBeaconList.add(unitBeacon); // 2. Define the encrypted parts. List encryptedPartList = new ArrayList<>(); // Each encrypted part needs a name and prefix // The name must be the name of the standard beacon // The prefix must be unique // For this example we use the prefix "I-" for "inspector_id_last4" // and "U-" for "unit" EncryptedPart encryptedPartInspector = EncryptedPart.builder() .name("inspector_id_last4") .prefix("I-") .build(); encryptedPartList.add(encryptedPartInspector); EncryptedPart encryptedPartUnit = EncryptedPart.builder() .name("unit") .prefix("U-") .build(); encryptedPartList.add(encryptedPartUnit); // 3. Create the compound beacon. // This compound beacon only requires a name, split character, // and list of encrypted parts CompoundBeacon inspectorUnitBeacon = CompoundBeacon.builder() .name("inspectorUnitBeacon") .split(".") .sensitive(encryptedPartList) .build(); ``` ------ #### [ C\$1 / .NET ] ``` // 1. Create standard beacons for the inspector_id_last4 and unit fields. StandardBeacon inspectorBeacon = new StandardBeacon { Name = "inspector_id_last4", Length = 10 }; standardBeaconList.Add(inspectorBeacon); StandardBeacon unitBeacon = new StandardBeacon { Name = "unit", Length = 30 }; standardBeaconList.Add(unitBeacon); // 2. Define the encrypted parts. var last4EncryptedPart = new EncryptedPart // Each encrypted part needs a name and prefix // The name must be the name of the standard beacon // The prefix must be unique // For this example we use the prefix "I-" for "inspector_id_last4" // and "U-" for "unit" var last4EncryptedPart = new EncryptedPart { Name = "inspector_id_last4", Prefix = "I-" }; encryptedPartList.Add(last4EncryptedPart); var unitEncryptedPart = new EncryptedPart { Name = "unit", Prefix = "U-" }; encryptedPartList.Add(unitEncryptedPart); // 3. Create the compound beacon. // This compound beacon only requires a name, split character, // and list of encrypted parts var compoundBeaconList = new List>); var inspectorCompoundBeacon = new CompoundBeacon { Name = "inspector_id_last4", Split = ".", Encrypted = encryptedPartList }; compoundBeaconList.Add(inspectorCompoundBeacon); ``` ------ #### [ Rust ] ``` // 1. Create standard beacons for the inspector_id_last4 and unit fields. let last4_beacon = StandardBeacon::builder() .name("inspector_id_last4") .length(10) .build()?; let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?; let standard_beacon_list = vec![last4_beacon, unit_beacon]; // 2. Define the encrypted parts. // The name must be the name of the standard beacon // The prefix must be unique // For this example we use the prefix "I-" for "inspector_id_last4" // and "U-" for "unit" let encrypted_parts_list = vec![ EncryptedPart::builder() .name("inspector_id_last4") .prefix("I-") .build()?, EncryptedPart::builder().name("unit").prefix("U-").build()?, ]; // 3. Create the compound beacon // This compound beacon only requires a name, split character, // and list of encrypted parts let compound_beacon_list = vec![CompoundBeacon::builder() .name("last4UnitCompound") .split(".") .encrypted(encrypted_parts_list) .build()?]; ``` ------