Configurazione dei beacon

La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul DynamoDB Encryption Client.

Esistono due tipi di beacon che supportano la crittografia ricercabile. I beacon standard eseguono ricerche di uguaglianza. Sono il modo più semplice per implementare la crittografia ricercabile nel database. I beacon composti combinano stringhe letterali in chiaro e beacon standard per eseguire query più complesse.

I beacon sono progettati per essere implementati in nuovi database non popolati. Qualsiasi beacon configurato in un database esistente mapperà solo i nuovi record scritti nel database. I beacon vengono calcolati in base al valore in chiaro di un campo, una volta crittografato il campo non è più possibile per il beacon di mappare i dati esistenti. Dopo aver scritto nuovi record con un beacon, non è possibile aggiornare la configurazione del beacon. Tuttavia, puoi aggiungere nuovi beacon per i nuovi campi che aggiungi al tuo record.

Dopo aver determinato i modelli di accesso, la configurazione dei beacon dovrebbe essere il secondo passaggio dell'implementazione del database. Quindi, dopo aver configurato tutti i beacon, è necessario creare un portachiavi AWS KMS gerarchico, definire la versione del beacon, configurare un indice secondario per ogni beacon, definire le azioni crittografiche e configurare il database e il client Database Encryption SDK. AWS Per ulteriori informazioni, consulta Utilizzo dei beacon.

Per semplificare la definizione della versione beacon, consigliamo di creare elenchi per beacon standard e composti. Aggiungi ogni beacon che crei al rispettivo elenco di beacon standard o compositi mentre li configuri.

Argomenti

• Configurazione dei beacon standard
• Configurazione dei beacon composti
• Configurazioni di esempio

Configurazione dei beacon standard

I beacon standard sono il modo più semplice per implementare la crittografia ricercabile nel database. Possono eseguire ricerche di uguaglianza solo per un singolo campo crittografato o virtuale.

Esempio di sintassi di configurazione

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);
                        

Per configurare un beacon standard, fornite i seguenti valori.

Nome del beacon

Il nome che usi per interrogare un campo crittografato.

Il nome di un beacon può avere lo stesso nome di un campo crittografato o di un campo virtuale, ma non può avere lo stesso nome di un campo non crittografato. Se possibile, consigliamo vivamente di utilizzare il nome del campo crittografato o del campo virtuale da cui è costruito il beacon standard. Due beacon diversi non possono avere lo stesso nome. Per informazioni su come determinare il nome del beacon migliore per l'implementazione, consulta Scelta del nome del beacon.

Lunghezza del faro

Il numero di bit del valore hash del beacon che vengono conservati dopo il troncamento.

La lunghezza del faro determina il numero medio di falsi positivi prodotti da un determinato faro. Per ulteriori informazioni e assistenza nella determinazione della lunghezza del beacon appropriata per l'implementazione, vedere Determinazione della lunghezza del beacon.

Fonte del beacon (opzionale)

Il campo da cui è costruito un beacon standard.

La fonte del beacon deve essere un nome di campo o un indice che si riferisce al valore di un campo annidato. Quando il nome del beacon è lo stesso della fonte del beacon, puoi omettere la fonte del beacon dalla configurazione e AWS Database Encryption SDK utilizzerà automaticamente il nome del beacon come fonte del beacon.

Creare un campo virtuale

Per creare un campo virtuale, è necessario fornire un nome per il campo virtuale e un elenco dei campi di origine. L'ordine in cui vengono aggiunti i campi di origine all'elenco delle parti virtuali determina l'ordine in cui vengono concatenati per creare il campo virtuale. L'esempio seguente concatena due campi sorgente nella loro interezza per creare un campo virtuale.

Nota

Ti consigliamo di verificare che i campi virtuali producano il risultato previsto prima di popolare il database. Per ulteriori informazioni, consulta Testing beacon outputs.

Java

Vedi l'esempio di codice completo: .java VirtualBeaconSearchableEncryptionExample

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

Guarda l'esempio di codice completo: .cs VirtualBeaconSearchableEncryptionExample

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

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

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

Per creare un campo virtuale con un segmento specifico di un campo sorgente, è necessario definire tale trasformazione prima di aggiungere il campo di origine all'elenco delle parti virtuali.

Considerazioni sulla sicurezza per i campi virtuali

I beacon non alterano lo stato crittografato del campo. Tuttavia, quando si utilizzano i beacon, esiste un compromesso intrinseco tra l'efficienza delle query e la quantità di informazioni rivelate sulla distribuzione dei dati. Il modo in cui configuri il beacon determina il livello di sicurezza che viene mantenuto da quel beacon.

Evitate di creare un campo virtuale con campi sorgente che si sovrappongono ai beacon standard esistenti. La creazione di campi virtuali che includono un campo sorgente che è già stato utilizzato per creare un beacon standard può ridurre il livello di sicurezza di entrambi i beacon. La misura in cui la sicurezza viene ridotta dipende dal livello di entropia aggiunto dai campi sorgente aggiuntivi. Il livello di entropia è determinato dalla distribuzione di valori univoci nel campo sorgente aggiuntivo e dal numero di bit con cui il campo sorgente aggiuntivo contribuisce alla dimensione complessiva del campo virtuale.

È possibile utilizzare la popolazione e la lunghezza del beacon per determinare se i campi di origine di un campo virtuale preservano la sicurezza del set di dati. La popolazione è il numero previsto di valori univoci in un campo. Non è necessario che la tua popolazione sia precisa. Per informazioni sulla stima della popolazione di un campo, vedi Stima della popolazione.

Considera il seguente esempio quando esamini la sicurezza dei tuoi campi virtuali.

• Beacon1 è costruito da. FieldA FieldAha una popolazione superiore a 2 ^{(lunghezza Beacon1}).

• Beacon2 è costruito daVirtualField, che è costruito da,, e. FieldA FieldB FieldC FieldD ^{Insieme, FieldBFieldC, e FieldD hanno una popolazione superiore a 2 N}

Beacon2 preserva la sicurezza sia di Beacon1 che di Beacon2 se le seguenti affermazioni sono vere:

N ≥ (Beacon1 length)/2

e

N ≥ (Beacon2 length)/2

Definizione degli stili dei beacon

I beacon standard possono essere utilizzati per eseguire ricerche di uguaglianza per un campo crittografato o virtuale. In alternativa, possono essere utilizzati per costruire beacon composti per eseguire operazioni di database più complesse. Per aiutarvi a organizzare e gestire i beacon standard, il AWS Database Encryption SDK fornisce i seguenti stili di beacon opzionali che definiscono l'uso previsto di un beacon standard.

Nota

Per definire gli stili dei beacon, è necessario utilizzare la versione 3.2 o successiva di Database Encryption SDK. AWS Distribuisci la nuova versione a tutti i lettori prima di aggiungere stili beacon alle configurazioni dei beacon.

PartOnly

Un beacon standard definito come PartOnly può essere utilizzato solo per definire una parte crittografata di un beacon composto. Non è possibile interrogare direttamente un beacon standard. PartOnly

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

Per impostazione predefinita, ogni beacon standard genera una chiave HMAC unica per il calcolo del beacon. Di conseguenza, non è possibile eseguire una ricerca di uguaglianza sui campi crittografati utilizzando due beacon standard separati. Un beacon standard definito come Shared utilizza la chiave HMAC di un altro beacon standard per i suoi calcoli.

Ad esempio, se devi confrontare beacon1 campi con beacon2 campi, definiscilo beacon2 come un Shared beacon che utilizza la chiave HMAC di per i suoi calcoli. beacon1

Nota

Considerate le vostre esigenze di sicurezza e prestazioni prima di configurare qualsiasi beacon. Shared Sharedi beacon potrebbero aumentare la quantità di informazioni statistiche identificabili sulla distribuzione del set di dati. Ad esempio, potrebbero rivelare quali campi condivisi contengono lo stesso valore di testo in chiaro.

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

Per impostazione predefinita, se il valore di un campo è un set, AWS Database Encryption SDK calcola un singolo beacon standard per il set. Di conseguenza, non è possibile eseguire la query CONTAINS(a, :value) dove si a trova un campo crittografato. Un beacon standard definito come AsSet calcola i singoli valori del beacon standard per ogni singolo elemento del set e memorizza il valore del beacon nell'elemento come set. Ciò consente al AWS Database Encryption SDK di eseguire la query. CONTAINS(a, :value)

Per definire un beacon AsSet standard, gli elementi del set devono appartenere alla stessa popolazione in modo che possano utilizzare tutti la stessa lunghezza del beacon. Il set beacon potrebbe contenere un numero inferiore di elementi rispetto al set di testo in chiaro in caso di collisioni durante il calcolo dei valori del beacon.

Nota

Considerate le vostre esigenze di sicurezza e prestazioni prima di configurare qualsiasi beacon. AsSet AsSeti beacon potrebbero aumentare la quantità di informazioni statistiche identificabili sulla distribuzione del set di dati. Ad esempio, potrebbero rivelare la dimensione del set di testo in chiaro.

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

Un beacon standard definito come SharedSet combina le AsSet funzioni Shared and in modo da poter eseguire ricerche di uguaglianza sui valori crittografati di un set e di un campo. Ciò consente al AWS Database Encryption SDK di eseguire la query CONTAINS(a, b) in cui si a trova un set crittografato e b un campo crittografato.

Nota

Considerate le vostre esigenze di sicurezza e prestazioni prima di configurare qualsiasi Shared beacon. SharedSeti beacon potrebbero aumentare la quantità di informazioni statistiche identificabili sulla distribuzione del set di dati. Ad esempio, potrebbero rivelare la dimensione del set di testo in chiaro o quali campi condivisi contengono lo stesso valore di testo in chiaro.

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" }
    }
}

Configurazione dei beacon composti

I beacon composti combinano stringhe letterali in chiaro e beacon standard per eseguire operazioni complesse sul database, come interrogare due diversi tipi di record da un singolo indice o interrogare una combinazione di campi con una chiave di ordinamento. I beacon composti possono essere costruiti da, e campi. ENCRYPT_AND_SIGN SIGN_ONLY SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT È necessario creare un beacon standard per ogni campo crittografato incluso nel beacon composto.

Nota

Ti consigliamo di verificare che i beacon compositi producano il risultato previsto prima di popolare il database. Per ulteriori informazioni, consulta Testing beacon outputs.

Esempio di sintassi di configurazione

Java

Configurazione del beacon composto

L'esempio seguente definisce gli elenchi di parti crittografati e firmati localmente all'interno della configurazione del beacon composto.

List<CompoundBeacon> compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
    .name("compoundBeaconName")
    .split(".")
    .encrypted(encryptedPartList) 
    .signed(signedPartList)                       
    .constructors(constructorList) 
    .build();
compoundBeaconList.add(exampleCompoundBeacon);

Definizione della versione del beacon

L'esempio seguente definisce gli elenchi di parti crittografati e firmati a livello globale nella versione beacon. Per ulteriori informazioni sulla definizione della versione beacon, vedete Uso dei beacon.

 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

Guarda l'esempio di codice completo: .cs BeaconConfig

Configurazione del beacon composto

L'esempio seguente definisce gli elenchi di parti crittografati e firmati localmente all'interno della configurazione del beacon composto.

var compoundBeaconList = new List<CompoundBeacon>();       
var exampleCompoundBeacon = new CompoundBeacon
 {
    Name = "compoundBeaconName",
    Split = ".",
    Encrypted = encryptedPartList,
    Signed = signedPartList,                        
    Constructors = constructorList 
 };
compoundBeaconList.Add(exampleCompoundBeacon);

Definizione della versione del beacon

L'esempio seguente definisce gli elenchi di parti crittografati e firmati a livello globale nella versione beacon. Per ulteriori informazioni sulla definizione della versione beacon, vedete Uso dei beacon.

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
            }
        }
    }
};

È possibile definire le parti crittografate e le parti firmate in elenchi definiti localmente o globalmente. Ti consigliamo di definire le parti crittografate e firmate in un elenco globale nella versione beacon, quando possibile. Definendo le parti crittografate e firmate a livello globale, è possibile definire ogni parte una volta e quindi riutilizzarle in più configurazioni beacon composte. Se intendete utilizzare una parte crittografata o firmata una sola volta, potete definirla in un elenco locale nella configurazione del beacon composto. È possibile fare riferimento sia alle parti locali che a quelle globali nell'elenco dei costruttori.

Se definite gli elenchi di parti crittografati e firmati a livello globale, dovete fornire un elenco di parti del costruttore che identifichi tutti i modi possibili in cui il beacon composto può assemblare i campi nella configurazione del beacon composto.

Nota

Per definire elenchi di parti crittografati e firmati a livello globale, è necessario utilizzare la versione 3.2 o successiva di Database Encryption SDK. AWS Distribuisci la nuova versione a tutti i lettori prima di definire nuove parti a livello globale.

Non è possibile aggiornare le configurazioni dei beacon esistenti per definire elenchi di parti crittografati e firmati a livello globale.

Per configurare un beacon composto, fornite i seguenti valori.

Nome del beacon

Il nome che usi per interrogare un campo crittografato.

Il nome di un beacon può avere lo stesso nome di un campo crittografato o di un campo virtuale, ma non può avere lo stesso nome di un campo non crittografato. Due beacon non possono avere lo stesso nome di beacon. Per informazioni su come determinare il nome del beacon migliore per l'implementazione, consulta Scelta del nome del beacon.

Carattere diviso

Il personaggio usato per separare le parti che compongono il faro composto.

Il carattere diviso non può apparire nei valori in chiaro di nessuno dei campi da cui è costruito il beacon composto.

Elenco delle parti crittografato

Identifica i ENCRYPT_AND_SIGN campi inclusi nel beacon composto.

Ogni parte deve includere un nome e un prefisso. Il nome della parte deve essere il nome del beacon standard costruito a partire dal campo crittografato. Il prefisso può essere qualsiasi stringa, ma deve essere univoco. Una parte crittografata non può avere lo stesso prefisso di una parte firmata. Si consiglia di utilizzare un valore breve che distingua la parte dalle altre parti servite dal beacon composto.

Ti consigliamo di definire le parti crittografate a livello globale quando possibile. Potresti prendere in considerazione la definizione locale di una parte crittografata se intendi utilizzarla solo in un beacon composto. Una parte crittografata definita localmente non può avere lo stesso prefisso o nome di una parte crittografata definita a livello globale.

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);                                        
                                        

Elenco delle parti firmate

Identifica i campi firmati inclusi nel beacon composto.

Nota

Le parti firmate sono opzionali. È possibile configurare un beacon composto che non faccia riferimento a parti firmate.

Ogni parte deve includere un nome, una fonte e un prefisso. L'origine è il SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT campo SIGN_ONLY o il campo identificato dalla parte. L'origine deve essere un nome di campo o un indice che si riferisce al valore di un campo annidato. Se il nome della parte identifica la fonte, puoi omettere la fonte e AWS Database Encryption SDK utilizzerà automaticamente il nome come fonte. Ti consigliamo di specificare l'origine come nome della parte quando possibile. Il prefisso può essere qualsiasi stringa, ma deve essere univoco. Una parte firmata non può avere lo stesso prefisso di una parte crittografata. Si consiglia di utilizzare un valore breve che distingua la parte dalle altre parti servite dal beacon composto.

Ti consigliamo di definire le parti firmate a livello globale quando possibile. Potresti prendere in considerazione la definizione locale di una parte firmata se intendi utilizzarla solo in un beacon composto. Una parte firmata definita localmente non può avere lo stesso prefisso o nome di una parte firmata definita a livello globale.

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-" }
};

Elenco dei costruttori

Identifica i costruttori che definiscono i diversi modi in cui le parti crittografate e firmate possono essere assemblate dal beacon composto. È possibile fare riferimento sia alle parti locali che a quelle globali nell'elenco dei costruttori.

Se costruite il vostro beacon composto da parti crittografate e firmate definite a livello globale, dovete fornire un elenco di costruttori.

Se non utilizzate parti crittografate o firmate definite a livello globale per costruire il beacon composto, l'elenco dei costruttori è facoltativo. Se non specificate un elenco di costruttori, AWS Database Encryption SDK assembla il beacon composto con il seguente costruttore predefinito.

• Tutte le parti firmate nell'ordine in cui sono state aggiunte all'elenco delle parti firmate

• Tutte le parti crittografate nell'ordine in cui sono state aggiunte all'elenco delle parti crittografate

• Tutte le parti sono obbligatorie

Costruttori

Ogni costruttore è un elenco ordinato di parti del costruttore che definisce un modo in cui il faro composto può essere assemblato. Le parti del costruttore vengono unite nell'ordine in cui vengono aggiunte all'elenco, con ogni parte separata dal carattere di divisione specificato.

Ogni parte del costruttore nomina una parte crittografata o firmata e definisce se tale parte è obbligatoria o facoltativa all'interno del costruttore. Ad esempio, se si desidera interrogare un beacon composto suField1, e Field1.Field2Field1.Field2.Field3, contrassegnarlo Field3 come facoltativo Field2 e creare un costruttore.

Ogni costruttore deve avere almeno una parte obbligatoria. Si consiglia di rendere obbligatoria la prima parte di ogni costruttore in modo da poter utilizzare l'BEGINS_WITHoperatore nelle query.

Un costruttore ha successo se tutte le parti necessarie sono presenti nel record. Quando si scrive un nuovo record, il beacon composto utilizza l'elenco dei costruttori per determinare se il beacon può essere assemblato in base ai valori forniti. Tenta di assemblare il beacon nell'ordine in cui i costruttori sono stati aggiunti all'elenco dei costruttori e utilizza il primo costruttore che riesce. Se nessun costruttore riesce, il beacon non viene scritto nel record.

Tutti i lettori e gli scrittori devono specificare lo stesso ordine di costruttori per garantire che i risultati delle query siano corretti.

Utilizzate le seguenti procedure per specificare il vostro elenco di costruttori.

1. Create una parte costruttore per ogni parte crittografata e parte firmata per definire se quella parte è necessaria o meno.

   Il nome della parte del costruttore deve essere il nome del beacon standard o del campo firmato che rappresenta.

   Java

   ConstructorPart field1ConstructorPart = ConstructorPart.builder()
           .name("Field1")
           .required(true)
           .build();

   C# / .NET

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

2. Create un costruttore per ogni possibile modo in cui il beacon composto può essere assemblato utilizzando le parti del costruttore create nel passaggio 1.

   Ad esempio, se si desidera eseguire un'interrogazione su Field1.Field2.Field3 andField4.Field2.Field3, è necessario creare due costruttori. Field1e Field4 possono essere entrambi obbligatori perché sono definiti in due costruttori separati.

   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. Create un elenco di costruttori che includa tutti i costruttori creati nel passaggio 2.

   Java

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

   C# / .NET

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

4. Specificate constructorList quando create il beacon composto.