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.
# AWS KMS Porte-clés hiérarchiques
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée AWS Database Encryption SDK. Ce guide du développeur fournit toujours des informations sur le client de chiffrement [ DynamoDB. ](legacy-dynamodb-encryption-client.md) |
**Note**
Depuis le 24 juillet 2023, les clés de branche créées lors de la version préliminaire pour développeurs ne sont plus prises en charge. Créez de nouvelles clés de branche pour continuer à utiliser le magasin de clés que vous avez créé lors de la version préliminaire pour développeurs.
Grâce au trousseau de clés AWS KMS hiérarchique, vous pouvez protéger vos documents cryptographiques à l'aide d'une clé KMS à chiffrement symétrique sans avoir à appeler AWS KMS chaque fois que vous chiffrez ou déchiffrez un enregistrement. C'est un bon choix pour les applications qui ont besoin de minimiser les appels et pour AWS KMS les applications qui peuvent réutiliser certains éléments cryptographiques sans enfreindre leurs exigences de sécurité.
Le trousseau de clés hiérarchique est une solution de mise en cache des matériaux cryptographiques qui réduit le nombre d' AWS KMS appels en utilisant des clés de * branche AWS KMS protégées * conservées dans une table Amazon DynamoDB, puis en mettant en cache localement les matériaux des clés de branche utilisés dans les opérations de chiffrement et de déchiffrement. La table DynamoDB fait office de magasin de clés qui gère et protège les clés de branche. Il stocke la clé de branche active et toutes les versions précédentes de la clé de branche. La clé de * branche * active est la version de clé de branche la plus récente. Le trousseau de clés hiérarchique utilise une clé de chiffrement des données unique pour chaque demande de chiffrement et chiffre chaque clé de chiffrement des données avec une clé d'encapsulation unique dérivée de la clé de branche active. Le trousseau de clés hiérarchique dépend de la hiérarchie établie entre les clés de branche actives et leurs clés d'encapsulation dérivées.
Le trousseau de clés hiérarchique utilise généralement chaque version de clé de branche pour répondre à plusieurs demandes. Mais vous pouvez contrôler la mesure dans laquelle les clés de branche actives sont réutilisées et vous déterminez la fréquence de rotation de la clé de branche active. La version active de la clé de branche reste active tant que vous ne la [ faites pas pivoter](rotate-branch-key.md). Les versions précédentes de la clé de branche active ne seront pas utilisées pour effectuer des opérations de chiffrement, mais elles peuvent toujours être interrogées et utilisées pour les opérations de déchiffrement.
Lorsque vous instanciez le trousseau de clés hiérarchique, il crée un cache local. Vous spécifiez une limite de [ cache ](#cache-limit) qui définit la durée maximale pendant laquelle les éléments des clés de branche sont stockés dans le cache local avant d'expirer et d'en être expulsés. Le trousseau de clés hiérarchique effectue un AWS KMS appel pour déchiffrer la clé de branche et assembler les éléments de la clé de branche la première fois que a `branch-key-id` est spécifié dans une opération. Les éléments des clés de branche sont ensuite stockés dans le cache local et réutilisés pour toutes les opérations de chiffrement et de déchiffrement qui le spécifient `branch-key-id` jusqu'à l'expiration de la limite de cache. Le stockage des informations relatives aux clés de branche dans le cache local réduit le nombre d' AWS KMS appels. Par exemple, considérez une limite de cache de 15 minutes. Si vous effectuez 10 000 opérations de chiffrement dans cette limite de cache, le trousseau de AWS KMS clés [ traditionnel ](use-kms-keyring.md) devra effectuer 10 000 AWS KMS appels pour effectuer 10 000 opérations de chiffrement. Si vous en avez un actif`branch-key-id`, le trousseau de clés hiérarchique n'a besoin que d'un seul AWS KMS appel pour effectuer 10 000 opérations de chiffrement.
Le cache local sépare le matériel de chiffrement du matériel de déchiffrement. Les matériaux de chiffrement sont assemblés à partir de la clé de branche active et réutilisés pour toutes les opérations de chiffrement jusqu'à l'expiration de la limite de cache. Les matériaux de déchiffrement sont assemblés à partir de l'ID de clé de branche et de la version identifiés dans les métadonnées du champ chiffré, et ils sont réutilisés pour toutes les opérations de déchiffrement liées à l'ID et à la version de la clé de branche jusqu'à expiration de la limite de cache. Le cache local peut stocker plusieurs versions de la même clé de branche à la fois. Lorsque le cache local est configuré pour utiliser un[branch key ID supplier](#branch-key-id-supplier), il peut également stocker des éléments de clé de branche provenant de plusieurs clés de branche actives à la fois.
**Note**
Toutes les mentions du trousseau de clés * hiérarchique * dans le SDK AWS de chiffrement de base de données font référence au trousseau de clés AWS KMS hiérarchique.
**Topics**
+ [Comment ça marche](#how-hierarchical-keyring-works)
+ [Conditions préalables](#hierarchical-keyring-prereqs)
+ [Autorisations requises](#hierarchical-keyring-permissions)
+ [Choisissez un cache](#hierarchical-keyring-caches)
+ [Création d'un porte-clés hiérarchique](#initialize-hierarchical-keyring)
+ [Utilisation du trousseau de clés hiérarchique pour le chiffrement consultable](#searchable-encryption-hierarchical-keyrings)
## Comment ça marche
Les procédures pas à pas suivantes décrivent comment le trousseau de clés hiérarchique assemble le matériel de chiffrement et de déchiffrement, ainsi que les différents appels qu'il effectue pour les opérations de chiffrement et de déchiffrement. Pour plus de détails techniques sur les processus de dérivation des clés d'encapsulation et de chiffrement des clés de données en texte brut, voir Détails techniques des trousses de clés [AWS KMS hiérarchiques. ](reference.md#hierarchical-keyring-details)
**Chiffrez et signez**
La procédure pas à pas suivante décrit comment le trousseau de clés hiérarchique assemble les matériaux de chiffrement et en déduit une clé d'encapsulation unique.
1. La méthode de cryptage demande au trousseau de clés hiérarchique les matériaux de chiffrement. Le trousseau de clés génère une clé de données en texte brut, puis vérifie s'il existe des clés de branche valides dans le cache local pour générer la clé d'encapsulation. S'il existe des éléments de clé de branche valides, le trousseau passe à l'**étape 4**.
1. S'il n'existe aucun matériel de clé de branche valide, le trousseau de clés hiérarchique interroge le magasin de clés pour la clé de branche active.
1. Le magasin de clés appelle AWS KMS pour déchiffrer la clé de branche active et renvoie la clé de branche active en texte brut. Les données identifiant la clé de branche active sont sérialisées pour fournir des données authentifiées supplémentaires (AAD) dans l'appel de déchiffrement à. AWS KMS
1. Le magasin de clés renvoie la clé de branche en texte brut et les données qui l'identifient, telles que la version de la clé de branche.
1. Le trousseau de clés hiérarchique rassemble les éléments clés de branche (la clé de branche en texte clair et la version de la clé de branche) et en stocke une copie dans le cache local.
1. Le trousseau de clés hiérarchique dérive une clé d'encapsulation unique à partir de la clé de branche en texte brut et d'un sel aléatoire de 16 octets. Il utilise la clé d'encapsulation dérivée pour chiffrer une copie de la clé de données en texte brut.
La méthode de cryptage utilise les matériaux de cryptage pour crypter et signer l'enregistrement. Pour plus d'informations sur la manière dont les enregistrements sont chiffrés et signés dans le SDK AWS de chiffrement de base de données, voir [ Chiffrer et signer. ](how-it-works.md#encrypt-and-sign)
**Décrypter et vérifier**
La procédure pas à pas suivante décrit comment le trousseau de clés hiérarchique assemble le matériel de déchiffrement et déchiffre la clé de données chiffrée.
1. La méthode de déchiffrement identifie la clé de données chiffrée à partir du champ de description du matériel de l'enregistrement chiffré et la transmet au trousseau de clés hiérarchique.
1. Le trousseau de clés hiérarchique désérialise les données identifiant la clé de données chiffrée, y compris la version de la clé de branche, le sel de 16 octets et d'autres informations décrivant la manière dont la clé de données a été chiffrée.
Pour de plus amples informations, veuillez consulter [AWS KMS Détails techniques du porte-clés hiérarchique](reference.md#hierarchical-keyring-details).
1. Le trousseau de clés hiérarchique vérifie si le cache local contient des éléments de clé de branche valides qui correspondent à la version de clé de branche identifiée à l'**étape 2**. S'il existe des éléments de clé de branche valides, le trousseau passe à l'**étape 6**.
1. S'il n'existe aucun matériel de clé de branche valide, le trousseau de clés hiérarchique interroge le magasin de clés pour trouver la clé de branche qui correspond à la version de clé de branche identifiée à l'**étape 2**.
1. Le magasin de clés appelle AWS KMS pour déchiffrer la clé de branche et renvoie la clé de branche active en texte brut. Les données identifiant la clé de branche active sont sérialisées pour fournir des données authentifiées supplémentaires (AAD) dans l'appel de déchiffrement à. AWS KMS
1. Le magasin de clés renvoie la clé de branche en texte brut et les données qui l'identifient, telles que la version de la clé de branche.
1. Le trousseau de clés hiérarchique rassemble les éléments clés de branche (la clé de branche en texte clair et la version de la clé de branche) et en stocke une copie dans le cache local.
1. Le trousseau de clés hiérarchique utilise les matériaux de clé de branche assemblés et le sel de 16 octets identifié à l'**étape 2 ** pour reproduire la clé d'encapsulation unique qui a chiffré la clé de données.
1. Le trousseau de clés hiérarchique utilise la clé d'encapsulation reproduite pour déchiffrer la clé de données et renvoie la clé de données en texte brut.
La méthode de déchiffrement utilise les matériaux de déchiffrement et la clé de données en texte brut pour déchiffrer et vérifier l'enregistrement. Pour plus d'informations sur la manière dont les enregistrements sont déchiffrés et vérifiés dans le SDK de chiffrement AWS de base de données, voir [ Déchiffrer et vérifier. ](how-it-works.md#decrypt-and-verify)
## Conditions préalables
Avant de créer et d'utiliser un trousseau de clés hiérarchique, assurez-vous que les conditions préalables suivantes sont remplies.
+ Vous, ou l'administrateur de votre magasin de clés, avez [ créé un magasin de clés ](create-keystore.md) et [ créé au moins une clé de branche active](create-branch-keys.md).
+ Vous avez [ configuré les actions de votre magasin de clés](keystore-actions.md#config-keystore-actions).
**Note**
La façon dont vous configurez les actions de votre magasin de clés détermine les opérations que vous pouvez effectuer et les clés KMS que le trousseau de clés hiérarchique peut utiliser. Pour plus d'informations, consultez la section Actions relatives au magasin [ clé](keystore-actions.md).
+ Vous disposez des AWS KMS autorisations nécessaires pour accéder au magasin de clés et aux clés de succursale et les utiliser. Pour de plus amples informations, veuillez consulter [Autorisations requises](#hierarchical-keyring-permissions).
+ Vous avez examiné les types de cache pris en charge et configuré le type de cache qui correspond le mieux à vos besoins. Pour de plus amples informations, consultez [Choisissez un cache](#hierarchical-keyring-caches).
## Autorisations requises
Le SDK AWS de chiffrement de base de données n'en nécessite pas Compte AWS et n'en dépend pas Service AWS. Toutefois, pour utiliser un trousseau de clés hiérarchique, vous devez disposer Compte AWS des autorisations minimales suivantes sur le ou les AWS KMS key chiffrements symétriques de votre magasin de clés.
+ Pour chiffrer et déchiffrer des données à l'aide du trousseau de clés hiérarchique, vous avez besoin de KMS:Decrypt. [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
+ Pour [ créer ](create-branch-keys.md) et [ faire pivoter des clés de ](rotate-branch-key.md) branche, vous avez besoin de [ kms : GenerateDataKeyWithoutPlaintext ](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) et de [ kms : ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html).
Pour plus d'informations sur le contrôle de l'accès aux clés de votre agence et à votre magasin de clés, consultez[Implémentation des autorisations avec le moindre privilégié](keystore-least-privilege.md).
## Choisissez un cache
Le trousseau de clés hiérarchique réduit le nombre d'appels en AWS KMS mettant en cache localement les éléments clés de branche utilisés dans les opérations de chiffrement et de déchiffrement. Avant de [ créer votre trousseau de clés hiérarchique](#initialize-hierarchical-keyring), vous devez décider du type de cache que vous souhaitez utiliser. Vous pouvez utiliser le cache par défaut ou le personnaliser en fonction de vos besoins.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants :
+ [Cache par défaut](#cache-default)
+ [MultiThreaded cache](#cache-multithreaded)
+ [StormTracking cache](#cache-stormtracking)
+ [Cache partagé](#cache-shared)
### Cache par défaut
Pour la plupart des utilisateurs, le cache par défaut répond à leurs exigences en matière de thread. Le cache par défaut est conçu pour prendre en charge les environnements fortement multithread. Lorsqu'une entrée de matériel clé de branche expire, le cache par défaut empêche l'appel de plusieurs threads AWS KMS en notifiant à un thread que l'entrée de matériaux de clé de branche va expirer 10 secondes à l'avance. Cela garantit qu'un seul thread envoie une demande AWS KMS d'actualisation du cache.
Le cache par défaut et le StormTracking cache prennent en charge le même modèle de threading, mais il vous suffit de spécifier la capacité d'entrée pour utiliser le cache par défaut. Pour des personnalisations plus précises du cache, utilisez le. [StormTracking cache](#cache-stormtracking)
À moins que vous ne souhaitiez personnaliser le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local, vous n'avez pas besoin de spécifier de type de cache lorsque vous créez le trousseau de clés hiérarchique. Si vous ne spécifiez aucun type de cache, le trousseau de clés hiérarchique utilise le type de cache par défaut et définit la capacité d'entrée sur 1 000.
Pour personnaliser le cache par défaut, spécifiez les valeurs suivantes :
+ **Capacité d'entrée ** : limite le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local.
------
#### [ Java ]
```
.cache(CacheType.builder()
.Default(DefaultCache.builder()
.entryCapacity({{100}})
.build())
```
------
#### [ C\# / .NET ]
```
CacheType defaultCache = new CacheType
{
Default = new DefaultCache{EntryCapacity = {{100}}}
};
```
------
#### [ Rust ]
```
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity({{100}})
.build()?,
);
```
------
### MultiThreaded cache
Le MultiThreaded cache peut être utilisé en toute sécurité dans les environnements multithread, mais il ne fournit aucune fonctionnalité permettant de minimiser les appels AWS KMS Amazon DynamoDB. Par conséquent, lorsqu'une entrée de matériel clé de branche expire, tous les fils de discussion sont notifiés en même temps. Cela peut entraîner plusieurs AWS KMS appels pour actualiser le cache.
Pour utiliser le MultiThreaded cache, spécifiez les valeurs suivantes :
+ **Capacité d'entrée ** : limite le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local.
+ **Taille de la queue d'élagage d'entrée ** : définit le nombre d'entrées à tailler si la capacité d'entrée est atteinte.
------
#### [ Java ]
```
.cache(CacheType.builder()
.MultiThreaded(MultiThreadedCache.builder()
.entryCapacity({{100}})
.entryPruningTailSize({{1}})
.build())
```
------
#### [ C\# / .NET ]
```
CacheType multithreadedCache = new CacheType
{
MultiThreaded = new MultiThreadedCache
{
EntryCapacity = {{100}},
EntryPruningTailSize = {{1}}
}
};
```
------
#### [ Rust ]
```
CacheType::MultiThreaded(
MultiThreadedCache::builder()
.entry_capacity({{100}})
.entry_pruning_tail_size({{1}})
.build()?)
```
------
### StormTracking cache
Le StormTracking cache est conçu pour prendre en charge les environnements fortement multithread. Lorsqu'une entrée de matériel de clé de branche expire, le StormTracking cache empêche l'appel de plusieurs threads AWS KMS en notifiant à un thread que l'entrée de matériaux de clé de branche va expirer à l'avance. Cela garantit qu'un seul thread envoie une demande AWS KMS d'actualisation du cache.
Pour utiliser le StormTracking cache, spécifiez les valeurs suivantes :
+ **Capacité d'entrée ** : limite le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local.
Valeur par défaut : 1000 entrées
+ **Taille de la queue d'élagage d'entrée ** : définit le nombre d'entrées de matériaux clés de branche à tailler à la fois.
Valeur par défaut : 1 entrée
+ **Période de grâce ** : définit le nombre de secondes avant l'expiration pendant lesquelles une tentative d'actualisation des éléments clés de branche est effectuée.
Valeur par défaut : 10 secondes
+ **Intervalle de grâce ** : définit le nombre de secondes entre les tentatives d'actualisation des éléments clés de la branche.
Valeur par défaut : 1 seconde
+ **Ventilation ** : définit le nombre de tentatives simultanées qui peuvent être effectuées pour actualiser les éléments clés de la branche.
Valeur par défaut : 20 tentatives
+ **Durée de vie en vol (TTL) ** : définit le nombre de secondes qui s'écoulent avant l'expiration d'une tentative d'actualisation du matériel clé de la branche. Chaque fois que le cache revient `NoSuchEntry` en réponse à a`GetCacheEntry`, cette clé de branche est considérée comme étant * en vol * jusqu'à ce que la même clé soit écrite avec une `PutCache` entrée.
Valeur par défaut : 10 secondes
+ ****Veille : définit le nombre de secondes pendant lesquelles un thread doit rester en veille s'`fanOut`il est dépassé.
Valeur par défaut : 20 millisecondes
------
#### [ Java ]
```
.cache(CacheType.builder()
.StormTracking(StormTrackingCache.builder()
.entryCapacity({{100}})
.entryPruningTailSize({{1}})
.gracePeriod({{10}})
.graceInterval({{1}})
.fanOut({{20}})
.inFlightTTL({{10}})
.sleepMilli({{20}})
.build())
```
------
#### [ C\# / .NET ]
```
CacheType stormTrackingCache = new CacheType
{
StormTracking = new StormTrackingCache
{
EntryCapacity = {{100}},
EntryPruningTailSize = {{1}},
FanOut = {{20}},
GraceInterval = {{1}},
GracePeriod = {{10}},
InFlightTTL = {{10}},
SleepMilli = {{20}}
}
};
```
------
#### [ Rust ]
```
CacheType::StormTracking(
StormTrackingCache::builder()
.entry_capacity({{100}})
.entry_pruning_tail_size({{1}})
.grace_period({{10}})
.grace_interval({{1}})
.fan_out({{20}})
.in_flight_ttl({{10}})
.sleep_milli({{20}})
.build()?)
```
------
### Cache partagé
Par défaut, le trousseau de clés hiérarchique crée un nouveau cache local chaque fois que vous instanciez le jeu de clés. Cependant, le cache partagé peut contribuer à économiser de la mémoire en vous permettant de partager un cache entre plusieurs porte-clés hiérarchiques. Plutôt que de créer un nouveau cache de matériel cryptographique pour chaque jeu de clés hiérarchique que vous instanciez, le cache partagé ne stocke qu'un seul cache en mémoire, qui peut être utilisé par tous les ensembles de clés hiérarchiques qui le référencent. Le cache partagé permet d'optimiser l'utilisation de la mémoire en évitant la duplication de documents cryptographiques entre les trousseaux de clés. Au lieu de cela, les trousseaux de clés hiérarchiques peuvent accéder au même cache sous-jacent, réduisant ainsi l'empreinte mémoire globale.
Lorsque vous créez votre cache partagé, vous définissez toujours le type de cache. Vous pouvez spécifier un [Cache par défaut](#cache-default)[MultiThreaded cache](#cache-multithreaded), ou [StormTracking cache](#cache-stormtracking) comme type de cache, ou le remplacer par un cache personnalisé compatible.
**Partitions**
Plusieurs porte-clés hiérarchiques peuvent utiliser un seul cache partagé. Lorsque vous créez un trousseau de clés hiérarchique avec un cache partagé, vous pouvez définir un ID ** de ** partition facultatif. L'ID de partition permet de distinguer le trousseau de clés hiérarchique qui écrit dans le cache. Si deux porte-clés hiérarchiques font référence au même ID de partition et au même ID de clé de branche[logical key store name](create-keystore.md#logical-key-store-name), les deux porte-clés partageront les mêmes entrées de cache dans le cache. Si vous créez deux trousseaux de clés hiérarchiques avec le même cache partagé, mais des ID de partition différents, chaque jeu de clés n'accédera aux entrées du cache qu'à partir de sa propre partition désignée dans le cache partagé. Les partitions agissent comme des divisions logiques au sein du cache partagé, permettant à chaque jeu de clés hiérarchique de fonctionner indépendamment sur sa propre partition désignée, sans interférer avec les données stockées dans l'autre partition.
Si vous avez l'intention de réutiliser ou de partager les entrées du cache d'une partition, vous devez définir votre propre identifiant de partition. Lorsque vous transmettez l'ID de partition à votre trousseau de clés hiérarchique, celui-ci peut réutiliser les entrées de cache déjà présentes dans le cache partagé, au lieu de devoir récupérer et réautoriser les éléments clés de branche. Si vous ne spécifiez pas d'identifiant de partition, un identifiant de partition unique est automatiquement attribué au trousseau de clés chaque fois que vous instanciez le jeu de clés hiérarchique.
Les procédures suivantes montrent comment créer un cache partagé avec le type de cache [ par défaut ](#cache-default) et le transmettre à un trousseau de clés hiérarchique.
1. Créez un `CryptographicMaterialsCache` (CMC) à l'aide de la [ Material Providers Library ](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL).
------
#### [ Java ]
```
// Instantiate the MPL
final MaterialProviders matProv =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a CacheType object for the Default cache
final CacheType cache =
CacheType.builder()
.Default(DefaultCache.builder().entryCapacity(100).build())
.build();
// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
CreateCryptographicMaterialsCacheInput.builder()
.cache(cache)
.build();
final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ C\# / .NET ]
```
// Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };
// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};
var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ Rust ]
```
// Instantiate the MPL
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create a CacheType object for the default cache
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
// Create a CMC using the default cache
let shared_cryptographic_materials_cache: CryptographicMaterialsCacheRef = mpl.
create_cryptographic_materials_cache()
.cache(cache)
.send()
.await?;
```
------
1. Créez un `CacheType` objet pour le cache partagé.
Transmettez ce `sharedCryptographicMaterialsCache` que vous avez créé ** à l'**étape 1 au nouvel `CacheType` objet.
------
#### [ Java ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
CacheType.builder()
.Shared(sharedCryptographicMaterialsCache)
.build();
```
------
#### [ C\# / .NET ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
```
------
#### [ Rust ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
let shared_cache: CacheType = CacheType::Shared(shared_cryptographic_materials_cache);
```
------
1. Transmettez l'`sharedCache`objet de l'**étape 2 ** à votre trousseau de clés hiérarchique.
Lorsque vous créez un trousseau de clés hiérarchique avec un cache partagé, vous pouvez éventuellement en définir un `partitionID` pour partager les entrées du cache entre plusieurs porte-clés hiérarchiques. Si vous ne spécifiez pas d'identifiant de partition, le trousseau de clés hiérarchique attribue automatiquement au trousseau de clés un identifiant de partition unique.
**Note**
Vos trousseaux de clés hiérarchiques partageront les mêmes entrées de cache dans un cache partagé si vous créez au moins deux porte-clés qui font référence aux mêmes ID de partition et ID de clé de branche. [logical key store name](create-keystore.md#logical-key-store-name) Si vous ne souhaitez pas que plusieurs trousseaux de clés partagent les mêmes entrées de cache, vous devez utiliser un identifiant de partition unique pour chaque porte-clés hiérarchique.
L'exemple suivant crée un porte-clés hiérarchique avec un[branch key ID supplier](#branch-key-id-supplier), et une limite [ de ](#cache-limit) cache de 600 secondes. Pour plus d'informations sur les valeurs définies dans la section Configuration de trousseau de clés hiérarchique suivante, consultez[Création d'un porte-clés hiérarchique](#initialize-hierarchical-keyring).
------
#### [ Java ]
```
// Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds({{600}})
.cache(sharedCache)
.partitionID({{partitionID}})
.build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\# / .NET ]
```
// Create the Hierarchical keyring
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
Cache = sharedCache,
TtlSeconds = {{600}},
PartitionId = {{partitionID}}
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
```
------
#### [ Rust ]
```
// Create the Hierarchical keyring
let keyring1 = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store1)
.branch_key_id(branch_key_id.clone())
// CryptographicMaterialsCacheRef is an Rc (Reference Counted), so if you clone it to
// pass it to different Hierarchical Keyrings, it will still point to the same
// underlying cache, and increment the reference count accordingly.
.cache(shared_cache.clone())
.ttl_seconds({{600}})
.partition_id({{partition_id}}.clone())
.send()
.await?;
```
------
## Création d'un porte-clés hiérarchique
Pour créer un porte-clés hiérarchique, vous devez fournir les valeurs suivantes :
+ **Un magasin de clés **
Le magasin de clés qui gère et protège les clés de vos agences. Vous devez créer et configurer votre magasin de clés avant de créer le trousseau de clés hiérarchique. Pour de plus amples informations, veuillez consulter [Stockage des clés dans le SDK de chiffrement des AWS bases de données](keystores.md).
+
**Une limite de durée de vie du cache (TTL) **
Durée en secondes pendant laquelle une entrée de matériel de clé de branche dans le cache local peut être utilisée avant son expiration. La limite de cache TTL détermine la fréquence à laquelle le client appelle AWS KMS pour autoriser l'utilisation des clés de branche. Cette valeur doit être supérieure à zéro. Une fois la limite de cache TTL expirée, l'entrée n'est jamais diffusée et sera expulsée du cache local.
+ **Un identifiant de clé de succursale **
Vous pouvez soit configurer statiquement la clé `branch-key-id` qui identifie une seule clé de branche active dans votre magasin de clés, soit fournir un fournisseur d'ID de clé de branche.
Le fournisseur d'ID de clé de * branche * utilise les champs stockés dans le contexte de chiffrement pour déterminer quelle clé de branche est requise pour déchiffrer un enregistrement. Par défaut, seules les clés de partition et de tri sont incluses dans le contexte de chiffrement. Vous pouvez toutefois utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` [ cryptographique ](concepts.md#crypt-actions) pour inclure des champs supplémentaires dans le contexte de chiffrement.
Nous vous recommandons vivement d'utiliser un fournisseur d'identifiant de clé de branche pour les bases de données multi-locataires où chaque locataire possède sa propre clé de branche. Vous pouvez utiliser le fournisseur d'ID de clé de succursale pour créer un nom convivial pour vos identifiants de clé de succursale afin de faciliter la reconnaissance de l'ID de clé de branche correct pour un locataire spécifique. Par exemple, le nom convivial vous permet de faire référence à une clé de branche au `tenant1` lieu de`b3f61619-4d35-48ad-a275-050f87e15122`.
Pour les opérations de déchiffrement, vous pouvez soit configurer statiquement un seul jeu de clés hiérarchique pour limiter le déchiffrement à un seul locataire, soit utiliser le fournisseur d'ID de clé de branche pour identifier le locataire responsable du déchiffrement d'un enregistrement.
+ **(Facultatif) Un cache **
Si vous souhaitez personnaliser le type de cache ou le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local, spécifiez le type de cache et la capacité d'entrée lorsque vous initialisez le trousseau de clés.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants : Par défaut MultiThreaded, StormTracking, et partagé. Pour plus d'informations et des exemples illustrant comment définir chaque type de cache, consultez[Choisissez un cache](#hierarchical-keyring-caches).
Si vous ne spécifiez pas de cache, le trousseau de clés hiérarchique utilise automatiquement le type de cache par défaut et définit la capacité d'entrée sur 1 000.
+ **(Facultatif) Un identifiant de partition **
Si vous le spécifiez[Cache partagé](#cache-shared), vous pouvez éventuellement définir un ID de partition. L'ID de partition permet de distinguer le trousseau de clés hiérarchique qui écrit dans le cache. Si vous avez l'intention de réutiliser ou de partager les entrées du cache d'une partition, vous devez définir votre propre identifiant de partition. Vous pouvez spécifier n'importe quelle chaîne pour l'ID de partition. Si vous ne spécifiez pas d'identifiant de partition, un identifiant de partition unique est automatiquement attribué au trousseau de clés lors de sa création.
Pour de plus amples informations, veuillez consulter [Partitions](#shared-cache-partitions).
**Note**
Vos trousseaux de clés hiérarchiques partageront les mêmes entrées de cache dans un cache partagé si vous créez au moins deux porte-clés qui font référence aux mêmes ID de partition et ID de clé de branche. [logical key store name](create-keystore.md#logical-key-store-name) Si vous ne souhaitez pas que plusieurs trousseaux de clés partagent les mêmes entrées de cache, vous devez utiliser un identifiant de partition unique pour chaque porte-clés hiérarchique.
+ **(Facultatif) Une liste de jetons de subvention **
Si vous contrôlez l'accès à la clé KMS dans votre trousseau de clés hiérarchique à l'aide [ d'](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)autorisations, vous devez fournir tous les jetons d'autorisation nécessaires lorsque vous initialisez le jeu de clés.
Les exemples suivants montrent comment configurer un magasin de clés avec une configuration statique. Choisissez votre langue préférée :
------
#### [ Java ]
```
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.kms.KmsClient;
import software.amazon.cryptography.keystore.KeyStore;
import software.amazon.cryptography.keystore.model.KeyStoreConfig;
import software.amazon.cryptography.keystore.model.KMSConfiguration;
final KeyStore keystore = KeyStore.builder()
.KeyStoreConfig(KeyStoreConfig.builder()
.ddbClient(DynamoDbClient.create())
.ddbTableName({{keyStoreName}})
.logicalKeyStoreName({{logicalKeyStoreName}})
.kmsClient(KmsClient.create())
.kmsConfiguration(KMSConfiguration.builder()
.kmsKeyArn({{kmsKeyArn}})
.build())
.build())
.build();
```
------
#### [ C\# / .NET ]
```
using Amazon.DynamoDBv2;
using Amazon.KeyManagementService;
using AWS.Cryptography.KeyStore;
var kmsConfig = new KMSConfiguration { KmsKeyArn = {{kmsKeyArn}} };
var keystoreConfig = new KeyStoreConfig
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsConfiguration = kmsConfig,
DdbTableName = {{keyStoreName}},
DdbClient = new AmazonDynamoDBClient(),
LogicalKeyStoreName = {{logicalKeyStoreName}}
};
var keystore = new KeyStore(keystoreConfig);
```
------
#### [ Rust ]
```
use aws_db_esdk::key_store::client as keystore_client;
use aws_db_esdk::key_store::types::key_store_config::KeyStoreConfig;
use aws_db_esdk::key_store::types::KmsConfiguration;
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let key_store_config = KeyStoreConfig::builder()
.kms_client(aws_sdk_kms::Client::new(&sdk_config))
.ddb_client(aws_sdk_dynamodb::Client::new(&sdk_config))
.ddb_table_name({{key_store_name}})
.logical_key_store_name({{logical_key_store_name}})
.kms_configuration(KmsConfiguration::KmsKeyArn({{kms_key_arn}}.to_string()))
.build()?;
let keystore = keystore_client::Client::from_conf(key_store_config)?;
```
------
Après avoir configuré votre magasin de clés, utilisez l'objet de stockage de clés qui en résulte pour créer votre porte-clés hiérarchique. Les exemples de porte-clés hiérarchiques qui suivent utilisent l'objet de stockage de clés que vous avez configuré.
### Création d'un porte-clés hiérarchique avec un identifiant de clé de branche statique
Les exemples suivants montrent comment créer un trousseau de clés hiérarchique avec un ID de clé de branche statique, le[Cache par défaut](#cache-default), et une limite de cache TTL de 600 secondes.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyId({{branch-key-id}})
.ttlSeconds({{600}})
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\# / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = {{600}}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id({{branch_key_id}})
.key_store(keystore.clone())
.ttl_seconds({{600}})
.send()
.await?;
```
------
### Création d'un porte-clés hiérarchique avec un fournisseur d'identifiant de clé de branche
Les procédures suivantes montrent comment créer un porte-clés hiérarchique avec un fournisseur d'identifiant de clé de branche.
1. Créer un fournisseur d'identifiant de clé de succursale
L'exemple suivant crée des noms conviviaux pour les deux clés de branche créées à l'**étape 1 ** et appelle `CreateDynamoDbEncryptionBranchKeyIdSupplier` à créer un fournisseur d'ID de clé de branche avec le SDK de chiffrement de AWS base de données pour le client DynamoDB.
------
#### [ Java ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
private static String branchKeyIdForTenant1;
private static String branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this.branchKeyIdForTenant1 = tenant1Id;
this.branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
.DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
.build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
.ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier({{branch-key-ID-tenant1}}, {{branch-key-ID-tenant2}}))
.build()).branchKeyIdSupplier();
```
------
#### [ C\# / .NET ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
private String _branchKeyIdForTenant1;
private String _branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this._branchKeyIdForTenant1 = tenant1Id;
this._branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
{
DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier({{branch-key-ID-tenant1}}, {{branch-key-ID-tenant2}})
}).BranchKeyIdSupplier;
```
------
#### [ Rust ]
```
// Create friendly names for each branch_key_id
pub struct ExampleBranchKeyIdSupplier {
branch_key_id_for_tenant1: String,
branch_key_id_for_tenant2: String,
}
impl ExampleBranchKeyIdSupplier {
pub fn new(tenant1_id: &str, tenant2_id: &str) -> Self {
Self {
branch_key_id_for_tenant1: tenant1_id.to_string(),
branch_key_id_for_tenant2: tenant2_id.to_string(),
}
}
}
// Create the branch key ID supplier
let dbesdk_config = DynamoDbEncryptionConfig::builder().build()?;
let dbesdk = dbesdk_client::Client::from_conf(dbesdk_config)?;
let supplier = ExampleBranchKeyIdSupplier::new(tenant1_branch_key_id, tenant2_branch_key_id);
let branch_key_id_supplier = dbesdk
.create_dynamo_db_encryption_branch_key_id_supplier()
.ddb_key_branch_key_id_supplier(supplier)
.send()
.await?
.branch_key_id_supplier
.unwrap();
```
------
1. Création d'un porte-clés hiérarchique
Les exemples suivants initialisent un trousseau de clés hiérarchique avec le fournisseur d'ID de clé de branche créé à l'**étape 1**, une limite de cache TLL de 600 secondes et une taille de cache maximale de 1 000.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds({{600}})
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity({{100}})
.build())
.build())
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\# / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = {{600}},
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = {{100}} }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id_supplier(branch_key_id_supplier)
.key_store(keystore.clone())
.ttl_seconds(600)
.send()
.await?;
```
------
## Utilisation du trousseau de clés hiérarchique pour le chiffrement consultable
[Le chiffrement consultable vous ](searchable-encryption.md) permet de rechercher des enregistrements chiffrés sans déchiffrer l'intégralité de la base de données. Cela se fait en indexant la valeur en texte brut d'un champ chiffré à l'aide d'une [ balise. ](beacons.md) Pour implémenter le chiffrement consultable, vous devez utiliser un trousseau de clés hiérarchique.
L'`CreateKey`opération de stockage de clés génère à la fois une clé de branche et une clé de * balise*. La clé de branche est utilisée dans les opérations de chiffrement et de déchiffrement des enregistrements. La clé de balise est utilisée pour générer des balises.
La clé de branche et la clé de balise sont protégées par les mêmes AWS KMS key que celles que vous avez spécifiées lors de la création de votre service de stockage de clés. Une fois que l'`CreateKey`opération a appelé AWS KMS pour générer la clé de branche, elle appelle [ kms : GenerateDataKeyWithoutPlaintext ](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) une deuxième fois pour générer la clé de balise à l'aide de la requête suivante.
```
{
"EncryptionContext": {
"branch-key-id" : "{{branch-key-id}}",
"type" : {{type}},
"create-time" : "{{timestamp}}",
"tablename" : "{{the logical table name for your key store}}",
"kms-arn" : {{the KMS key ARN}},
"hierarchy-version" : 1
},
"KeyId": "{{the KMS key ARN}}",
"NumberOfBytes": "32"
}
```
Après avoir généré les deux clés, l'`CreateKey`opération appelle [ ddb : TransactWriteItems ](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) pour écrire deux nouveaux éléments qui conserveront la clé de branche et la clé de balise dans votre magasin de clés de branche.
Lorsque vous [ configurez une balise standard](configure-beacons.md#config-standard-beacons), le SDK AWS Database Encryption interroge le magasin de clés pour la clé de balise. Ensuite, il utilise une fonction de dérivation de clé HMAC-based d'extraction et d'expansion ([HKDF](https://en.wikipedia.org/wiki/HKDF)) pour combiner la clé de balise avec le nom de la balise [ standard afin de créer la clé HMAC ](beacons.md#standard-beacon-overview) pour une balise donnée.
Contrairement aux clés de branche, il n'existe qu'une seule version de clé `branch-key-id` de balise par magasin de clés. La touche de la balise n'est jamais pivotée.
### Définition de la source de clé de votre balise
Lorsque vous définissez la version de [ balise ](using-beacons.md#beacon-version) pour vos balises standard et composées, vous devez identifier la clé de balise et définir une limite de durée de vie (TTL) du cache pour les matériaux des clés de balise. Les éléments clés des balises sont stockés dans un cache local distinct de celui des clés de branche. L'extrait suivant montre comment définir le pour une base de données `keySource` à locataire unique. Identifiez la clé de votre balise par celle à laquelle `branch-key-id` elle est associée.
------
#### [ Java ]
```
keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId({{branch-key-id}})
.cacheTTL({{6000}})
.build())
.build())
```
------
#### [ C\# / .NET ]
```
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = {{branch-key-id}},
CacheTTL = {{6000}}
}
}
```
------
#### [ Rust ]
```
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
// `keyId` references a beacon key.
// For every branch key we create in the keystore,
// we also create a beacon key.
// This beacon key is not the same as the branch key,
// but is created with the same ID as the branch key.
.key_id({{branch_key_id}})
.cache_ttl({{6000}})
.build()?,
))
```
------
**Définition de la source de balises dans une base de données mutualisée**
Si vous disposez d'une base de données mutualisée, vous devez spécifier les valeurs suivantes lors de la configuration du`keySource`.
+
**keyFieldName**
Définit le nom du champ qui stocke la clé `branch-key-id` associée à la balise utilisée pour générer des balises pour un locataire donné. Il `keyFieldName` peut s'agir de n'importe quelle chaîne, mais elle doit être unique à tous les autres champs de votre base de données. Lorsque vous écrivez de nouveaux enregistrements dans votre base de données, la `branch-key-id` clé identifiant la clé de balise utilisée pour générer des balises pour cet enregistrement est stockée dans ce champ. Vous devez inclure ce champ dans vos requêtes relatives aux balises et identifier les matériaux clés de balise appropriés nécessaires pour recalculer la balise. Pour de plus amples informations, veuillez consulter [Interrogation de balises dans une base de données mutualisée](searchable-encryption-multitenant.md#query-multitenant-beacons).
+ **Cachet L **
Durée en secondes pendant laquelle une entrée de matériel clé de balise dans le cache de balise local peut être utilisée avant son expiration. Cette valeur doit être supérieure à zéro. Lorsque la limite de cache TTL expire, l'entrée est supprimée du cache local.
+ **(Facultatif) Un cache **
Si vous souhaitez personnaliser le type de cache ou le nombre d'entrées de matériel de clé de branche pouvant être stockées dans le cache local, spécifiez le type de cache et la capacité d'entrée lorsque vous initialisez le trousseau de clés.
Le trousseau de clés hiérarchique prend en charge les types de cache suivants : Par défaut MultiThreaded, StormTracking, et partagé. Pour plus d'informations et des exemples illustrant comment définir chaque type de cache, consultez[Choisissez un cache](#hierarchical-keyring-caches).
Si vous ne spécifiez pas de cache, le trousseau de clés hiérarchique utilise automatiquement le type de cache par défaut et définit la capacité d'entrée sur 1 000.
L'exemple suivant crée un trousseau de clés hiérarchique avec un fournisseur d'ID de clé de branche, une limite de cache TLL de 600 secondes et une capacité de saisie de 1 000.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds({{600}})
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity({{1000}})
.build())
.build());
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = {{600}},
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = {{1000}} }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(keystore.clone())
.ttl_seconds({{600}})
.send()
.await?;
```