Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Konfiguration von Beacons
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Es gibt zwei Arten von Beacons, die durchsuchbare Verschlüsselung unterstützen. Standard-Beacons führen Gleichheitssuchen durch. Sie sind der einfachste Weg, eine durchsuchbare Verschlüsselung in Ihrer Datenbank zu implementieren. Compound Beacons kombinieren wörtliche Klartext-Zeichenketten und Standard-Beacons, um komplexere Abfragen durchzuführen.
Beacons sind so konzipiert, dass sie in neuen, nicht aufgefüllten Datenbanken implementiert werden können. Jedes in einer vorhandenen Datenbank konfigurierte Beacon ordnet nur neue Datensätze zu, die in die Datenbank geschrieben wurden. Beacons werden anhand des Klartextwerts eines Felds berechnet. Sobald das Feld verschlüsselt ist, kann das Beacon keine vorhandenen Daten zuordnen. Nachdem Sie neue Datensätze mit einem Beacon geschrieben haben, können Sie die Konfiguration des Beacons nicht mehr aktualisieren. Sie können jedoch neue Beacons für neue Felder hinzufügen, die Sie Ihrem Datensatz hinzufügen.
Nachdem Sie Ihre Zugriffsmuster bestimmt haben, sollte die Konfiguration von Beacons der zweite Schritt in Ihrer Datenbankimplementierung sein. Nachdem Sie alle Ihre Beacons konfiguriert haben, müssen Sie einen [AWS KMS hierarchischen Schlüsselbund](use-hierarchical-keyring.md) erstellen, die Beacon-Version definieren, [einen sekundären Index für jedes Beacon konfigurieren](ddb-searchable-encryption.md#ddb-beacon-indexes), Ihre [kryptografischen Aktionen](concepts.md#crypt-actions) definieren und Ihre Datenbank und den Database Encryption SDK-Client konfigurieren. AWS [Weitere Informationen finden Sie unter Verwenden von Beacons.](using-beacons.md)
Um die Definition der Beacon-Version zu vereinfachen, empfehlen wir, Listen für Standard- und Verbund-Beacons zu erstellen. Fügen Sie jedes Beacon, das Sie erstellen, bei der Konfiguration der jeweiligen Standard- oder Verbund-Beacons hinzu.
**Topics**
+ [Konfiguration von Standard-Beacons](#config-standard-beacons)
+ [Konfiguration von Compound-Beacons](#config-compound-beacons)
+ [Beispielkonfigurationen](beacon-config-examples.md)
## Konfiguration von Standard-Beacons
[Standard-Beacons](beacons.md#standard-beacon-overview) sind die einfachste Methode, eine durchsuchbare Verschlüsselung in Ihrer Datenbank zu implementieren. Sie können nur Gleichheitssuchen für ein einzelnes verschlüsseltes oder virtuelles Feld durchführen.
### Beispiel für eine Konfigurationssyntax
------
#### [ 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 zu verwenden, aus dem Ihr Standard-Beacon erstellt wird. Zwei verschiedene Beacons können nicht denselben Beacon-Namen haben. Hilfe bei der Bestimmung des besten Beacon-Namens für Ihre Implementierung finden Sie unter [Auswahl eines](choosing-beacon-name.md) Beacon-Namens.
**Länge des Beacons**
Die Anzahl der Bits des Beacon-Hashwerts, die nach der Kürzung beibehalten werden.
Die Länge des Beacons bestimmt die durchschnittliche Anzahl von Fehlalarmen, die von einem bestimmten Beacon erzeugt werden. Weitere Informationen und Hilfe bei der Bestimmung der geeigneten Beacon-Länge für Ihre Implementierung finden Sie unter [Bestimmung](choosing-beacon-length.md) der Beacon-Länge.
**Beacon-Quelle (optional)**
Das Feld, aus dem ein Standard-Beacon erstellt wird.
Die Beacon-Quelle muss ein Feldname oder ein Index sein, der auf den Wert eines verschachtelten Felds verweist. Wenn Ihr Beacon-Name mit der Beacon-Quelle identisch ist, können Sie die Beacon-Quelle aus Ihrer Konfiguration weglassen und das AWS Database Encryption SDK verwendet den Beacon-Namen automatisch als Beacon-Quelle.
### Ein virtuelles Feld erstellen
Um ein [virtuelles Feld](beacons.md#virtual-field) zu erstellen, müssen Sie einen Namen für das virtuelle Feld und eine Liste der Quellfelder angeben. Die Reihenfolge, in der Sie der virtuellen Komponentenliste Quellfelder hinzufügen, bestimmt die Reihenfolge, in der sie zum Aufbau des virtuellen Felds verkettet werden. Im folgenden Beispiel werden zwei Quellfelder in ihrer Gesamtheit verkettet, um ein virtuelles Feld zu erstellen.
**Anmerkung**
Wir empfehlen, zu überprüfen, ob Ihre virtuellen Felder das erwartete Ergebnis liefern, bevor Sie Ihre Datenbank auffüllen. Weitere Informationen finden Sie unter [Beacon-Ausgaben testen](ddb-searchable-encryption.md#ddb-beacon-testing).
------
#### [ Java ]
**[Sehen Sie sich das vollständige Codebeispiel an: .java VirtualBeaconSearchableEncryptionExample](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 ]
**[Sehen Sie sich das vollständige Codebeispiel an: .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 ]
**Sehen Sie sich das vollständige Codebeispiel** [an: 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];
```
------
Um ein virtuelles Feld mit einem bestimmten Segment eines Quellfeldes zu erstellen, müssen Sie diese Transformation definieren, bevor Sie das Quellfeld zu Ihrer virtuellen Teileliste hinzufügen.
#### Sicherheitsüberlegungen für virtuelle Felder
Beacons ändern den verschlüsselten Zustand des Feldes nicht. Bei der Verwendung von Beacons besteht jedoch ein inhärenter Kompromiss zwischen der Effizienz Ihrer Abfragen und der Menge an Informationen, die über die Verteilung Ihrer Daten preisgegeben werden. Die Art und Weise, wie Sie Ihr Beacon konfigurieren, bestimmt das Sicherheitsniveau, das durch dieses Beacon gewährleistet wird.
Vermeiden Sie es, ein virtuelles Feld mit Quellfeldern zu erstellen, die sich mit vorhandenen Standard-Beacons überschneiden. Das Erstellen virtueller Felder, die ein Quellfeld enthalten, das bereits zur Erstellung eines Standard-Beacons verwendet wurde, kann das Sicherheitsniveau für beide Beacons verringern. Das Ausmaß, in dem die Sicherheit reduziert wird, hängt von der Entropiestufe ab, die durch die zusätzlichen Quellfelder hinzugefügt wird. Der Grad der Entropie wird durch die Verteilung der Einzelwerte im zusätzlichen Quellfeld und die Anzahl der Bits bestimmt, die das zusätzliche Quellfeld zur Gesamtgröße des virtuellen Feldes beiträgt.
Sie können anhand der Population und [der Beacon-Länge](choosing-beacon-length.md) ermitteln, ob die Quellfelder für ein virtuelles Feld die Sicherheit Ihres Datensatzes gewährleisten. Die Population ist die erwartete Anzahl von Einzelwerten in einem Feld. Ihre Population muss nicht exakt sein. Hilfe zur Schätzung der Grundgesamtheit eines Felds finden Sie unter [Grundgesamtheit schätzen](choosing-beacon-length.md#estimate-population).
Betrachten Sie das folgende Beispiel, wenn Sie die Sicherheit Ihrer virtuellen Felder überprüfen.
+ Beacon1 besteht aus. `FieldA` `FieldA`hat eine Population von mehr als **2 (Beacon1-Länge)**.
+ Beacon2 wird aus`VirtualField`, was aus,, und aufgebaut ist`FieldA`, `FieldB` konstruiert. `FieldC` `FieldD` **Zusammen `FieldD` haben, `FieldB``FieldC`, und eine Population von mehr als 2 N**
Beacon2 gewährleistet die Sicherheit von Beacon1 und Beacon2, wenn die folgenden Aussagen zutreffen:
```
N ≥ (Beacon1 length)/2
```
und
```
N ≥ (Beacon2 length)/2
```
### Definition von Beacon-Stilen
Standard-Beacons können verwendet werden, um Gleichheitssuchen für ein verschlüsseltes oder virtuelles Feld durchzuführen. Sie können auch verwendet werden, um zusammengesetzte Beacons für komplexere Datenbankoperationen zu erstellen. Um Ihnen bei der Organisation und Verwaltung von Standard-Beacons zu helfen, bietet das AWS Database Encryption SDK die folgenden optionalen *Beacon-Stile*, die den Verwendungszweck eines Standard-Beacons definieren.
**Anmerkung**
Um Beacon-Stile zu definieren, müssen Sie Version 3.2 oder höher des Database Encryption SDK verwenden. AWS Stellen Sie die neue Version für alle Leser bereit, bevor Sie Beacon-Styles zu Ihren Beacon-Konfigurationen hinzufügen.
------
#### [ PartOnly ]
Ein Standard-Beacon, das als definiert ist, `PartOnly` kann nur zur Definition eines [verschlüsselten Teils](#encrypted-parts) eines zusammengesetzten Beacons verwendet werden. Sie können ein `PartOnly` Standard-Beacon nicht direkt abfragen.
**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 ]
Standardmäßig generiert jedes Standard-Beacon einen eindeutigen HMAC-Schlüssel für die Beacon-Berechnung. Daher können Sie keine Gleichheitssuche in den verschlüsselten Feldern von zwei separaten Standard-Beacons durchführen. Ein als definierter Standard-Beacon `Shared` verwendet für seine Berechnungen den HMAC-Schlüssel eines anderen Standard-Beacons.
Wenn Sie beispielsweise Felder mit `beacon1` Feldern vergleichen müssen, definieren Sie es `beacon2` `beacon2` als `Shared` Beacon, das den HMAC-Schlüssel von für seine Berechnungen verwendet. `beacon1`
**Anmerkung**
Berücksichtigen Sie Ihre Sicherheits- und Leistungsanforderungen, bevor Sie Beacons konfigurieren. `Shared` `Shared`Beacons können die Menge an statistischen Informationen, die über die Verteilung Ihres Datensatzes identifiziert werden können, erhöhen. Sie könnten beispielsweise Aufschluss darüber geben, welche gemeinsam genutzten Felder denselben Klartextwert enthalten.
**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 ]
Wenn es sich bei einem Feldwert um einen Satz handelt, berechnet das AWS Database Encryption SDK standardmäßig einen einzelnen Standard-Beacon für den Satz. Daher können Sie die Abfrage nicht ausführen, `CONTAINS(a, :value)` wenn sich ein verschlüsseltes `a` Feld befindet. Ein Standard-Beacon, definiert als, `AsSet` berechnet einzelne Standard-Beacon-Werte für jedes einzelne Element des Satzes und speichert den Beacon-Wert im Element als Satz. Dadurch kann das AWS Database Encryption SDK die Abfrage durchführen. `CONTAINS(a, :value)`
Um einen `AsSet` Standard-Beacon zu definieren, müssen die Elemente in der Gruppe aus derselben Population stammen, sodass sie alle dieselbe [Beacon-Länge](choosing-beacon-length.md) verwenden können. Das Beacon-Set enthält möglicherweise weniger Elemente als das Klartext-Set, wenn es bei der Berechnung der Beacon-Werte zu Kollisionen kommen sollte.
**Anmerkung**
Berücksichtigen Sie Ihre Sicherheits- und Leistungsanforderungen, bevor Sie Beacons konfigurieren. `AsSet` `AsSet`Beacons können die Menge an statistischen Informationen, die über die Verteilung Ihres Datensatzes identifiziert werden können, erhöhen. Sie könnten beispielsweise die Größe des Klartext-Datensatzes offenlegen.
**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 ]
Ein Standard-Beacon, definiert als, `SharedSet` kombiniert die `AsSet` Funktionen `Shared` und, sodass Sie Gleichheitssuchen für die verschlüsselten Werte einer Menge und eines Felds durchführen können. Auf diese Weise kann das AWS Database Encryption SDK die Abfrage durchführen, `CONTAINS(a, b)` bei der `a` es sich um einen verschlüsselten Satz und um ein verschlüsseltes Feld `b` handelt.
**Anmerkung**
Berücksichtigen Sie Ihre Sicherheits- und Leistungsanforderungen, bevor Sie `Shared` Beacons konfigurieren. `SharedSet`Beacons können die Menge an statistischen Informationen, die über die Verteilung Ihres Datensatzes identifiziert werden können, erhöhen. Sie könnten beispielsweise Aufschluss darüber geben, wie groß der Klartextsatz ist oder welche gemeinsam genutzten Felder denselben Klartextwert enthalten.
**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()?
```
------
## Konfiguration von Compound-Beacons
Zusammengesetzte Beacons kombinieren wörtliche Klartext-Zeichenketten und Standard-Beacons, um komplexe Datenbankoperationen durchzuführen, z. B. das Abfragen von zwei verschiedenen Datensatztypen aus einem einzigen Index oder das Abfragen einer Kombination von Feldern mit einem Sortierschlüssel. Zusammengesetzte Beacons können aus Feldern, und erstellt werden. `ENCRYPT_AND_SIGN` `SIGN_ONLY` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Sie müssen für jedes verschlüsselte Feld, das im Verbund-Beacon enthalten ist, einen Standard-Beacon erstellen.
**Anmerkung**
Wir empfehlen, zu überprüfen, ob Ihre Compound-Beacons das erwartete Ergebnis erzielen, bevor Sie Ihre Datenbank auffüllen. Weitere Informationen finden Sie unter Beacon-Ausgaben [testen](ddb-searchable-encryption.md#ddb-beacon-testing).
### Beispiel für eine Konfigurationssyntax
------
#### [ Java ]
**Konfiguration eines zusammengesetzten Beacons**
Im folgenden Beispiel werden verschlüsselte und signierte Teilelisten lokal in der Konfiguration der Compound Beacons definiert.
```
List compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
.name("compoundBeaconName")
.split(".")
.encrypted(encryptedPartList)
.signed(signedPartList)
.constructors(constructorList)
.build();
compoundBeaconList.add(exampleCompoundBeacon);
```
**Definition der Beacon-Version**
Im folgenden Beispiel werden verschlüsselte und signierte Teilelisten global in der Beacon-Version definiert. Weitere Informationen zur Definition der Beacon-Version finden Sie unter Beacons [verwenden](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 ]
**Sehen Sie sich das vollständige Codebeispiel** [an: .cs BeaconConfig](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/complexexample/BeaconConfig.cs)
**Konfiguration eines zusammengesetzten Beacons**
Im folgenden Beispiel werden verschlüsselte und signierte Teilelisten lokal in der Konfiguration der Compound Beacons definiert.
```
var compoundBeaconList = new List();
var exampleCompoundBeacon = new CompoundBeacon
{
Name = "compoundBeaconName",
Split = ".",
Encrypted = encryptedPartList,
Signed = signedPartList,
Constructors = constructorList
};
compoundBeaconList.Add(exampleCompoundBeacon);
```
**Definition der Beacon-Version**
Im folgenden Beispiel werden verschlüsselte und signierte Teilelisten global in der Beacon-Version definiert. Weitere Informationen zur Definition der Beacon-Version finden Sie unter Beacons [verwenden](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 ]
**Sehen Sie sich das vollständige Codebeispiel** [an: beacon\$1config.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/complexexample/beacon_config.rs)
**Konfiguration eines zusammengesetzten Beacons**
Im folgenden Beispiel werden verschlüsselte und signierte Teilelisten lokal in der Konfiguration der Compound Beacons definiert.
```
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];
```
------
Sie können Ihre [verschlüsselten und [signierten Teile](#signed-parts)](#encrypted-parts) in lokal oder global definierten Listen definieren. Wir empfehlen, Ihre verschlüsselten und signierten Teile wann immer möglich in einer globalen Liste in der [Beacon-Version](using-beacons.md#beacon-version) zu definieren. Indem Sie verschlüsselte und signierte Teile global definieren, können Sie jedes Teil einmal definieren und die Teile dann in mehreren Compound-Beacon-Konfigurationen wiederverwenden. Wenn Sie beabsichtigen, einen verschlüsselten oder signierten Teil nur einmal zu verwenden, können Sie ihn in einer lokalen Liste in der Compound-Beacon-Konfiguration definieren. Sie können in Ihrer [Konstruktorliste](#constructor-parts) sowohl auf lokale als auch auf globale Teile verweisen.
Wenn Sie Ihre verschlüsselten und signierten Teilelisten global definieren, müssen Sie eine Liste von Konstruktorteilen bereitstellen, in der alle Möglichkeiten aufgeführt sind, wie der Compound Beacon die Felder in Ihrer Compound-Beacon-Konfiguration zusammenstellen kann.
**Anmerkung**
Um verschlüsselte und signierte Teilelisten global zu definieren, müssen Sie Version 3.2 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version allen Lesern zur Verfügung, bevor Sie neue Teile global definieren.
Sie können bestehende Beacon-Konfigurationen nicht aktualisieren, um verschlüsselte und signierte Teilelisten global zu definieren.
Um eine Verbundstation zu konfigurieren, geben Sie die folgenden Werte an.
**Name des Beacons**
Der Name, den Sie bei der Abfrage eines verschlüsselten Felds verwenden.
Ein Beacon-Name kann derselbe Name wie ein verschlüsseltes Feld oder virtuelles Feld sein, er kann jedoch nicht derselbe Name wie ein unverschlüsseltes Feld sein. Keine zwei Beacons können denselben Beacon-Namen haben. Hilfe bei der Bestimmung des besten Beacon-Namens für Ihre Implementierung finden Sie unter [Auswahl eines](choosing-beacon-name.md) Beacon-Namens.
**Charakter teilen**
Das Zeichen, das verwendet wird, um die Teile zu trennen, aus denen Ihr Verbundsignal besteht.
Das Trennzeichen darf in den Klartextwerten der Felder, aus denen der Verbundbeacon aufgebaut ist, nicht vorkommen.
**Verschlüsselte Teileliste**
Identifiziert die `ENCRYPT_AND_SIGN` Felder, die im Compound Beacon enthalten sind.
Jeder Teil muss einen Namen und ein Präfix enthalten. Der Teilname muss der Name des Standard-Beacons sein, der aus dem verschlüsselten Feld erstellt wurde. Das Präfix kann eine beliebige Zeichenfolge sein, muss jedoch eindeutig sein. Ein verschlüsselter Teil kann nicht dasselbe Präfix wie ein signierter Teil haben. Es wird empfohlen, einen kurzen Wert zu verwenden, der den Teil von anderen Teilen unterscheidet, die vom Compound Beacon bedient werden.
Wir empfehlen, Ihre verschlüsselten Teile nach Möglichkeit global zu definieren. Sie könnten erwägen, einen verschlüsselten Teil lokal zu definieren, wenn Sie ihn nur in einem Compound Beacon verwenden möchten. Ein lokal definierter verschlüsselter Teil kann nicht dasselbe Präfix oder denselben Namen haben wie ein global definierter verschlüsselter Teil.
```
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()?
];
```
**Signierte Teileliste**
Identifiziert die signierten Felder, die im Compound Beacon enthalten sind.
Signierte Teile sind optional. Sie können einen Compound-Beacon konfigurieren, der keine signierten Teile referenziert.
Jeder Teil muss einen Namen, eine Quelle und ein Präfix enthalten. Die Quelle ist das `SIGN_ONLY` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` ODER-Feld, das der Teil identifiziert. Die Quelle muss ein Feldname oder ein Index sein, der auf den Wert eines verschachtelten Felds verweist. Wenn Ihr Teilname die Quelle identifiziert, können Sie die Quelle weglassen und das AWS Database Encryption SDK verwendet den Namen automatisch als Quelle. Wir empfehlen, wann immer möglich, die Quelle als Teilnamen anzugeben. Das Präfix kann eine beliebige Zeichenfolge sein, muss jedoch eindeutig sein. Ein signierter Teil kann nicht dasselbe Präfix wie ein verschlüsselter Teil haben. Es wird empfohlen, einen kurzen Wert zu verwenden, der den Teil von anderen Teilen unterscheidet, die vom Compound Beacon bedient werden.
Wir empfehlen, Ihre signierten Teile nach Möglichkeit global zu definieren. Sie könnten erwägen, ein signiertes Teil lokal zu definieren, wenn Sie es nur in einem Compound Beacon verwenden möchten. Ein lokal definierter signierter Teil kann nicht dasselbe Präfix oder denselben Namen haben wie ein global definierter signierter Teil.
```
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()?,
];
```
**Liste der Konstruktoren**
Identifiziert die *Konstruktoren*, die die verschiedenen Arten definieren, wie die verschlüsselten und signierten Teile durch den Compound Beacon zusammengesetzt werden können. Sie können in Ihrer Konstruktorliste sowohl auf lokale als auch auf globale Bauteile verweisen.
Wenn Sie Ihr Compound-Beacon aus global definierten, verschlüsselten und signierten Teilen erstellen, müssen Sie eine Konstruktorliste angeben.
Wenn Sie keine global definierten, verschlüsselten oder signierten Teile verwenden, um Ihren Compound-Beacon zu erstellen, ist die Liste der Konstruktoren optional. Wenn Sie keine Konstruktorliste angeben, stellt das AWS Database Encryption SDK den Compound Beacon mit dem folgenden Standardkonstruktor zusammen.
+ Alle signierten Teile in der Reihenfolge, in der sie der signierten Teileliste hinzugefügt wurden
+ Alle verschlüsselten Teile in der Reihenfolge, in der sie der verschlüsselten Teileliste hinzugefügt wurden
+ Alle Teile sind erforderlich
**Konstruktoren**
Jeder Konstruktor ist eine geordnete Liste von *Konstruktorteilen*, die eine Art und Weise definiert, wie der Compound Beacon zusammengebaut werden kann. Die Konstruktorteile werden in der Reihenfolge zusammengefügt, in der sie der Liste hinzugefügt wurden, wobei jeder Teil durch das angegebene Trennzeichen getrennt wird.
Jeder Konstruktorteil benennt einen verschlüsselten Teil oder einen signierten Teil und definiert, ob dieser Teil innerhalb des Konstruktors erforderlich oder optional ist. Wenn Sie beispielsweise ein zusammengesetztes Beacon für, und abfragen möchten `Field1` `Field1.Field2``Field1.Field2.Field3`, markieren Sie und `Field3` als optional `Field2` und erstellen Sie einen Konstruktor.
Jeder Konstruktor muss mindestens einen erforderlichen Teil haben. Wir empfehlen, den ersten Teil in jedem Konstruktor als erforderlich festzulegen, damit Sie den `BEGINS_WITH` Operator in Ihren Abfragen verwenden können.
Ein Konstruktor ist erfolgreich, wenn alle erforderlichen Teile im Datensatz vorhanden sind. Wenn Sie einen neuen Datensatz schreiben, ermittelt der Verbundbeacon anhand der Konstruktorliste, ob der Beacon aus den bereitgestellten Werten zusammengesetzt werden kann. Es versucht, den Beacon in der Reihenfolge zusammenzustellen, in der die Konstruktoren der Konstruktorliste hinzugefügt wurden, und verwendet den ersten Konstruktor, der erfolgreich ist. Wenn keine Konstruktoren erfolgreich sind, wird der Beacon nicht in den Datensatz geschrieben.
Alle Leser und Autoren sollten dieselbe Reihenfolge der Konstruktoren angeben, um sicherzustellen, dass ihre Abfrageergebnisse korrekt sind.
Verwenden Sie die folgenden Verfahren, um Ihre eigene Konstruktorliste anzugeben.
1. Erstellen Sie für jeden verschlüsselten und signierten Teil einen Konstruktorteil, um zu definieren, ob dieser Teil erforderlich ist oder nicht.
Der Name des Konstruktorteils muss der Name des Standard-Beacons oder des signierten Felds sein, für das er steht.
------
#### [ 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. **Erstellen Sie mithilfe der Konstruktorteile, die Sie in Schritt 1 erstellt haben, einen Konstruktor für jede mögliche Art und Weise, wie das Verbundsignal zusammengebaut werden kann.**
Wenn Sie beispielsweise nach `Field1.Field2.Field3` und abfragen möchten`Field4.Field2.Field3`, müssen Sie zwei Konstruktoren erstellen. `Field1`und `Field4` können beide erforderlich sein, da sie in zwei separaten Konstruktoren definiert sind.
------
#### [ 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. **Erstellen Sie eine Konstruktorliste, die alle Konstruktoren enthält, die Sie in Schritt 2 erstellt haben.**
------
#### [ 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. Geben Sie den an`constructorList`, wenn Sie Ihren Verbundbeacon erstellen.
# Beispielkonfigurationen
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Die folgenden Beispiele zeigen, wie Standard- und Verbund-Beacons konfiguriert werden. Die folgenden Konfigurationen bieten keine Beacon-Längen. Hilfe bei der Bestimmung der geeigneten Beacon-Länge für Ihre Konfiguration finden Sie unter [Wählen Sie eine Beacon-Länge](choosing-beacon-length.md).
Vollständige Codebeispiele, die die Konfiguration und Verwendung von Beacons demonstrieren, finden Sie in den durchsuchbaren Verschlüsselungsbeispielen für [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/) und [Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/) im -dynamodb-Repository unter. aws-database-encryption-sdk GitHub
**Topics**
+ [Standard-Beacons](#standard-config-examples)
+ [Zusammengesetzte Beacons](#compound-config-examples)
## Standard-Beacons
Wenn Sie das `inspector_id_last4` Feld nach exakten Übereinstimmungen abfragen möchten, erstellen Sie ein Standard-Beacon mit der folgenden Konfiguration.
------
#### [ 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];
```
------
## Zusammengesetzte Beacons
Wenn Sie die `UnitInspection` Datenbank auf `inspector_id_last4` und abfragen möchten`inspector_id_last4.unit`, erstellen Sie ein zusammengesetztes Beacon mit der folgenden Konfiguration. Für diesen Compound Beacon sind nur [verschlüsselte](configure-beacons.md#encrypted-parts) Teile erforderlich.
------
#### [ 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()?];
```
------