Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Cifrado con capacidad de búsqueda para bases de datos multitenencia
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
Para implementar un cifrado con capacidad de búsqueda en su base de datos, debe utilizar un [conjunto de claves de AWS KMS jerárquico](use-hierarchical-keyring.md). El conjunto de claves AWS KMS jerárquico genera, cifra y descifra las claves de datos utilizadas para proteger sus registros. También crea la clave de baliza que se utiliza para generar balizas. Cuando se utiliza el conjunto de claves AWS KMS jerárquico con bases de datos multiusuario, hay una clave de rama y una clave de baliza distintas para cada inquilino. Para consultar datos cifrados en una base de datos de multitenencia, debe identificar los materiales clave de baliza utilizados para generar la baliza que está consultando. Para obtener más información, consulte [Uso del conjunto de claves jerárquico para el cifrado para búsquedas](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
Al definir la [versión de baliza](using-beacons.md#beacon-version) para una base de datos de multitenencia, especifique una lista de todas las balizas estándar que configuró, una lista de todas las balizas compuestas que configuró, una versión de baliza y una `keySource`. Debe [definir la fuente de claves de baliza](use-hierarchical-keyring.md#beacon-key-source) como una `MultiKeyStore`, e incluir una`keyFieldName`, el tiempo de vida de la caché de claves de baliza local y el tamaño máximo de la caché de claves de baliza local.
Si configuró alguna [baliza firmada](configure.md#signed-beacons), debe incluirla en su `compoundBeaconList`. Las balizas firmadas son un tipo de baliza compuesta que indexan y realizan consultas complejas en los campos y campos. `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**
El [`keyFieldName`](use-hierarchical-keyring.md#keyFieldName) define el nombre del campo que almacena la `branch-key-id` asociada a la baliza utilizada para generar las balizas para un inquilino determinado.
Cuando se escriben nuevos registros en la base de datos, en este campo se almacena la `branch-key-id` de baliza utilizada para generar las balizas de ese registro.
De forma predeterminada, el `keyField` es un campo conceptual que no se almacena de forma explícita en la base de datos. El SDK AWS de cifrado de bases de datos identifica la [clave `branch-key-id` de los datos](concepts.md#data-key) cifrados en la [descripción del material](concepts.md#material-description) y almacena el valor en el concepto `keyField` para que pueda consultarlo en las balizas compuestas y balizas [firmadas](configure.md#signed-beacons). Como la descripción del material está firmada, lo conceptual `keyField` se considera una parte firmada.
También puede incluirlo `keyField` en sus acciones criptográficas como un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` campo `SIGN_ONLY` o para almacenar de forma explícita el campo en la base de datos. Si lo hace, debe incluir manualmente el `branch-key-id` en la `keyField` cada vez que escriba un registro en la base de datos.
## Consulta de balizas en una base de datos de multitenencia
Para consultar una baliza, debe incluir la `keyField` en la consulta los materiales clave necesarios para volver a calcular la baliza. Debe especificar la `branch-key-id` asociada a la baliza utilizada para generar las balizas para un registro. No puede especificar el [nombre amigable](use-hierarchical-keyring.md#branch-key-id-supplier) que identifica al `branch-key-id` del inquilino en el proveedor de ID de clave de rama. Puede incluir el `keyField` en sus consultas de las siguientes maneras.
**Balizas compuestas**
Ya sea que las almacene de forma explícita `keyField` en sus registros o no, puede incluir las `keyField` directamente en sus balizas compuestas como una parte firmada. La parte `keyField` firmada debe ser obligatoria.
Por ejemplo, si desea construir una baliza compuesta, `compoundBeacon`, a partir de dos campos, `encryptedField` y `signedField`, también debe incluir la baliza `keyField` como parte firmada. Esto permite realizar la siguiente consulta en `compoundBeacon`.
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue.K_branch-key-id
```
**Balizas firmadas**
El SDK AWS de cifrado de bases de datos utiliza balizas estándar y compuestas para proporcionar soluciones de cifrado con capacidad de búsqueda. Estas balizas deben incluir al menos un campo cifrado. Sin embargo, el SDK AWS de cifrado de bases de datos también admite [balizas firmadas](configure.md#signed-beacons) que se pueden configurar completamente a partir de texto sin formato `SIGN_ONLY` y campos. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Las balizas firmadas se pueden construir a partir de una sola pieza. Ya sea que las almacene de forma explícita `keyField` en sus registros o no, puede crear una baliza firmada a partir de ella `keyField` y utilizarla para crear consultas compuestas que combinen una consulta en la baliza `keyField` firmada con una consulta en una de las otras balizas. Por ejemplo, puede realizar la siguiente consulta.
```
keyField = K_branch-key-id AND compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```
Si necesita ayuda para configurar las balizas firmadas, consulte [Crear balizas firmadas](configure.md#signed-beacons)
**Realice consultas directamente en el `keyField`**
Si lo especificó `keyField` en sus acciones criptográficas y almacenó el campo de forma explícita en su registro, puede crear una consulta compuesta que combine una consulta de su baliza con una consulta de`keyField`. Puede optar por realizar una consulta directamente en el `keyField` si desea consultar una baliza estándar. Por ejemplo, puede realizar la siguiente consulta.
```
keyField = branch-key-id AND standardBeacon = S_standardBeaconValue
```