Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crittografia ricercabile per database multitenant
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
[Per implementare la crittografia ricercabile nel database, è necessario utilizzare un portachiavi gerarchico AWS KMS .](use-hierarchical-keyring.md) Il portachiavi AWS KMS gerarchico genera, crittografa e decrittografa le chiavi dati utilizzate per proteggere i record. Crea anche la chiave beacon utilizzata per generare beacon. Quando si utilizza il portachiavi AWS KMS Hierarchical con database multitenant, esistono una chiave branch e una chiave beacon distinte per ogni tenant. Per interrogare i dati crittografati in un database multitenant, è necessario identificare i materiali chiave del beacon utilizzati per generare il beacon su cui si sta interrogando. Per ulteriori informazioni, consulta [Utilizzo del portachiavi gerarchico per una crittografia ricercabile](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
Quando definisci la [versione beacon](using-beacons.md#beacon-version) per un database multitenant, specifica un elenco di tutti i beacon standard che hai configurato, un elenco di tutti i beacon composti che hai configurato, una versione beacon e un. `keySource` È necessario [definire la fonte della chiave beacon](use-hierarchical-keyring.md#beacon-key-source) come e includere a) un `MultiKeyStore` tempo di permanenza della cache per la cache della chiave beacon locale e la dimensione massima della cache per la cache locale delle chiavi beacon. `keyFieldName`
Se hai configurato dei [beacon firmati](configure.md#signed-beacons), questi devono essere inclusi nel tuo. `compoundBeaconList` I beacon firmati sono un tipo di beacon composto che indicizza ed esegue interrogazioni complesse su campi e. `SIGN_ONLY` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
------
#### [ Java ]
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.version(1) // MUST be 1
.keyStore(branchKeyStoreName)
.keySource(BeaconKeySource.builder()
.multi(MultiKeyStore.builder()
.keyFieldName(keyField)
.cacheTTL(6000)
.maxCacheSize(10)
.build())
.build())
.build()
);
```
------
#### [ C\$1 / .NET ]
```
var beaconVersions = new List
{
new BeaconVersion
{
StandardBeacons = standardBeaconList,
CompoundBeacons = compoundBeaconList,
EncryptedParts = encryptedPartsList,
SignedParts = signedPartsList,
Version = 1, // MUST be 1
KeyStore = branchKeyStoreName,
KeySource = new BeaconKeySource
{
Multi = new MultiKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000,
MaxCacheSize = 10
}
}
}
};
```
------
#### [ Rust ]
```
let beacon_version = BeaconVersion::builder()
.standard_beacons(standard_beacon_list)
.compound_beacons(compound_beacon_list)
.version(1) // MUST be 1
.key_store(key_store.clone())
.key_source(BeaconKeySource::Multi(
MultiKeyStore::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)
.max_cache_size(10)
.build()?,
))
.build()?;
let beacon_versions = vec![beacon_version];
```
------
**keyFieldName**
[`keyFieldName`](use-hierarchical-keyring.md#keyFieldName)definisce il nome del campo che memorizza la chiave beacon `branch-key-id` associata alla chiave beacon utilizzata per generare i beacon per un determinato tenant.
Quando si scrivono nuovi record nel database, la chiave `branch-key-id` che identifica la chiave beacon utilizzata per generare i beacon per quel record viene memorizzata in questo campo.
Per impostazione predefinita, `keyField` è un campo concettuale che non è memorizzato in modo esplicito nel database. [Il AWS Database Encryption SDK identifica la `branch-key-id`[chiave dei dati](concepts.md#data-key) crittografati nella [descrizione del materiale](concepts.md#material-description) e memorizza il valore concettuale `keyField` a cui potete fare riferimento nei beacon composti e nei beacon firmati.](configure.md#signed-beacons) Poiché la descrizione del materiale è firmata, la parte concettuale è considerata una parte firmata. `keyField`
Puoi anche includerlo `keyField` nelle tue azioni crittografiche come `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` campo `SIGN_ONLY` or per memorizzare esplicitamente il campo nel tuo database. Se si esegue questa operazione, è necessario includerli manualmente `keyField` ogni volta che si scrive un record `branch-key-id` nel database.
## Interrogazione dei beacon in un database multi-tenant
Per interrogare un beacon, è necessario includere `keyField` nella query i materiali chiave del beacon appropriati necessari per ricalcolare il beacon. È necessario specificare la chiave `branch-key-id` associata alla chiave beacon utilizzata per generare i beacon per un record. Non è possibile specificare il [nome descrittivo](use-hierarchical-keyring.md#branch-key-id-supplier) che identifica il fornitore dell'ID della chiave di filiale di `branch-key-id` un tenant. Puoi includerli `keyField` nelle tue domande nei seguenti modi.
**Fari composti**
Che li memorizziate esplicitamente o meno `keyField` nei vostri archivi, potete includerli `keyField` direttamente nei vostri beacon compositi come parte firmata. La parte `keyField` firmata deve essere obbligatoria.
Ad esempio, se si desidera creare un faro composto da due campi `encryptedField` e `compoundBeacon``signedField`, è necessario includerlo anche `keyField` come parte firmata. Ciò consente di eseguire la seguente interrogazione su. `compoundBeacon`
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue.K_branch-key-id
```
**Fari firmati**
Il AWS Database Encryption SDK utilizza beacon standard e composti per fornire soluzioni di crittografia ricercabili. Questi beacon devono includere almeno un campo crittografato. Tuttavia, AWS Database Encryption SDK supporta anche [beacon firmati](configure.md#signed-beacons) che possono essere configurati interamente da testo e campi in chiaro. `SIGN_ONLY` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
I beacon firmati possono essere costruiti da un'unica parte. Indipendentemente dal fatto che lo memorizziate esplicitamente `keyField` nei vostri archivi o meno, potete costruire un beacon firmato da `keyField` e utilizzarlo per creare query composte che combinano una query sul beacon `keyField` firmato con una query su uno degli altri beacon. Ad esempio, è possibile eseguire la seguente query.
```
keyField = K_branch-key-id AND compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```
Per informazioni sulla configurazione dei beacon firmati, vedere [Creazione di beacon firmati](configure.md#signed-beacons)
**Effettua una query direttamente su `keyField`**
Se hai specificato il `keyField` nelle tue azioni crittografiche e lo hai archiviato in modo esplicito nel tuo record, puoi creare una query composta che combina una query sul tuo beacon con una query su. `keyField` Puoi scegliere di interrogare direttamente su `keyField` se desideri interrogare un beacon standard. Ad esempio, è possibile eseguire la seguente query.
```
keyField = branch-key-id AND standardBeacon = S_standardBeaconValue
```