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.

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, definir la versión de las balizas, configurar un índice secundario para cada baliza, definir las acciones criptográficas 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.

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.

Temas

• Configuración de balizas estándar
• Configuración de balizas compuestas
• Configuraciones de ejemplo

Configuración de balizas estándar

Las balizas estándar 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<StandardBeacon> standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
    .name("beaconName")
    .length(beaconLengthInBits)
    .build();
standardBeaconList.add(exampleStandardBeacon);

C# / .NET

var standardBeaconList = new List<StandardBeacon>();
StandardBeacon exampleStandardBeacon = new StandardBeacon
  {
    Name = "beaconName",
    Length = 10
  };
standardBeaconList.Add(exampleStandardBeacon);
                        

Para configurar una baliza estándar, 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. Siempre que sea posible, recomendamos encarecidamente utilizar el nombre del campo cifrado o el campo virtual 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.

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.

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, 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.

Java

Consulta el ejemplo de código completo: VirtualBeaconSearchableEncryptionExample.java

List<VirtualPart> virtualPartList = new ArrayList<>();
    virtualPartList.add(sourceField1);
    virtualPartList.add(sourceField2);

VirtualField virtualFieldName = VirtualField.builder()
    .name("virtualFieldName")
    .parts(virtualPartList)
    .build();

List<VirtualField> virtualFieldList = new ArrayList<>();
    virtualFieldList.add(virtualFieldName);

C# / .NET

Vea el ejemplo de código completo: .cs VirtualBeaconSearchableEncryptionExample

var virtualPartList = new List<VirtualPart> { sourceField1, sourceField2 };

var virtualFieldName = new VirtualField
{
    Name = "virtualFieldName",
    Parts = virtualPartList
};

var virtualFieldList = new List<VirtualField> { virtualFieldName };

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 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.

Considere el siguiente ejemplo al revisar la seguridad de sus campos virtuales.

• Beacon1 se construye a partir de FieldA. FieldAtiene 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 2^N

Beacon2 preserva la seguridad tanto de Beacon1 como de Beacon2 si se cumplen las siguientes afirmaciones:

N ≥ (Beacon1 length)/2

y

N ≥ (Beacon2 length)/2

Definición de 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 de una baliza compuesta. No puede consultar directamente una baliza PartOnly estándar.

Java

List<StandardBeacon> standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
    .name("beaconName")
    .length(beaconLengthInBits)
    .style(
        BeaconStyle.builder()
           .partOnly(PartOnly.builder().build())
        .build()
    )
    .build();
standardBeaconList.add(exampleStandardBeacon);

C#/.NET

new StandardBeacon
{
    Name = "beaconName",
    Length = beaconLengthInBits,
    Style = new BeaconStyle
    {
        PartOnly = new PartOnly()
    }
}

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. Sharedlas 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<StandardBeacon> 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#/.NET

new StandardBeacon
{
    Name = "beacon2",
    Length = beaconLengthInBits,
    Style = new BeaconStyle
    {
        Shared = new Shared { Other = "beacon1" }
    }
}

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 consultaCONTAINS(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. 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. AsSetlas 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<StandardBeacon> standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
    .name("beaconName")
    .length(beaconLengthInBits)
    .style(
        BeaconStyle.builder()
           .asSet(AsSet.builder().build())
        .build()
    )
    .build();
standardBeaconList.add(exampleStandardBeacon);

C#/.NET

new StandardBeacon
{
    Name = "beaconName",
    Length = beaconLengthInBits,
    Style = new BeaconStyle
    {
        AsSet = new AsSet()
    }
}

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. SharedSetlas 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<StandardBeacon> 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#/.NET

new StandardBeacon
{
    Name = "beacon2",
    Length = beaconLengthInBits,
    Style = new BeaconStyle
    {
        SharedSet = new SharedSet { Other = "beacon1" }
    }
}

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_SIGNSIGN_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 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<CompoundBeacon> 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.

 List<BeaconVersion> 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# / .NET

Consulte el ejemplo de código completo: .cs BeaconConfig

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<CompoundBeacon>();       
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.

var beaconVersions = new List<BeaconVersion>
{
    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
            }
        }
    }
};

Puede definir las partes cifradas y las partes firmadas 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. 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.

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.

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.

Java

List<EncryptedPart> encryptedPartList = new ArrayList<>);
EncryptedPart encryptedPartExample = EncryptedPart.builder()
    .name("standardBeaconName")
    .prefix("E-")
    .build();
encryptedPartList.add(encryptedPartExample);

C# / .NET

var encryptedPartList = new List<EncryptedPart>();
var encryptedPartExample = new EncryptedPart
 {
    Name = "compoundBeaconName",
    Prefix = "E-"
 };
encryptedPartList.Add(encryptedPartExample);                                        
                                        

Lista de piezas firmadas

Identifica los campos firmados incluidos en la baliza compuesta.

nota

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.

Java

List<SignedPart> signedPartList = new ArrayList<>);
SignedPart signedPartExample = SignedPart.builder()
    .name("signedFieldName")
    .prefix("S-")
    .build();
signedPartList.add(signedPartExample);

C# / .NET

var signedPartsList = new List<SignedPart>
{
    new SignedPart { Name = "signedFieldName1", Prefix = "S-" },
    new SignedPart { Name = "signedFieldName2", Prefix = "SF-" }
};

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# / .NET

   var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true };

2. 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<ConstructorPart> 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<ConstructorPart> field421ConstructorPartList = new ArrayList<>();
   field421ConstructorPartList.add(field4ConstructorPart);
   field421ConstructorPartList.add(field2ConstructorPart);
   field421ConstructorPartList.add(field1ConstructorPart);
   Constructor field421Constructor = Constructor.builder()
           .parts(field421ConstructorPartList)
           .build();

   C# / .NET

   // Create a list for Field1.Field2.Field3 queries
    var field123ConstructorPartList = new Constructor
   {
       Parts = new List<ConstructorPart> { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart }
   };
   // Create a list for Field4.Field2.Field1 queries        
   var field421ConstructorPartList = new Constructor
   {
       Parts = new List<ConstructorPart> { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart }
   };                                            

3. Cree una lista de constructores que incluya todos los constructores que creó en el Paso 2.

   Java

   List<Constructor> constructorList = new ArrayList<>();
   constructorList.add(field123Constructor)
   constructorList.add(field421Constructor)

   C# / .NET

   var constructorList = new List<Constructor>
   {
       field123Constructor,
       field421Constructor
   };

4. Especifica el constructorList momento de crear la baliza compuesta.