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á.
# Uso de beacons
****
| |
| --- |
| 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). |
Os beacons permitem pesquisar registros criptografados sem descriptografar todo o banco de dados que está sendo consultado. Os beacons são projetados para serem implementados em bancos de dados novos e vazios. Qualquer beacon configurado em um banco de dados existente mapeará somente novos registros gravados no banco de dados. Os beacons são calculados a partir do valor de texto simples de um campo, uma vez que o campo é criptografado, não há como o beacon mapear os dados existentes. Depois de gravar novos registros com o beacon, não será possível atualizar a configuração do beacon. No entanto, é possível adicionar novos beacons aos novos campos que você adiciona ao seu registro.
Depois de configurar seus beacons, você deve concluir as etapas a seguir antes de começar a preencher seu banco de dados e realizar consultas em seus beacons.
1. **Crie um AWS KMS chaveiro hierárquico**
[Para usar a criptografia pesquisável, você deve usar o [token de autenticação hierárquico do AWS KMS](use-hierarchical-keyring.md) para gerar, criptografar e descriptografar as chaves de dados](concepts.md#data-key) usadas para proteger seus registros.
[Depois de configurar seus beacons, reúna os [pré-requisitos do token de autenticação hierárquico](use-hierarchical-keyring.md#hierarchical-keyring-prereqs) e crie seu token de autenticação hierárquico](use-hierarchical-keyring.md#initialize-hierarchical-keyring).
Para obter mais detalhes sobre por que o token de autenticação hierárquico é necessário, consulte [Uso do token de autenticação hierárquico para criptografia pesquisável](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
1.
**Definir a versão do beacon **
Especifique sua`keyStore`,`keySource`, uma lista de todos os beacons padrão que você configurou, uma lista de todos os beacons compostos que você configurou, uma lista de peças criptografadas, uma lista de peças assinadas e uma versão do beacon. Você deve especificar `1` para a versão do beacon. Para obter orientação sobre como definir `keySource`, consulte [Definição da fonte de chave de beacon](use-hierarchical-keyring.md#beacon-key-source).
O exemplo de Java a seguir define a versão do beacon para um único banco de dados de locatário. Para obter ajuda na definição da versão do beacon para um banco de dados multilocatário, consulte [Criptografia pesquisável para bancos de dados multilocatários](searchable-encryption-multitenant.md).
------
#### [ Java ]
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.encryptedParts(encryptedPartsList)
.signedParts(signedPartsList)
.version(1) // MUST be 1
.keyStore(keyStore)
.keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branchKeyId)
.cacheTTL(6000)
.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
{
Single = new SingleKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000
}
}
}
};
```
------
#### [ 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::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()?,
))
.build()?;
let beacon_versions = vec![beacon_version];
```
------
1. **Configurar índices secundários**
Depois de [configurar os beacons](configure-beacons.md), você deve configurar um índice secundário que reflete cada beacon antes de poder pesquisar nos campos criptografados. Para obter mais informações, consulte [Configuração de índices secundários com beacons](ddb-searchable-encryption.md#ddb-beacon-indexes).
1. **Definir [ações criptográficas](concepts.md#crypt-actions)**
Todos os campos usados para construir um beacon padrão devem ser marcados com `ENCRYPT_AND_SIGN`. Todos os outros campos usados para construir beacons devem ser marcados `SIGN_ONLY` com ou. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
1. **Configurar um cliente SDK AWS de criptografia de banco de dados**
Para configurar um cliente SDK AWS de criptografia de banco de dados que proteja os itens da tabela em sua tabela do DynamoDB, [consulte Biblioteca de criptografia Java do lado do cliente](ddb-java.md) para o DynamoDB.
## Consultar beacons
O tipo de beacon que você configura determina o tipo de consultas que você é capaz de realizar. Os beacons padrão usam expressões de filtro para realizar pesquisas de igualdade. Os beacons compostos combinam cadeias de texto simples literais e beacons padrão para realizar consultas complexas. Ao consultar dados criptografados, você pesquisa pelo nome do beacon.
Não é possível comparar os valores de dois beacons padrão, mesmo que eles contenham o mesmo texto simples subjacente. Os dois beacons padrão produzirão duas etiquetas de HMAC diferentes para os mesmos valores de texto simples. Como resultado, os beacons padrão não podem realizar as consultas a seguir.
+ `beacon1 = beacon2`
+ `beacon1 IN (beacon2)`
+ `value IN (beacon1, beacon2, ...)`
+ `CONTAINS(beacon1, beacon2)`
Os beacons compostos podem realizar as consultas a seguir.
+ `BEGINS_WITH(a)`, onde `a` reflete o valor total do campo com o qual o beacon composto montado começa. Não é possível usar o operador `BEGINS_WITH` para identificar um valor que comece com uma substring específica. No entanto, é possível usar `BEGINS_WITH(S_)`, em que `S_` reflete o prefixo de uma parte com a qual o beacon composto montado começa.
+ `CONTAINS(a)`, em que `a` reflete o valor total de um campo que o beacon composto montado contém. Não é possível usar o operador `CONTAINS` para identificar um registro que contenha uma substring específica ou um valor dentro de um conjunto.
Por exemplo, não é possível realizar uma consulta `CONTAINS(path, "a"` em que `a` reflita o valor em um conjunto.
+ É possível comparar [partes assinadas](configure-beacons.md#signed-parts) de beacons compostos. Ao comparar partes assinadas, é possível, opcionalmente, acrescentar o prefixo de uma [parte criptografada](configure-beacons.md#encrypted-parts) a uma ou mais partes assinadas, mas não é possível incluir o valor de um campo criptografado em nenhuma consulta.
Por exemplo, é possível comparar partes assinadas e consultar em `signedField1 = signedField2` ou`value IN (signedField1, signedField2, ...)`.
Também é possível comparar partes assinadas e o prefixo de uma parte criptografada por meio de consulta em `signedField1.A_ = signedField2.B_`.
+ `field BETWEEN a AND b`, em que `a` e `b` são partes assinadas. Opcionalmente, é possível acrescentar o prefixo de uma parte criptografada a uma ou mais partes assinadas, mas não é possível incluir o valor de um campo criptografado em nenhuma consulta.
Você deve incluir o prefixo de cada parte incluída em uma consulta em um beacon composto. Por exemplo, se você construiu um beacon composto, `compoundBeacon`, a partir de dois campos `encryptedField` e `signedField`, deverá incluir os prefixos configurados para essas duas partes ao consultar o beacon.
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```