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.
# Configuración de las balizas
****
| |
| --- |
| 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). |
Existen dos tipos de balizas que admiten el cifrado para búsquedas. Las balizas estándar realizan búsquedas de igualdad. Son la forma más sencilla de implementar el cifrado para búsquedas en su base de datos. Las balizas compuestas combinan cadenas literales de texto no cifrado y balizas estándar para realizar consultas más complejas.
Las balizas están diseñadas para su implementación en bases de datos nuevas y despobladas. Cualquier baliza configurada en una base de datos existente solo mapeará los nuevos registros escritos en la base de datos. Las balizas se calculan a partir del valor de texto no cifrado de un campo. Una vez cifrado el campo, la baliza no tiene forma de mapear los datos existentes. Una vez que haya escrito nuevos registros con una baliza, no puede actualizar la configuración de la baliza. Sin embargo, puede agregar balizas nuevas para los campos nuevos que agregue a su registro.
Una vez determinados los patrones de acceso, la configuración de las balizas debería ser el segundo paso de la implementación de la base de datos. A continuación, después de configurar todas las balizas, debe crear un conjunto de [claves AWS KMS jerárquico](use-hierarchical-keyring.md), definir la versión de las balizas, [configurar un índice secundario para cada](ddb-searchable-encryption.md#ddb-beacon-indexes) baliza, definir las [acciones criptográficas](concepts.md#crypt-actions) y configurar la base de datos y el cliente del SDK de cifrado de bases de datos. AWS Para obtener más información, consulte [Utilizar balizas](using-beacons.md).
Para facilitar la definición de la versión de baliza, recomendamos crear listas de balizas estándar y compuestas. Agregue cada baliza que cree a la lista de balizas estándar o compuestas correspondiente a medida que las vaya configurando.
**Topics**
+ [Configuración de balizas estándar](#config-standard-beacons)
+ [Configuración de balizas compuestas](#config-compound-beacons)
+ [Configuraciones de ejemplo](beacon-config-examples.md)
## Configuración de balizas estándar
[Las balizas estándar](beacons.md#standard-beacon-overview) son la forma más sencilla de implementar el cifrado para búsquedas en su base de datos. Solo pueden realizar búsquedas de igualdad para un único campo virtual o cifrado.
### Ejemplo de sintaxis de configuración
------
#### [ Java ]
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
------
#### [ C\$1 / .NET ]
```
var standardBeaconList = new List();
StandardBeacon exampleStandardBeacon = new StandardBeacon
{
Name = "beaconName",
Length = 10
};
standardBeaconList.Add(exampleStandardBeacon);
```
------
#### [ Rust ]
```
let standard_beacon_list = vec con el que se construye la baliza estándar. Dos balizas diferentes no pueden tener el mismo nombre de baliza. Para obtener ayuda para determinar el mejor nombre de baliza para su implementación, consulte [Elegir un nombre de baliza](choosing-beacon-name.md).
**Longitud de la baliza**
El número de bits del valor hash de la baliza que se conservan tras el truncamiento.
La longitud de la baliza determina el número medio de falsos positivos producidos por una baliza determinada. Para obtener más información y ayuda para determinar la longitud de baliza adecuada para su implementación, consulte [Determinar la longitud de la baliza](choosing-beacon-length.md).
**Fuente de la baliza (opcional)**
El campo a partir del cual se construye una baliza estándar.
La fuente de la baliza debe ser un nombre de campo o un índice que haga referencia al valor de un campo anidado. Si el nombre de la baliza es el mismo que el de la fuente de la baliza, puede omitir la fuente de la baliza de la configuración y el SDK de cifrado de AWS bases de datos utilizará automáticamente el nombre de la baliza como fuente de la baliza.
### Creación de un campo virtual
Para crear un [campo virtual](beacons.md#virtual-field), debe proporcionar un nombre para el campo virtual y una lista de los campos de origen. El orden en que se agregan los campos de origen a la lista de piezas virtuales determina el orden en que se concatenan para crear el campo virtual. El siguiente ejemplo concatena dos campos de origen en su totalidad para crear un campo virtual.
**nota**
Recomendamos comprobar que los campos virtuales producen el resultado esperado antes de rellenar la base de datos. Para obtener más información, consulte [Probar los resultados de las balizas](ddb-searchable-encryption.md#ddb-beacon-testing).
------
#### [ Java ]
**Consulta el ejemplo de código completo**: [VirtualBeaconSearchableEncryptionExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/VirtualBeaconSearchableEncryptionExample.java)
```
List virtualPartList = new ArrayList<>();
virtualPartList.add(sourceField1);
virtualPartList.add(sourceField2);
VirtualField virtualFieldName = VirtualField.builder()
.name("virtualFieldName")
.parts(virtualPartList)
.build();
List virtualFieldList = new ArrayList<>();
virtualFieldList.add(virtualFieldName);
```
------
#### [ C\$1 / .NET ]
**[Vea el ejemplo de código completo: .cs VirtualBeaconSearchableEncryptionExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/VirtualBeaconSearchableEncryptionExample.cs)**
```
var virtualPartList = new List { sourceField1, sourceField2 };
var virtualFieldName = new VirtualField
{
Name = "virtualFieldName",
Parts = virtualPartList
};
var virtualFieldList = new List { virtualFieldName };
```
------
#### [ Rust ]
**Consulta el ejemplo de código completo**[: virtual\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/virtual_beacon_searchable_encryption.rs)
```
let virtual_part_list = vec![source_field_one, source_field_two];
let state_and_has_test_result_field = VirtualField::builder()
.name("virtual_field_name")
.parts(virtual_part_list)
.build()?;
let virtual_field_list = vec![virtual_field_name];
```
------
Para crear un campo virtual con un segmento específico de un campo de origen, debe definir esa transformación antes de agregar el campo de origen a la lista de piezas virtuales.
#### Aspectos de seguridad para campos virtuales
Las balizas no alteran el estado cifrado del campo. Sin embargo, cuando se utilizan balizas, existe un equilibrio inherente entre la eficacia de las consultas y la cantidad de información que se revela sobre la distribución de los datos. La forma en que configura su baliza determina el nivel de seguridad que preserva esa baliza.
Evite crear un campo virtual con campos de origen que se superpongan con las balizas estándar existentes. La creación de campos virtuales que incluyan un campo de origen que ya se haya utilizado para crear una baliza estándar puede reducir el nivel de seguridad de ambas balizas. La medida en que se reduzca la seguridad depende del nivel de entropía agregado por los campos de origen adicionales. El nivel de entropía está determinado por la distribución de valores únicos en el campo de origen adicional y el número de bits que el campo de origen adicional aporta al tamaño total del campo virtual.
Puede usar la población y la [longitud de la baliza](choosing-beacon-length.md) para determinar si los campos de origen de un campo virtual preservan la seguridad del conjunto de datos. La población es el número esperado de valores únicos en un campo. Su población no tiene por qué ser precisa. Para obtener ayuda para estimar la población de un campo, consulte [Estimar la población](choosing-beacon-length.md#estimate-population).
Considere el siguiente ejemplo al revisar la seguridad de sus campos virtuales.
+ Beacon1 se construye a partir de `FieldA`. `FieldA`tiene una población superior a **2 (longitud de Beacon1)**.
+ Beacon2 se construye a partir de `VirtualField`, que se construye a partir de `FieldA`, `FieldB`, `FieldC` y `FieldD`. Juntos, `FieldB`, `FieldC` y `FieldD` tienen una población superior a **2N**
Beacon2 preserva la seguridad tanto de Beacon1 como de Beacon2 si se cumplen las siguientes afirmaciones:
```
N ≥ (Beacon1 length)/2
```
and
```
N ≥ (Beacon2 length)/2
```
### Definir estilos de balizas
Las balizas estándar se pueden utilizar para realizar búsquedas de igualdad en un campo cifrado o virtual. O bien, se pueden usar para construir balizas compuestas para realizar operaciones de bases de datos más complejas. Para ayudarlo a organizar y administrar las balizas estándar, el SDK de cifrado de AWS bases de datos proporciona los siguientes *estilos de balizas* opcionales que definen el uso previsto de una baliza estándar.
**nota**
Para definir los estilos de balizas, debe usar la versión 3.2 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de añadir estilos de baliza a las configuraciones de baliza.
------
#### [ PartOnly ]
Una baliza estándar definida como solo se `PartOnly` puede utilizar para definir una [parte cifrada](#encrypted-parts) de una baliza compuesta. No se puede consultar directamente una baliza `PartOnly` estándar.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.partOnly(PartOnly.builder().build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1/.NET**
```
new StandardBeacon
{
Name = "beaconName",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
PartOnly = new PartOnly()
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon_name")
.length(beacon_length_in_bits)
.style(BeaconStyle::PartOnly(PartOnly::builder().build()?))
.build()?
```
------
#### [ Shared ]
De forma predeterminada, cada baliza estándar genera una clave HMAC única para el cálculo de la baliza. Como resultado, no se puede realizar una búsqueda de igualdad en los campos cifrados de dos balizas estándar independientes. Una baliza estándar definida como `Shared` utiliza la clave HMAC de otra baliza estándar para sus cálculos.
Por ejemplo, si necesita comparar `beacon1` campos con otros `beacon2` campos, defínalo `beacon2` como un `Shared` indicador que utilice la clave HMAC de `beacon1` para sus cálculos.
**nota**
Tenga en cuenta sus necesidades de seguridad y rendimiento antes de configurar cualquier `Shared` baliza. `Shared`las balizas pueden aumentar la cantidad de información estadística que se puede identificar sobre la distribución del conjunto de datos. Por ejemplo, pueden revelar qué campos compartidos contienen el mismo valor de texto sin formato.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beacon2")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.shared(Shared.builder().other("beacon1").build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1/.NET**
```
new StandardBeacon
{
Name = "beacon2",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
Shared = new Shared { Other = "beacon1" }
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon2")
.length(beacon_length_in_bits)
.style(BeaconStyle::Shared(
Shared::builder().other("beacon1").build()?,
))
.build()?
```
------
#### [ AsSet ]
De forma predeterminada, si el valor de un campo es un conjunto, el SDK de cifrado de AWS bases de datos calcula una única baliza estándar para el conjunto. Como resultado, no se puede realizar la consulta `CONTAINS(a, :value)` si `a` hay un campo cifrado. Una baliza estándar definida como `AsSet` calcula los valores de baliza estándar individuales para cada elemento individual del conjunto y almacena el valor de la baliza en el elemento como un conjunto. Esto permite que el SDK AWS de cifrado de bases de datos realice la consulta`CONTAINS(a, :value)`.
Para definir una baliza `AsSet` estándar, los elementos del conjunto deben ser de la misma población para que todos puedan utilizar la misma [longitud de baliza](choosing-beacon-length.md). El conjunto de balizas podría tener menos elementos que el conjunto de texto sin formato si se produjeran colisiones al calcular los valores de las balizas.
**nota**
Tenga en cuenta sus necesidades de seguridad y rendimiento antes de configurar cualquier `AsSet` baliza. `AsSet`las balizas pueden aumentar la cantidad de información estadística que se puede identificar sobre la distribución del conjunto de datos. Por ejemplo, pueden revelar el tamaño del conjunto de texto sin formato.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.asSet(AsSet.builder().build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1/.NET**
```
new StandardBeacon
{
Name = "beaconName",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
AsSet = new AsSet()
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon_name")
.length(beacon_length_in_bits)
.style(BeaconStyle::AsSet(AsSet::builder().build()?))
.build()?
```
------
#### [ SharedSet ]
Una baliza estándar definida como `SharedSet` combina las `AsSet` funciones `Shared` y para que puedas realizar búsquedas de igualdad en los valores cifrados de un conjunto y un campo. Esto permite que el SDK de cifrado de AWS bases de datos realice la consulta `CONTAINS(a, b)` cuando `a` hay un conjunto cifrado y `b` un campo cifrado.
**nota**
Tenga en cuenta sus necesidades de seguridad y rendimiento antes de configurar cualquier `Shared` baliza. `SharedSet`las balizas pueden aumentar la cantidad de información estadística que se puede identificar sobre la distribución del conjunto de datos. Por ejemplo, pueden revelar el tamaño del conjunto de texto sin formato o qué campos compartidos contienen el mismo valor de texto sin formato.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beacon2")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.sharedSet(SharedSet.builder().other("beacon1").build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1/.NET**
```
new StandardBeacon
{
Name = "beacon2",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
SharedSet = new SharedSet { Other = "beacon1" }
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon2")
.length(beacon_length_in_bits)
.style(BeaconStyle::SharedSet(
SharedSet::builder().other("beacon1").build()?,
))
.build()?
```
------
## Configuración de balizas compuestas
Las balizas compuestas combinan cadenas literales de texto no cifrado y balizas estándar para realizar operaciones complejas de bases de datos, como consultar dos tipos de registros diferentes desde un único índice o consultar una combinación de campos con una clave de clasificación. Las balizas compuestas se pueden construir a partir de `ENCRYPT_AND_SIGN``SIGN_ONLY`, y `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` campos. Debe crear una baliza estándar para cada campo cifrado incluido en la baliza compuesta.
**nota**
Se recomienda comprobar que las balizas compuestas producen el resultado esperado antes de rellenar la base de datos. Para obtener más información, consulte [Probar](ddb-searchable-encryption.md#ddb-beacon-testing) las salidas de las balizas.
### Ejemplo de sintaxis de configuración
------
#### [ Java ]
**Configuración de baliza compuesta**
El siguiente ejemplo define las listas de piezas cifradas y firmadas localmente dentro de la configuración de baliza compuesta.
```
List compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
.name("compoundBeaconName")
.split(".")
.encrypted(encryptedPartList)
.signed(signedPartList)
.constructors(constructorList)
.build();
compoundBeaconList.add(exampleCompoundBeacon);
```
**Definición de la versión de baliza**
El siguiente ejemplo define las listas de piezas cifradas y firmadas de forma global en la versión de baliza. Para obtener más información sobre cómo definir la versión de baliza, consulte [Uso de balizas](using-beacons.md).
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.encryptedParts(encryptedPartList)
.signedParts(signedPartList)
.version(1) // MUST be 1
.keyStore(keyStore)
.keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branchKeyId)
.cacheTTL(6000)
.build())
.build())
.build()
);
```
------
#### [ C\$1 / .NET ]
**[Consulte el ejemplo de código completo: .cs BeaconConfig](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/complexexample/BeaconConfig.cs)**
**Configuración de baliza compuesta**
El siguiente ejemplo define las listas de piezas cifradas y firmadas localmente dentro de la configuración de baliza compuesta.
```
var compoundBeaconList = new List();
var exampleCompoundBeacon = new CompoundBeacon
{
Name = "compoundBeaconName",
Split = ".",
Encrypted = encryptedPartList,
Signed = signedPartList,
Constructors = constructorList
};
compoundBeaconList.Add(exampleCompoundBeacon);
```
**Definición de la versión de baliza**
El siguiente ejemplo define las listas de piezas cifradas y firmadas de forma global en la versión de baliza. Para obtener más información sobre cómo definir la versión de baliza, consulte [Uso de balizas](using-beacons.md).
```
var beaconVersions = new List
{
new BeaconVersion
{
StandardBeacons = standardBeaconList,
CompoundBeacons = compoundBeaconList,
EncryptedParts = encryptedPartsList,
SignedParts = signedPartsList,
Version = 1, // MUST be 1
KeyStore = keyStore,
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branchKeyId,
CacheTTL = 6000
}
}
}
};
```
------
#### [ Rust ]
**Consulte el ejemplo de código completo**[: beacon\$1config.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/complexexample/beacon_config.rs)
**Configuración de baliza compuesta**
El siguiente ejemplo define las listas de piezas cifradas y firmadas localmente dentro de la configuración de baliza compuesta.
```
let compound_beacon_list = vec.
```
let beacon_versions = BeaconVersion::builder()
.standard_beacons(standard_beacon_list)
.compound_beacons(compound_beacon_list)
.encrypted_parts(encrypted_parts_list)
.signed_parts(signed_parts_list)
.version(1) // MUST be 1
.key_store(key_store.clone())
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
.key_id(branch_key_id)
.cache_ttl(6000)
.build()?,
))
.build()?;
let beacon_versions = vec![beacon_versions];
```
------
Puede definir [las partes cifradas y las partes](#encrypted-parts) [firmadas](#signed-parts) en listas definidas local o globalmente. Siempre que sea posible, le recomendamos que defina las partes cifradas y firmadas en una lista global en la [versión de baliza](using-beacons.md#beacon-version). Al definir las partes cifradas y firmadas de forma global, puede definir cada parte una vez y, a continuación, reutilizarlas en varias configuraciones de balizas compuestas. Si solo piensa utilizar una parte cifrada o firmada una vez, puede definirla en una lista local en la configuración de baliza compuesta. Puede hacer referencia a partes locales y globales en su [lista de constructores](#constructor-parts).
Si define sus listas de piezas cifradas y firmadas de forma global, debe proporcionar una lista de las partes constructoras que identifique todas las formas posibles en que la baliza compuesta puede ensamblar los campos en su configuración de baliza compuesta.
**nota**
Para definir listas de piezas cifradas y firmadas de forma global, debe utilizar la versión 3.2 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de definir cualquier pieza nueva a nivel mundial.
No puede actualizar las configuraciones de balizas existentes para definir listas de piezas cifradas y firmadas a nivel mundial.
Para configurar una baliza compuesta, proporcione los siguientes valores.
**Nombre de la baliza**
El nombre que se utiliza al consultar un campo cifrado.
El nombre de un indicador puede ser el mismo nombre que un campo cifrado o un campo virtual, pero no puede ser el mismo nombre que un campo no cifrado. No puede haber dos balizas con el mismo nombre de baliza. Para obtener ayuda para determinar el mejor nombre de baliza para su implementación, consulte [Elección de un nombre de baliza](choosing-beacon-name.md).
**Carácter dividido**
El personaje que se usa para separar las partes que conforman su baliza compuesta.
El carácter dividido no puede aparecer en los valores de texto no cifrado de ninguno de los campos a partir de los que se construye la baliza compuesta.
**Lista de piezas cifradas**
Identifica los campos `ENCRYPT_AND_SIGN` incluidos en la baliza compuesta.
Cada pieza debe incluir un nombre y un prefijo. El nombre de la pieza debe ser el nombre de la baliza estándar construida a partir del campo cifrado. El prefijo puede ser cualquier cadena, pero debe ser único. Una parte cifrada no puede tener el mismo prefijo que una parte firmada. Recomendamos utilizar un valor corto que distinga la pieza de otras partes servidas por la baliza compuesta.
Recomendamos definir las piezas cifradas de forma global siempre que sea posible. Podría considerar la posibilidad de definir una parte cifrada de forma local si solo pretende utilizarla en una baliza compuesta. Una parte cifrada definida localmente no puede tener el mismo prefijo o nombre que una parte cifrada definida globalmente.
```
List encryptedPartList = new ArrayList<>();
EncryptedPart encryptedPartExample = EncryptedPart.builder()
.name("standardBeaconName")
.prefix("E-")
.build();
encryptedPartList.add(encryptedPartExample);
```
```
var encryptedPartList = new List();
var encryptedPartExample = new EncryptedPart
{
Name = "compoundBeaconName",
Prefix = "E-"
};
encryptedPartList.Add(encryptedPartExample);
```
```
let encrypted_parts_list = vec![
EncryptedPart::builder()
.name("standard_beacon_name")
.prefix("E-")
.build()?
];
```
**Lista de piezas firmadas**
Identifica los campos firmados incluidos en la baliza compuesta.
Las partes firmadas son opcionales. Puede configurar una baliza compuesta que no haga referencia a ninguna parte firmada.
Cada parte debe incluir un nombre, una fuente y un prefijo. La fuente es el `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` campo `SIGN_ONLY` o que identifica la pieza. La fuente debe ser un nombre de campo o un índice que haga referencia al valor de un campo anidado. Si el nombre de la pieza identifica la fuente, puede omitirla y el SDK de cifrado de AWS bases de datos utilizará automáticamente el nombre como fuente. Recomendamos especificar la fuente como nombre de la pieza siempre que sea posible. El prefijo puede ser cualquier cadena, pero debe ser único. Una pieza firmada no puede tener el mismo prefijo que una parte cifrada. Recomendamos utilizar un valor corto que distinga la pieza de otras partes servidas por la baliza compuesta.
Recomendamos definir las piezas firmadas de forma global siempre que sea posible. Podría considerar la posibilidad de definir una pieza firmada de forma local si solo tiene intención de utilizarla en una baliza compuesta. Una parte firmada definida localmente no puede tener el mismo prefijo o nombre que una parte firmada definida globalmente.
```
List signedPartList = new ArrayList<>();
SignedPart signedPartExample = SignedPart.builder()
.name("signedFieldName")
.prefix("S-")
.build();
signedPartList.add(signedPartExample);
```
```
var signedPartsList = new List
{
new SignedPart { Name = "signedFieldName1", Prefix = "S-" },
new SignedPart { Name = "signedFieldName2", Prefix = "SF-" }
};
```
```
let signed_parts_list = vec![
SignedPart::builder()
.name("signed_field_name_1")
.prefix("S-")
.build()?,
SignedPart::builder()
.name("signed_field_name_2")
.prefix("SF-")
.build()?,
];
```
**Lista de constructores**
Identifica los *constructores* que definen las diferentes formas en que la baliza compuesta puede ensamblar las piezas cifradas y firmadas. Puede hacer referencia a partes locales y globales en su lista de constructores.
Si crea su baliza compuesta a partir de partes firmadas y cifradas definidas globalmente, debe proporcionar una lista de constructores.
Si no utiliza ninguna parte cifrada o firmada definida globalmente para construir la baliza compuesta, la lista de constructores es opcional. Si no especificas una lista de constructores, el SDK de cifrado AWS de bases de datos ensambla la baliza compuesta con el siguiente constructor predeterminado.
+ Todas las piezas firmadas en el orden en que se agregaron a la lista de piezas firmadas
+ Todas las piezas cifradas en el orden en que se agregaron a la lista de piezas cifradas
+ Todas las piezas son obligatorias
**Constructores**
Cada constructor es una lista ordenada de *piezas del constructor* que define una forma en la que se puede ensamblar la baliza compuesta. Las piezas del constructor se unen en el orden en que se agregan a la lista, con cada parte separada por el carácter dividido especificado.
Cada parte del constructor nombra una parte cifrada o una parte firmada y define si esa parte es obligatoria u opcional en el constructor. Por ejemplo, si desea consultar una baliza compuesta sobre `Field1`, `Field1.Field2` y `Field1.Field2.Field3`, marque `Field2` y `Field3` como opcional y cree un constructor.
Cada constructor debe tener como mínimo una pieza requerida. Recomendamos hacer que la primera parte de cada constructor sea obligatoria para poder usar el operador `BEGINS_WITH` en las consultas.
Un constructor tiene éxito si todas las piezas requeridas están presentes en el registro. Al escribir un registro nuevo, la baliza compuesta utiliza la lista de constructores para determinar si la baliza se puede ensamblar a partir de los valores proporcionados. Intente ensamblar la baliza en el orden en que se agregaron los constructores a la lista de constructores y utilice el primer constructor que lo haga correctamente. Si ningún constructor tiene éxito, la baliza no se graba en el registro.
Todos los lectores y redactores deben especificar el mismo orden de constructores para garantizar que los resultados de sus consultas sean correctos.
Utilice los siguientes procedimientos para especificar su propia lista de constructores.
1. Cree una parte constructora para cada pieza cifrada y firmada para definir si esa pieza es necesaria o no.
El nombre de la pieza constructora debe ser el nombre de la baliza estándar o el campo firmado que representa.
------
#### [ Java ]
```
ConstructorPart field1ConstructorPart = ConstructorPart.builder()
.name("Field1")
.required(true)
.build();
```
------
#### [ C\$1 / .NET ]
```
var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true };
```
------
#### [ Rust ]
```
let field_1_constructor_part = ConstructorPart::builder()
.name("field_1")
.required(true)
.build()?;
```
------
1. Cree un constructor para cada forma posible de ensamblaje de la baliza compuesta utilizando las piezas constructoras que creó en el **Paso 1**.
Por ejemplo, si desea consultar sobre `Field1.Field2.Field3` y `Field4.Field2.Field3`, debe crear dos constructores. Tanto `Field1` como `Field4` pueden ser necesarios porque están definidos en dos constructores distintos.
------
#### [ Java ]
```
// Create a list for Field1.Field2.Field3 queries
List field123ConstructorPartList = new ArrayList<>();
field123ConstructorPartList.add(field1ConstructorPart);
field123ConstructorPartList.add(field2ConstructorPart);
field123ConstructorPartList.add(field3ConstructorPart);
Constructor field123Constructor = Constructor.builder()
.parts(field123ConstructorPartList)
.build();
// Create a list for Field4.Field2.Field1 queries
List field421ConstructorPartList = new ArrayList<>();
field421ConstructorPartList.add(field4ConstructorPart);
field421ConstructorPartList.add(field2ConstructorPart);
field421ConstructorPartList.add(field1ConstructorPart);
Constructor field421Constructor = Constructor.builder()
.parts(field421ConstructorPartList)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a list for Field1.Field2.Field3 queries
var field123ConstructorPartList = new Constructor
{
Parts = new List { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart }
};
// Create a list for Field4.Field2.Field1 queries
var field421ConstructorPartList = new Constructor
{
Parts = new List { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart }
};
```
------
#### [ Rust ]
```
// Create a list for field1.field2.field3 queries
let field1_field2_field3_constructor = Constructor::builder()
.parts(vec![
field1_constructor_part,
field2_constroctor_part.clone(),
field3_constructor_part,
])
.build()?;
// Create a list for field4.field2.field1 queries
let field4_field2_field1_constructor = Constructor::builder()
.parts(vec![
field4_constructor_part,
field2_constroctor_part.clone(),
field1_constructor_part,
])
.build()?;
```
------
1. Cree una lista de constructores que incluya todos los constructores que creó en el **Paso 2**.
------
#### [ Java ]
```
List constructorList = new ArrayList<>();
constructorList.add(field123Constructor);
constructorList.add(field421Constructor);
```
------
#### [ C\$1 / .NET ]
```
var constructorList = new List
{
field123Constructor,
field421Constructor
};
```
------
#### [ Rust ]
```
let constructor_list = vec![
field1_field2_field3_constructor,
field4_field2_field1_constructor,
];
```
------
1. Especifica el `constructorList` momento de crear la baliza compuesta.
# Configuraciones de ejemplo
****
| |
| --- |
| 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). |
En los ejemplos siguientes, se muestra cómo configurar balizas estándar y compuestas. Las siguientes configuraciones no proporcionan longitudes de baliza. Para obtener ayuda para determinar la longitud adecuada de la baliza para su configuración, consulte [Elegir longitud de una baliza](choosing-beacon-length.md).
Para ver ejemplos de código completos que muestran cómo configurar y usar balizas, consulte los ejemplos de cifrado con capacidad de búsqueda en [Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption), [.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/) y [Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/) en el aws-database-encryption-sdk repositorio -dynamodb de. GitHub
**Topics**
+ [Balizas estándar](#standard-config-examples)
+ [Balizas compuestas](#compound-config-examples)
## Balizas estándar
Si desea consultar las coincidencias exactas en el campo `inspector_id_last4`, cree una baliza estándar con la siguiente configuración.
------
#### [ Java ]
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("inspector_id_last4")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
------
#### [ C\$1 / .NET ]
```
var standardBeaconList = new List>);
StandardBeacon exampleStandardBeacon = new StandardBeacon
{
Name = "inspector_id_last4",
Length = 10
};
standardBeaconList.Add(exampleStandardBeacon);
```
------
#### [ Rust ]
```
let last4_beacon = StandardBeacon::builder()
.name("inspector_id_last4")
.length(10)
.build()?;
let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?;
let standard_beacon_list = vec![last4_beacon, unit_beacon];
```
------
## Balizas compuestas
Si desea consultar la `UnitInspection` base de datos sobre `inspector_id_last4` y `inspector_id_last4.unit`, cree una baliza compuesta con la siguiente configuración. Esta baliza compuesta solo requiere [partes cifradas](configure-beacons.md#encrypted-parts).
------
#### [ Java ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
List standardBeaconList = new ArrayList<>();
StandardBeacon inspectorBeacon = StandardBeacon.builder()
.name("inspector_id_last4")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(inspectorBeacon);
StandardBeacon unitBeacon = StandardBeacon.builder()
.name("unit")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(unitBeacon);
// 2. Define the encrypted parts.
List encryptedPartList = new ArrayList<>();
// Each encrypted part needs a name and prefix
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
EncryptedPart encryptedPartInspector = EncryptedPart.builder()
.name("inspector_id_last4")
.prefix("I-")
.build();
encryptedPartList.add(encryptedPartInspector);
EncryptedPart encryptedPartUnit = EncryptedPart.builder()
.name("unit")
.prefix("U-")
.build();
encryptedPartList.add(encryptedPartUnit);
// 3. Create the compound beacon.
// This compound beacon only requires a name, split character,
// and list of encrypted parts
CompoundBeacon inspectorUnitBeacon = CompoundBeacon.builder()
.name("inspectorUnitBeacon")
.split(".")
.sensitive(encryptedPartList)
.build();
```
------
#### [ C\$1 / .NET ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
StandardBeacon inspectorBeacon = new StandardBeacon
{
Name = "inspector_id_last4",
Length = 10
};
standardBeaconList.Add(inspectorBeacon);
StandardBeacon unitBeacon = new StandardBeacon
{
Name = "unit",
Length = 30
};
standardBeaconList.Add(unitBeacon);
// 2. Define the encrypted parts.
var last4EncryptedPart = new EncryptedPart
// Each encrypted part needs a name and prefix
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
var last4EncryptedPart = new EncryptedPart
{
Name = "inspector_id_last4",
Prefix = "I-"
};
encryptedPartList.Add(last4EncryptedPart);
var unitEncryptedPart = new EncryptedPart
{
Name = "unit",
Prefix = "U-"
};
encryptedPartList.Add(unitEncryptedPart);
// 3. Create the compound beacon.
// This compound beacon only requires a name, split character,
// and list of encrypted parts
var compoundBeaconList = new List>);
var inspectorCompoundBeacon = new CompoundBeacon
{
Name = "inspector_id_last4",
Split = ".",
Encrypted = encryptedPartList
};
compoundBeaconList.Add(inspectorCompoundBeacon);
```
------
#### [ Rust ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
let last4_beacon = StandardBeacon::builder()
.name("inspector_id_last4")
.length(10)
.build()?;
let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?;
let standard_beacon_list = vec![last4_beacon, unit_beacon];
// 2. Define the encrypted parts.
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
let encrypted_parts_list = vec![
EncryptedPart::builder()
.name("inspector_id_last4")
.prefix("I-")
.build()?,
EncryptedPart::builder().name("unit").prefix("U-").build()?,
];
// 3. Create the compound beacon
// This compound beacon only requires a name, split character,
// and list of encrypted parts
let compound_beacon_list = vec![CompoundBeacon::builder()
.name("last4UnitCompound")
.split(".")
.encrypted(encrypted_parts_list)
.build()?];
```
------