As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criptografia pesquisável para bancos de dados multilocatários
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Para implementar a criptografia pesquisável em seu banco de dados, você deve usar um [token de autenticação hierárquico do AWS KMS](use-hierarchical-keyring.md). O AWS KMS chaveiro hierárquico gera, criptografa e descriptografa as chaves de dados usadas para proteger seus registros. Ele também cria a chave do beacon usada para gerar beacons. Ao usar o AWS KMS chaveiro hierárquico com bancos de dados multilocatários, há uma chave de ramificação e uma chave de beacon distintas para cada inquilino. Para consultar dados criptografados em um banco de dados multilocatário, você deve identificar os materiais de chave do beacon usados para gerar o beacon que você está consultando. Para obter mais informações, consulte [Uso do token de autenticação hierárquico para criptografia pesquisável](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
Ao definir a [versão do beacon](using-beacons.md#beacon-version) para um banco de dados multilocatário, especifique uma lista de todos os beacons padrão que você configurou, uma lista de todos os beacons compostos que você configurou, uma versão do beacon e uma `keySource`. Você deve [definir sua fonte de chave de beacon](use-hierarchical-keyring.md#beacon-key-source) como `MultiKeyStore` e incluir um `keyFieldName` de tempo de vida útil para o cache de chave de beacon local e tamanho máximo de cache para o cache de chave de beacon local.
Se você configurou algum [beacon assinado](configure.md#signed-beacons), ele deve ser incluído no seu `compoundBeaconList`. Os beacons assinados são um tipo de farol composto que indexa e executa consultas complexas em campos 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**
O [`keyFieldName`](use-hierarchical-keyring.md#keyFieldName) define o nome do campo que armazena o `branch-key-id` associado à chave de beacon usada para gerar beacons para um determinado locatário.
Quando você grava novos registros em seu banco de dados, a chave `branch-key-id` que identifica a chave de beacon usada para gerar quaisquer beacons para esse registro é armazenada nesse campo.
Por padrão, `keyField` é um campo conceitual que não está explicitamente armazenado em seu banco de dados. [O SDK AWS de criptografia de banco de dados identifica a [chave `branch-key-id` de dados](concepts.md#data-key) criptografada na [descrição do material](concepts.md#material-description) e armazena o valor no conceito `keyField` para você referenciar em seus beacons compostos e beacons assinados.](configure.md#signed-beacons) Como a descrição do material é assinada, o `keyField` conceitual é considerado uma parte assinada.
Você também pode incluir o `keyField` em suas ações criptográficas como um `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` campo `SIGN_ONLY` ou para armazenar explicitamente o campo em seu banco de dados. Se você fizer isso, deverá incluir manualmente o `branch-key-id` no `keyField` sempre que gravar um registro no seu banco de dados.
## Consultar beacons em um banco de dados multilocatário
Para consultar um beacon, você deve incluir o `keyField` em sua consulta para identificar os materiais de chave de beacon apropriados necessários para recalcular o beacon. Você deve especificar o `branch-key-id` associado à chave de beacon usada para gerar os beacons para um registro. Você não pode especificar o [nome amigável](use-hierarchical-keyring.md#branch-key-id-supplier) que identifica o nome de um locatário `branch-key-id` no fornecedor da ID da chave da ramificação. É possível incluir o `keyField` em suas consultas das maneiras a seguir.
**Beacons compostos**
Quer você armazene explicitamente o `keyField` em seus registros ou não, você poderá inclur `keyField` diretamente em seus beacons compostos como uma parte assinada. A parte `keyField` assinada deve ser necessária.
Por exemplo, se você quiser construir um beacon composto, `compoundBeacon`, a partir de dois campos, `encryptedField` e`signedField`, você também deverá incluir `keyField` como uma parte assinada. Isso permite executar a consulta a seguir em `compoundBeacon`.
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue.K_branch-key-id
```
**Beacons assinados**
O SDK AWS de criptografia de banco de dados usa beacons padrão e compostos para fornecer soluções de criptografia pesquisáveis. Esses beacons devem incluir pelo menos um campo criptografado. No entanto, o SDK AWS de criptografia de banco de dados também oferece suporte a [beacons assinados](configure.md#signed-beacons) que podem ser configurados inteiramente a partir de texto simples `SIGN_ONLY` e campos. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Os beacons assinados podem ser construídos a partir de uma única parte. Independentemente de você armazenar explicitamente `keyField` em seus registros ou não, você pode construir um beacon assinado a partir do `keyField` e usá-lo para criar consultas compostas que combinam uma consulta no beacon `keyField` assinado com uma consulta em um de seus outros beacons. Por exemplo, você poderia realizar a consulta a seguir.
```
keyField = K_branch-key-id AND compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```
Para obter ajuda sobre a configuração de beacons assinados, consulte [Criação de beacons assinados](configure.md#signed-beacons)
**Consulte diretamente no `keyField`**
Se você especificou o `keyField` em suas ações criptográficas e armazenou explicitamente o campo em seu registro, você pode criar uma consulta composta que combina uma consulta no seu beacon com uma consulta no `keyField`. É possível optar por consultar diretamente no `keyField` se desejar consultar um beacon padrão. Por exemplo, você poderia realizar a consulta a seguir.
```
keyField = branch-key-id AND standardBeacon = S_standardBeaconValue
```