翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Java
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
このトピックでは、DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x をインストールして使用する方法について説明します。 AWS Database Encryption SDK for DynamoDB を使用したプログラミングの詳細については、GitHub の aws-database-encryption-sdk-dynamodb リポジトリの [Java の例](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples)を参照してください。
**注記**
次のトピックでは、DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x に焦点を当てます。
クライアント側の暗号化ライブラリの名前が [AWS Database Encryption SDK](DDBEC-rename.md) に変更されました。 AWS Database Encryption SDK は、引き続き[レガシー DynamoDB 暗号化クライアントバージョン](legacy-dynamodb-encryption-client.md)をサポートします。
**Topics**
+ [前提条件](#ddb-java-prerequisites)
+ [インストール](#ddb-java-installation)
+ [Java クライアントの使用](ddb-java-using.md)
+ [Java の例](ddb-java-examples.md)
+ [既存のテーブルにバージョン 3.x を追加する](ddb-java-config-existing-table.md)
+ [バージョン 3.x に移行する](ddb-java-migrate.md)
## 前提条件
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x をインストールする前に、次の前提条件を満たしていることを確認してください。
**Java 開発環境**
Java 8 以降が必要になります。Oracle のウェブサイトで [Java SE のダウンロード](https://www.oracle.com/java/technologies/downloads/)に移動し、Java SE Development Kit (JDK) をダウンロードして、インストールします。
Oracle JDK を使用する場合は、[Java Cryptography Extension (JCE) 無制限強度の管轄ポリシーファイル](http://www.oracle.com/java/technologies/javase-jce8-downloads.html)をダウンロードして、インストールする必要があります。
**AWS SDK for Java 2.x**
AWS Database Encryption SDK for DynamoDB には、 の [DynamoDB 拡張クライアント](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html)モジュールが必要です AWS SDK for Java 2.x。SDK 全体またはこのモジュールだけをインストールできます。
のバージョンの更新については AWS SDK for Java、[「 のバージョン 1.x から 2.x への移行 AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html)」を参照してください。
AWS SDK for Java は Apache Maven から入手できます。全体の依存関係を宣言することも AWS SDK for Java、`dynamodb-enhanced`モジュールのみの依存関係を宣言することもできます。
**Apache Maven AWS SDK for Java を使用して をインストールする**
+ 依存関係として [AWS SDK for Java全体をインポートする](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project)には、`pom.xml` ファイルでそれを宣言します。
+ AWS SDK for Javaで Amazon DynamoDB モジュールのみの依存関係を作成するには、[特定のモジュールを指定](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies)する手順に従います。`groupId` を `software.amazon.awssdk` に、`artifactID` を `dynamodb-enhanced` に設定します。
**注記**
AWS KMS キーリングまたは AWS KMS 階層キーリングを使用する場合は、 AWS KMS モジュールの依存関係も作成する必要があります。`groupId` を `software.amazon.awssdk` に、`artifactID` を `kms` に設定します。
## インストール
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x は、次の方法でインストールできます。
**Apache Maven の使用**
Amazon DynamoDB Encryption Client for Java は、以下の依存定義を使用して、[Apache Maven](https://maven.apache.org/) を介して利用できます。
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Gradle Kotlin の使用**
Gradle プロジェクトの依存関係セクションに次を追加することで、[Gradle](https://gradle.org/) を使用して Amazon DynamoDB Encryption Client for Java に対する依存関係を宣言できます。
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**手動**
DynamoDB 用の Java クライアント側の暗号化ライブラリをインストールするには、[aws-database-encryption-sdk-dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub リポジトリのクローンを作成するか、ダウンロードします。
SDK をインストールしたら、このガイドのコード例と GitHub の aws-database-encryption-sdk-dynamodb リポジトリの [Java の例](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples)を確認して開始します。
# DynamoDB 用の Java クライアント側の暗号化ライブラリの使用
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
このトピックでは、DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x の関数とヘルパークラスの一部について説明します。
DynamoDB 用の Java クライアント側の暗号化ライブラリを使用したプログラミングの詳細については、GitHub の aws-database-encryption-sdk-dynamodb リポジトリにある [Java の例](java-examples.md)、[Java の例](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples)を参照してください。
**Topics**
+ [項目エンクリプタ](#ddb-item-encryptors)
+ [属性アクション](#ddb-attribute-actions)
+ [暗号化設定](#ddb-config-encrypt)
+ [項目の更新](#ddb-update-items)
+ [署名付きセットの復号化](#ddb-java-signed-sets)
## 項目エンクリプタ
その中核となる AWS Database Encryption SDK for DynamoDB は項目エンクリプタです。DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x を使用して、次の方法で DynamoDB テーブル項目の暗号化、署名、検証、および復号を行うことができます。
**DynamoDB Enhanced Client**
DynamoDB `PutItem` リクエストを使用してクライアント側で項目を自動的に暗号化して署名するように、`DynamoDbEncryptionInterceptor` で [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) を設定できます。DynamoDB Enhanced Client を使用すると、[アノテーション付きデータクラス](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean)を使用して属性アクションを定義できます。可能な場合は常に、DynamoDB Enhanced Client を使用することをお勧めします。
DynamoDB Enhanced Client は、[検索可能な暗号化](searchable-encryption.md)をサポートしていません。
AWS Database Encryption SDK は、[ネストされた属性](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)の注釈をサポートしていません。
**下位レベルの DynamoDB API**
DynamoDB `PutItem` リクエストを使用してクライアント側で項目を自動的に暗号化して署名するように、`DynamoDbEncryptionInterceptor` で[下位レベルの DynamoDB API](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) を設定できます。
[検索可能な暗号化](searchable-encryption.md)を使用するには、下位レベルの DynamoDB API を使用する必要があります。
**下位レベルの `DynamoDbItemEncryptor`**
下位レベルの `DynamoDbItemEncryptor` は、DynamoDB を呼び出すことなく、テーブル項目を直接暗号化して署名するか、または復号して検証します。DynamoDB の `PutItem` または `GetItem` リクエストは実行しません。例えば、下位レベルの `DynamoDbItemEncryptor` を使用して、既に取得した DynamoDB 項目を直接復号して検証できます。
下位レベルの `DynamoDbItemEncryptor` は、[検索可能な暗号化](searchable-encryption.md)をサポートしていません。
## AWS Database Encryption SDK for DynamoDB の属性アクション
[属性アクション](concepts.md#crypt-actions)は、暗号化および署名される属性値を決定します。この属性値は署名のみされ、署名されて暗号化コンテキストに含まれ、無視されます。
**注記**
`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 暗号化アクションを使用するには、 AWS Database Encryption SDK のバージョン 3.3 以降を使用する必要があります。[データモデルを更新して を含める前に、すべてのリーダー](ddb-update-data-model.md)に新しいバージョンをデプロイします`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
下位レベルの DynamoDB API または下位レベルの `DynamoDbItemEncryptor` を使用する場合は、属性アクションを手動で定義する必要があります。DynamoDB Enhanced Client を使用する場合は、属性アクションを手動で定義するか、またはアノテーション付きデータクラスを使用して、[`TableSchema` を生成](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html)できます。設定プロセスを簡素化するには、アノテーション付きデータクラスを使用することをお勧めします。アノテーション付きデータクラスを使用する場合、オブジェクトを 1 回だけモデル化する必要があります。
**注記**
属性アクションを定義した後、どの属性を署名から除外するかを定義する必要があります。将来、新しい署名なし属性を簡単に追加できるように、署名なし属性を識別するための個別のプレフィックス (「`:`」など) を選択することをお勧めします。DynamoDB スキーマと属性アクションを定義するときに `DO_NOTHING` とマークされたすべての属性の属性名にこのプレフィックスを含めます。
### アノテーション付きデータクラスを使用する
[アノテーション付きデータクラス](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean)を使用して、DynamoDB Enhanced Client および `DynamoDbEncryptionInterceptor` で属性アクションを指定します。 AWS Database Encryption SDK for DynamoDB は、[標準の DynamoDB 属性の注釈](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html)を使用して、属性を保護する方法を決定する属性のタイプを定義します。デフォルトでは、プライマリキーを除く属性がすべて暗号化されます。これらの属性は署名されますが、暗号化はされません。
**注記**
`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 暗号化アクションを使用するには、 AWS Database Encryption SDK のバージョン 3.3 以降を使用する必要があります。[データモデルを更新して を含める前に、すべてのリーダー](ddb-update-data-model.md)に新しいバージョンをデプロイします`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
DynamoDB 拡張クライアント注釈の詳細については、GitHub の aws-database-encryption-sdk-dynamodb リポジトリの [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) を参照してください。
デフォルトでは、プライマリキー属性は署名されてはいるが、暗号化されておらず (`SIGN_ONLY`)、他のすべての属性は暗号化されて署名されています (`ENCRYPT_AND_SIGN`)。属性を として定義する場合`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。例外を指定するには、DynamoDB 用の Java クライアント側の暗号化ライブラリで定義されている暗号化アノテーションを使用します。例えば、特定の属性を署名のみにしたい場合は、`@DynamoDbEncryptionSignOnly` アノテーションを使用します。特定の属性に署名して暗号化コンテキストに含める場合は、 を使用します`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`。特定の属性が署名も暗号化もされないようにしたい場合 (`DO_NOTHING`) は、`@DynamoDbEncryptionDoNothing` アノテーションを使用します。
**注記**
AWS Database Encryption SDK は、[ネストされた属性](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)の注釈をサポートしていません。
次の例は、`ENCRYPT_AND_SIGN`、、`SIGN_ONLY`および `DO_NOTHING`属性アクションの定義に使用される注釈を示しています。の定義に使用される注釈の例については`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`、「[SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)」を参照してください。
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
次のスニペットに示すように、アノテーション付きデータクラスを使用して `TableSchema` を作成します。
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### 属性アクションを手動で定義する
属性アクションを手動で指定するには、名前と値のペアが属性名と指定されたアクションを表す `Map` オブジェクトを作成します。
属性を暗号化して署名するように `ENCRYPT_AND_SIGN` を指定します。属性に署名するが暗号化はしないように `SIGN_ONLY` を指定します。`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` を指定して属性に署名し、暗号化コンテキストに含めます。属性に署名することなく、その属性を暗号化することはできません。属性を無視するように `DO_NOTHING` を指定します。
パーティション属性とソート属性は、 `SIGN_ONLY` または のいずれかである必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。属性を として定義する場合`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
**注記**
`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 暗号化アクションを使用するには、 AWS Database Encryption SDK のバージョン 3.3 以降を使用する必要があります。[データモデルを更新して を含める前に、すべてのリーダー](ddb-update-data-model.md)に新しいバージョンをデプロイします`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## AWS Database Encryption SDK for DynamoDB の暗号化設定
AWS Database Encryption SDK を使用する場合は、DynamoDB テーブルの暗号化設定を明示的に定義する必要があります。暗号化設定に必要な値は、属性アクションを手動で定義したか、またはアノテーション付きデータクラスを使用して定義したかによって異なります。
次のスニペットは、DynamoDB Enhanced Client、[https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html)、および個別のプレフィックスによって定義された、許可された署名なし属性を使用して、DynamoDB テーブルの暗号化設定を定義します。
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**論理テーブル名**
DynamoDB テーブルの論理テーブル名。
論理テーブル名は、DynamoDB の復元オペレーションを簡素化するために、テーブルに格納されているすべてのデータに暗号的にバインドされます。最初に暗号化設定を定義する際に、DynamoDB テーブル名を論理テーブル名として指定することを強くお勧めします。常に同じ論理テーブル名を指定する必要があります。復号を成功させるには、論理テーブル名が、暗号化の際に指定された名前と一致する必要があります。[DynamoDB テーブルをバックアップから復元](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html)した後に DynamoDB テーブル名が変更された場合でも、論理テーブル名を使用することで、復号オペレーションで引き続きテーブルが確実に認識されます。
**許可された署名なし属性**
属性アクションで `DO_NOTHING` とマークされた属性。
許可された署名なし属性は、どの属性が署名から除外されるかをクライアントに伝えます。クライアントは、他のすべての属性が署名に含まれていると想定します。その後、レコードを復号する際に、クライアントは、ユーザーが指定する、許可された署名なし属性の中からどの属性を検証する必要があり、どの属性を無視する必要があるかを決定します。許可された署名なし属性から属性を削除することはできません。
すべての `DO_NOTHING` 属性をリストする配列を作成することで、許可された署名なし属性を明示的に定義できます。また、`DO_NOTHING` 属性に名前を付ける際に個別のプレフィックスを指定し、そのプレフィックスを使用してどの属性が署名されていないかをクライアントに伝えることもできます。将来新しい `DO_NOTHING` 属性を追加するプロセスが簡素化されるため、個別のプレフィックスを指定することを強くお勧めします。詳細については、「[データモデルの更新](ddb-update-data-model.md)」を参照してください。
すべての `DO_NOTHING` 属性のためにプレフィックスを指定しない場合は、クライアントが復号時に署名されていないことを想定するすべての属性を明示的にリストする `allowedUnsignedAttributes` 配列を設定できます。どうしても必要な場合にのみ、許可された署名なし属性を明示的に定義する必要があります。
**検索設定 (オプション)**
`SearchConfig` は[ビーコンのバージョン](using-beacons.md#beacon-version)を定義します。
[検索可能な暗号化](searchable-encryption.md)または[署名付きビーコン](configure.md#signed-beacons)を使用するには、`SearchConfig` を指定する必要があります。
**アルゴリズムスイート (オプション)**
`algorithmSuiteId` は、 AWS Database Encryption SDK が使用するアルゴリズムスイートを定義します。
代替アルゴリズムスイートを明示的に指定しない限り、 AWS Database Encryption SDK は[デフォルトのアルゴリズムスイート](supported-algorithms.md#recommended-algorithms)を使用します。デフォルトのアルゴリズムスイートは、キーの導出、[デジタル署名](concepts.md#digital-sigs)、および[キーコミットメント](concepts.md#key-commitment)を備えた AES-GCM アルゴリズムを使用します。デフォルトのアルゴリズムスイートはほとんどのアプリケーションに適している可能性がありますが、代替アルゴリズムスイートを選択できます。例えば、一部の信頼モデルは、デジタル署名を含まないアルゴリズムスイートによって満たされます。 AWS Database Encryption SDK がサポートするアルゴリズムスイートの詳細については、「」を参照してください[AWS Database Encryption SDK でサポートされているアルゴリズムスイート](supported-algorithms.md)。
[ECDSA デジタル署名のない AES-GCM アルゴリズムスイート](supported-algorithms.md#other-algorithms)を選択するには、テーブル暗号化設定に次のスニペットを含めます。
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## AWS Database Encryption SDK を使用した項目の更新
AWS Database Encryption SDK は、暗号化または署名された項目に対して [ddb:UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) をサポートしていません。暗号化または署名された項目を更新するには、[ddb:PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html) を使用する必要があります。`PutItem` リクエストで既存の項目と同じプライマリキーを指定すると、新しい項目が既存の項目に完全に置き換わります。[CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) を使用して、項目を更新した後、保存する際にすべての属性をクリアして置き換えることもできます。
## 署名付きセットの復号化
AWS Database Encryption SDK のバージョン 3.0.0 および 3.1.0 では、[セットタイプ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes)属性を として定義した場合`SIGN_ONLY`、セットの値は指定された順序で正規化されます。DynamoDB はセットの順序を保持しません。その結果、セットを含む項目の署名の検証が失敗する可能性があります。セットの値が AWS Database Encryption SDK に提供された順序とは異なる順序で返されると、セット属性に同じ値が含まれている場合でも、署名の検証は失敗します。
**注記**
AWS Database Encryption SDK のバージョン 3.1.1 以降では、すべてのセットタイプ属性の値が正規化されるため、DynamoDB に書き込まれたのと同じ順序で値が読み取られます。
署名の検証が失敗すると、復号オペレーションは失敗して以下のエラーメッセージを返します。
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model.StructuredEncryptionException: 受信者タグが一致しませんでした。 |
上記のエラーメッセージが表示され、復号化しようとしているアイテムにバージョン 3.0.0 または 3.1.0 を使用して署名されたセットが含まれていると思われる場合、セットを正常に検証する方法の詳細として GitHub の aws-database-encryption-sdk-dynamodb-java リポジトリの [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute) ディレクトリを参照してください。
# Java の例
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
次の例は、DynamoDB 用の Java クライアント側の暗号化ライブラリを使用して、アプリケーション内のテーブル項目を保護する方法を示しています。その他の例については、GitHub の aws-database-encryption-sdk-dynamodb リポジトリにある [Java の例](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples)を参照してください (また、独自の例を提供してください）。
次の例は、データが入力されていない新しい Amazon DynamoDB テーブルで DynamoDB 用の Java クライアント側の暗号化ライブラリを設定する方法を示しています。既存の Amazon DynamoDB テーブルをクライアント側の暗号化のために設定する場合は、「[既存のテーブルにバージョン 3.x を追加する](ddb-java-config-existing-table.md)」を参照してください。
**Topics**
+ [DynamoDB 拡張クライアントの使用](#ddb-java-enhanced-client-example)
+ [下位レベルの DynamoDB API の使用](#ddb-java-lowlevel-API-example)
+ [下位レベルの DynamoDbItemEncryptor の使用](#ddb-java-itemencryptor)
## DynamoDB 拡張クライアントの使用
次の例は、[AWS KMS キーリング](use-kms-keyring.md)で DynamoDB Enhanced Client と `DynamoDbEncryptionInterceptor` を使用して、DynamoDB API 呼び出しの一部として DynamoDB テーブルの項目を暗号化する方法を示しています。
DynamoDB 拡張クライアントではサポートされている任意の[キーリング](keyrings.md)を使用できますが、可能な限りいずれかの AWS KMS キーリングを使用することをお勧めします。
**注記**
DynamoDB Enhanced Client は、[検索可能な暗号化](searchable-encryption.md)をサポートしていません。検索可能な暗号化を使用するには、下位レベルの DynamoDB API とともに `DynamoDbEncryptionInterceptor` を使用します。
**完全なコードサンプルを参照してください**: [EnhancedPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**ステップ 1: AWS KMS キーリングを作成する**
次の例では`CreateAwsKmsMrkMultiKeyring`、 を使用して、対称暗号化 KMS AWS KMS キーを使用して キーリングを作成します。`CreateAwsKmsMrkMultiKeyring` メソッドにより、キーリングは、単一リージョンのキーとマルチリージョンのキーの両方を確実に正しく処理します。
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**ステップ 2: アノテーション付きデータクラスからテーブルスキーマを作成する**
次の例では、アノテーション付きデータクラスを使用して、`TableSchema` を作成します。
この例では、アノテーション付きのデータクラスと属性アクションが [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) を使用して定義されていることを前提としています。属性アクションにアノテーションを付ける方法のガイダンスについては、「[アノテーション付きデータクラスを使用する](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)」を参照してください。
AWS Database Encryption SDK は、[ネストされた属性](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)の注釈をサポートしていません。
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**ステップ 3: 署名から除外する属性を定義する**
次の例では、すべての `DO_NOTHING` 属性が個別のプレフィックス「`:`」を共有し、そのプレフィックスを使用して、許可される署名なし属性を定義すると想定しています。クライアントは、「`:`」というプレフィックスが付いた属性名は署名から除外されると想定します。詳細については、「[Allowed unsigned attributes](ddb-java-using.md#allowed-unauth)」を参照してください。
```
final String unsignedAttrPrefix = ":";
```
**ステップ 4: 暗号化設定を作成する**
次の例では、DynamoDB テーブルの暗号化設定を表す `tableConfigs` マップを定義します。
この例では、DynamoDB テーブル名を[論理テーブル名](ddb-java-using.md#logical-table-name)として指定します。最初に暗号化設定を定義する際に、DynamoDB テーブル名を論理テーブル名として指定することを強くお勧めします。詳細については、「[AWS Database Encryption SDK for DynamoDB の暗号化設定](ddb-java-using.md#ddb-config-encrypt)」を参照してください。
[検索可能な暗号化](searchable-encryption.md)または[署名付きビーコン](configure.md#signed-beacons)を使用するには、暗号化設定に [`SearchConfig`](ddb-java-using.md#ddb-search-config) も含める必要があります。
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**ステップ 5: `DynamoDbEncryptionInterceptor` を作成する**
次の例では、**ステップ 4** の `tableConfigs` を使用して新しい `DynamoDbEncryptionInterceptor` を作成します。
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**ステップ 6: 新しい AWS SDK DynamoDB クライアントを作成する**
次の例では、**ステップ 5** `interceptor`の を使用して新しい AWS SDK DynamoDB クライアントを作成します。
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**ステップ 7: DynamoDB Enhanced Client を作成し、テーブルを作成する**
次の例では、**ステップ 6** で作成した AWS SDK DynamoDB クライアントを使用して DynamoDB Enhanced Client を作成し、アノテーション付きデータクラスを使用してテーブルを作成します。
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**ステップ 8: テーブル項目を暗号化して署名する**
次の例では、DynamoDB Enhanced Client を使用して項目を DynamoDB テーブルに配置します。項目は、DynamoDB に送信される前に、クライアント側で暗号化および署名されます。
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## 下位レベルの DynamoDB API の使用
次の例は、[AWS KMS キーリング](use-kms-keyring.md)とともに下位レベルの DynamoDB API を使用し、DynamoDB `PutItem` リクエストを使用してクライアント側で項目を自動的に暗号化して署名する方法を示しています。
サポートされている任意の[キーリング](keyrings.md)を使用できますが、可能な限りいずれかの AWS KMS キーリングを使用することをお勧めします。
**完全なコードサンプルを参照してください**: [BasicPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)
**ステップ 1: AWS KMS キーリングを作成する**
次の例では`CreateAwsKmsMrkMultiKeyring`、 を使用して、対称暗号化 KMS AWS KMS キーを使用して キーリングを作成します。`CreateAwsKmsMrkMultiKeyring` メソッドにより、キーリングは、単一リージョンのキーとマルチリージョンのキーの両方を確実に正しく処理します。
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**ステップ 2: 属性アクションを設定する**
次の例では、テーブル項目のサンプル[属性アクション](concepts.md#crypt-actions)を表す `attributeActionsOnEncrypt` マップを定義します。
次の例では、属性を として定義していません`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 属性を指定する場合、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**ステップ 3: 署名から除外する属性を定義する**
次の例では、すべての `DO_NOTHING` 属性が個別のプレフィックス「`:`」を共有し、そのプレフィックスを使用して、許可される署名なし属性を定義すると想定しています。クライアントは、「`:`」というプレフィックスが付いた属性名は署名から除外されると想定します。詳細については、「[Allowed unsigned attributes](ddb-java-using.md#allowed-unauth)」を参照してください。
```
final String unsignedAttrPrefix = ":";
```
**ステップ 4: DynamoDB テーブルの暗号化設定を定義する**
次の例では、この DynamoDB テーブルの暗号化設定を表す `tableConfigs` マップを定義します。
この例では、DynamoDB テーブル名を[論理テーブル名](ddb-java-using.md#logical-table-name)として指定します。最初に暗号化設定を定義する際に、DynamoDB テーブル名を論理テーブル名として指定することを強くお勧めします。詳細については、「[AWS Database Encryption SDK for DynamoDB の暗号化設定](ddb-java-using.md#ddb-config-encrypt)」を参照してください。
[検索可能な暗号化](searchable-encryption.md)または[署名付きビーコン](configure.md#signed-beacons)を使用するには、暗号化設定に [`SearchConfig`](ddb-java-using.md#ddb-search-config) も含める必要があります。
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**ステップ 5: `DynamoDbEncryptionInterceptor` を作成する**
次の例では、**ステップ 4** の `tableConfigs` を使用して `DynamoDbEncryptionInterceptor` を作成します。
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**ステップ 6: 新しい AWS SDK DynamoDB クライアントを作成する**
次の例では、**ステップ 5** `interceptor`の を使用して新しい AWS SDK DynamoDB クライアントを作成します。
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**ステップ 7: DynamoDB テーブル項目を暗号化して署名する**
次の例では、サンプルテーブル項目を表す `item` マップを定義し、その項目を DynamoDB テーブルに配置します。項目は、DynamoDB に送信される前に、クライアント側で暗号化および署名されます。
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## 下位レベルの DynamoDbItemEncryptor の使用
次の例は、下位レベルの `DynamoDbItemEncryptor` を [AWS KMS キーリング](use-kms-keyring.md)とともに使用して、テーブル項目を直接暗号化して署名する方法を示しています。`DynamoDbItemEncryptor` は項目を DynamoDB テーブルに配置しません。
DynamoDB 拡張クライアントではサポートされている任意の[キーリング](keyrings.md)を使用できますが、可能な限りいずれかの AWS KMS キーリングを使用することをお勧めします。
**注記**
下位レベルの `DynamoDbItemEncryptor` は、[検索可能な暗号化](searchable-encryption.md)をサポートしていません。検索可能な暗号化を使用するには、下位レベルの DynamoDB API とともに `DynamoDbEncryptionInterceptor` を使用します。
**完全なコードサンプルを参照してください**: [ItemEncryptDecryptExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**ステップ 1: AWS KMS キーリングを作成する**
次の例では`CreateAwsKmsMrkMultiKeyring`、 を使用して、対称暗号化 KMS AWS KMS キーを使用して キーリングを作成します。`CreateAwsKmsMrkMultiKeyring` メソッドにより、キーリングは、単一リージョンのキーとマルチリージョンのキーの両方を確実に正しく処理します。
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**ステップ 2: 属性アクションを設定する**
次の例では、テーブル項目のサンプル[属性アクション](concepts.md#crypt-actions)を表す `attributeActionsOnEncrypt` マップを定義します。
次の例では、属性を として定義していません`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 属性を指定する場合、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**ステップ 3: 署名から除外する属性を定義する**
次の例では、すべての `DO_NOTHING` 属性が個別のプレフィックス「`:`」を共有し、そのプレフィックスを使用して、許可される署名なし属性を定義すると想定しています。クライアントは、「`:`」というプレフィックスが付いた属性名は署名から除外されると想定します。詳細については、「[Allowed unsigned attributes](ddb-java-using.md#allowed-unauth)」を参照してください。
```
final String unsignedAttrPrefix = ":";
```
**ステップ 4: `DynamoDbItemEncryptor` 設定を定義する**
次の例では、`DynamoDbItemEncryptor` の設定を定義します。
この例では、DynamoDB テーブル名を[論理テーブル名](ddb-java-using.md#logical-table-name)として指定します。最初に暗号化設定を定義する際に、DynamoDB テーブル名を論理テーブル名として指定することを強くお勧めします。詳細については、「[AWS Database Encryption SDK for DynamoDB の暗号化設定](ddb-java-using.md#ddb-config-encrypt)」を参照してください。
```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
```
**ステップ 5: `DynamoDbItemEncryptor` を作成する**
次の例では、**ステップ 4** の `config` を使用して新しい `DynamoDbItemEncryptor` を作成します。
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**ステップ 6: テーブル項目を直接暗号化して署名する**
次の例では、`DynamoDbItemEncryptor` を使用して項目を直接暗号化し、署名します。`DynamoDbItemEncryptor` は項目を DynamoDB テーブルに配置しません。
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# AWS Database Encryption SDK for DynamoDB を使用するように既存の DynamoDB テーブルを設定する
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x を使用すると、既存の Amazon DynamoDB テーブルをクライアント側の暗号化用に設定できます。このトピックでは、データが入力されている既存の DynamoDB テーブルにバージョン 3.x を追加するために必要な 3 つのステップについてのガイダンスを提供します。
**前提条件**
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x では、 AWS SDK for Java 2.x で提供される [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) が必要です。[DynamoDBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) を引き続き使用する場合は、DynamoDB 拡張クライアント AWS SDK for Java 2.x を使用するには に移行する必要があります。
[AWS SDK for Javaのバージョン 1.x から 2.x に移行](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html)する手順に従います。
その後、[DynamoDB Enhanced Client API の使用を開始](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html)するための手順に従います。
DynamoDB 用の Java クライアント側の暗号化ライブラリを使用するようにテーブルを設定する前に、[アノテーション付きデータクラスを使用して](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) `TableSchema` を生成し、[拡張クライアントを作成](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)する必要があります。
## ステップ 1: 暗号化された項目の読み取りと書き込みの準備をする
Database Encryption SDK AWS クライアントが暗号化された項目を読み書きできるように準備するには、次の手順を実行します。次の変更をデプロイした後も、クライアントは引き続きプレーンテキスト項目の読み取りと書き込みを行います。テーブルに書き込まれる新しい項目の暗号化や署名は行いませんが、暗号化された項目が表示されるとすぐに復号できます。これらの変更により、クライアントが[新しい項目の暗号化](#ddb-java-add-step2)を開始するための準備が整います。次のステップに進む前に、次の変更を各リーダーにデプロイする必要があります。
**1. [属性アクション](concepts.md#crypt-actions)を定義する**
アノテーション付きデータクラスを更新して、どの属性値を暗号化して署名するか、どの属性値を署名のみにするか、どの属性値を無視するかを定義する属性アクションを含めます。
DynamoDB 拡張クライアント注釈の詳細については、GitHub の aws-database-encryption-sdk-dynamodb リポジトリの [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) を参照してください。
デフォルトでは、プライマリキー属性は署名されてはいるが、暗号化されておらず (`SIGN_ONLY`)、他のすべての属性は暗号化されて署名されています (`ENCRYPT_AND_SIGN`)。例外を指定するには、DynamoDB 用の Java クライアント側の暗号化ライブラリで定義されている暗号化アノテーションを使用します。例えば、特定の属性を署名のみにしたい場合は、`@DynamoDbEncryptionSignOnly` アノテーションを使用します。特定の属性に署名して暗号化コンテキストに含める場合は、 `@DynamoDbEncryptionSignAndIncludeInEncryptionContext`注釈を使用します。特定の属性が署名も暗号化もされないようにしたい場合 (`DO_NOTHING`) は、`@DynamoDbEncryptionDoNothing` アノテーションを使用します。
`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 属性を指定する場合、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。の定義に使用される注釈の例については`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`、「[SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)」を参照してください。
アノテーションの例については、「[アノテーション付きデータクラスを使用する](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)」を参照してください。
**2. 署名から除外する属性を定義する**
次の例では、すべての `DO_NOTHING` 属性が個別のプレフィックス「`:`」を共有し、そのプレフィックスを使用して、許可される署名なし属性を定義すると想定しています。クライアントは、「`:`」というプレフィックスが付いた属性名は署名から除外されると想定します。詳細については、「[Allowed unsigned attributes](ddb-java-using.md#allowed-unauth)」を参照してください。
```
final String unsignedAttrPrefix = ":";
```
**3. [キーリング](keyrings.md)を作成します。**
次の例では [AWS KMS キーリング](use-kms-keyring.md)を作成します。 AWS KMS キーリングは、対称暗号化または非対称 RSA AWS KMS keys を使用してデータキーを生成、暗号化、復号します。
この例では、`CreateMrkMultiKeyring` を使用して、対称暗号化 KMS キーで AWS KMS キーリングを作成します。`CreateAwsKmsMrkMultiKeyring` メソッドにより、キーリングは、単一リージョンのキーとマルチリージョンのキーの両方を確実に正しく処理します。
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. DynamoDB テーブルの暗号化設定を定義する **
次の例では、この DynamoDB テーブルの暗号化設定を表す `tableConfigs` マップを定義します。
この例では、DynamoDB テーブル名を[論理テーブル名](ddb-java-using.md#logical-table-name)として指定します。最初に暗号化設定を定義する際に、DynamoDB テーブル名を論理テーブル名として指定することを強くお勧めします。詳細については、「[AWS Database Encryption SDK for DynamoDB の暗号化設定](ddb-java-using.md#ddb-config-encrypt)」を参照してください。
プレーンテキストのオーバーライドとして `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` を指定する必要があります。このポリシーは、プレーンテキスト項目の読み取りと書き込みを継続し、暗号化された項目を読み取り、クライアントが暗号化された項目を書き込むための準備を整えます。
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. `DynamoDbEncryptionInterceptor` の作成**
次の例では、**ステップ 3** の `tableConfigs` を使用して `DynamoDbEncryptionInterceptor` を作成します。
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## ステップ 2: 暗号化および署名された項目を書き込む
`DynamoDbEncryptionInterceptor` 設定内のプレーンテキストポリシーを更新して、クライアントが暗号化および署名された項目を書き込むことを許可します。次の変更をデプロイすると、クライアントは**ステップ 1** で設定した属性アクションに基づいて新しい項目を暗号化して署名します。クライアントは、プレーンテキストの項目と暗号化および署名された項目を読み取ることができるようになります。
[ステップ 3](#ddb-java-add-step3) に進む前に、テーブル内の既存のすべてのプレーンテキスト項目を暗号化して署名する必要があります。既存のプレーンテキスト項目を迅速に暗号化するために実行できる単一のメトリクスやクエリはありません。システムにとって最も合理的なプロセスを使用してください。例えば、定義した属性アクションと暗号化設定を使用して、時間をかけてテーブルをスキャンし、項目を書き換える非同期プロセスを使用できます。テーブル内のプレーンテキスト項目を識別するには、 AWS Database Encryption SDK が暗号化および署名されたときに項目に追加する `aws_dbe_head`および `aws_dbe_foot` 属性を含まないすべての項目をスキャンすることをお勧めします。
次の の例では、**ステップ 1 **のテーブル暗号化設定を更新します。プレーンテキストのオーバーライドを `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` を使用して更新する必要があります。このポリシーはプレーンテキスト項目を引き続き読み取りますが、暗号化された項目の読み取りと書き込みも行います。更新された `DynamoDbEncryptionInterceptor`を使用して新しい を作成します`tableConfigs`。
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## ステップ 3: 暗号化および署名された項目のみを読み取る
すべての項目を暗号化して署名した後、`DynamoDbEncryptionInterceptor` 設定内のプレーンテキストオーバーライドを更新して、暗号化および署名された項目の読み取りと書き込みのみをクライアントに許可します。次の変更をデプロイすると、クライアントは**ステップ 1** で設定した属性アクションに基づいて新しい項目を暗号化して署名します。クライアントは、暗号化および署名された項目のみを読み取ることができます。
次の の例では、**ステップ 2 **のテーブル暗号化設定を更新します。`FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` を使用してプレーンテキストオーバーライドを更新することも、設定からプレーンテキストポリシーを削除することもできます。クライアントは、デフォルトでは、暗号化および署名された項目の読み取りと書き込みのみを行います。更新された `DynamoDbEncryptionInterceptor`を使用して新しい を作成します`tableConfigs`。
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x に移行する
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x は、2.x コードベースを大幅に書き直したものです。これには、新しい構造化データ形式、マルチテナンシーのサポートの改善、シームレスなスキーマの変更、検索可能な暗号化のサポートなど、多くの更新が含まれています。このトピックでは、コードをバージョン 3.x に移行する方法について説明します。
## バージョン 1.x から 2.x への移行
バージョン 3.x に移行する前に、バージョン 2.x に移行してください。バージョン 2.x では、最新プロバイダーの符号が `MostRecentProvider` から `CachingMostRecentProvider` に変更されました。現在、符号が `MostRecentProvider` である DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 1.x を使用している場合は、コード内の符号名を `CachingMostRecentProvider` に更新する必要があります。詳細については、「[最新のプロバイダーに更新する](most-recent-provider.md#mrp-versions)」を参照してください。
## バージョン 2.x から 3.x への移行
次の手順では、DynamoDB 用の Java クライアント側の暗号化ライブラリのコードをバージョン 2.x からバージョン 3.x に移行する方法について説明します。
### ステップ 1. 新しい形式で項目を読み取る準備をする
Database Encryption SDK AWS クライアントが新しい形式の項目を読み取る準備をするには、次の手順を実行します。次の変更をデプロイした後、クライアントは引き続きバージョン 2.x と同じように動作します。クライアントは引き続きバージョン 2.x 形式で項目の読み取りと書き込みを行いますが、これらの変更により、クライアントが新しい形式で項目を読み取る準備が整います。
**をバージョン 2.x AWS SDK for Java に更新する**
DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 3.x では、[DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) が必要です。DynamoDB Enhanced Client は、以前のバージョンで使用されていた [DynamoDBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) を置き換えます。拡張クライアントを使用するには、 AWS SDK for Java 2.xを使用する必要があります。
[AWS SDK for Javaのバージョン 1.x から 2.x に移行](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html)する手順に従います。
必要な AWS SDK for Java 2.x モジュールの詳細については、「」を参照してください[前提条件](ddb-java.md#ddb-java-prerequisites)。
**従来のバージョンによって暗号化された項目を読み取るようにクライアントを設定する**
次の手順では、以下のコード例で示されているステップの概要を説明します。
1. キーリングを作成します。
キーリングと[暗号マテリアルマネージャー](concepts.md#crypt-materials-manager)は、DynamoDB 用の Java クライアント側の暗号化ライブラリの以前のバージョンで使用されていた暗号マテリアルプロバイダーを置き換えます。
**重要**
キーリングの作成時に指定するラッピングキーは、バージョン 2.x で暗号マテリアルプロバイダーで使用したのと同じラッピングキーである必要があります。
1. アノテーション付きクラスに基づいてテーブルスキーマを作成します。
このステップでは、新しい形式で項目の書き込みを開始するときに使用される属性アクションを定義します。
新しい DynamoDB Enhanced Client の使用に関するガイダンスについては、「AWS SDK for Java デベロッパーガイド」の「[`TableSchema` を生成する](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html)」を参照してください。
次の例では、新しい属性アクションのアノテーションを使用して、アノテーション付きクラスをバージョン 2.x から更新したことを前提としています。属性アクションにアノテーションを付ける方法のガイダンスについては、「[アノテーション付きデータクラスを使用する](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)」を参照してください。
**注記**
`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` 属性を指定する場合、パーティション属性とソート属性も である必要があります`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`。の定義に使用される注釈の例については`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`、「[SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)」を参照してください。
1. どの[属性を署名から除外](ddb-java-using.md#allowed-unauth)するかを定義します。
1. バージョン 2.x のモデル化されたクラスで設定された属性アクションの明示的なマッピングを設定します。
このステップでは、古い形式で項目を書き込むために使用される属性アクションを定義します。
1. DynamoDB 用の Java クライアント側の暗号化ライブラリのバージョン 2.x で使用した `DynamoDBEncryptor` を設定します。
1. 従来の動作を設定します。
1. `DynamoDbEncryptionInterceptor` を作成します。
1. 新しい AWS SDK DynamoDB クライアントを作成します。
1. `DynamoDBEnhancedClient` を作成し、モデル化されたクラスを含むテーブルを作成します。
DynamoDB Enhanced Client の詳細については、「[拡張クライアントを作成する](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)」を参照してください。
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### ステップ 2. 新しい形式で項目を書き込む
ステップ 1 からすべてのリーダーに変更をデプロイしたら、次のステップを実行して、新しい形式で項目を書き込むように AWS Database Encryption SDK クライアントを設定します。次の変更をデプロイした後、クライアントは引き続き古い形式で項目を読み取り、新しい形式で項目の書き込みと読み取りを開始します。
次の手順では、以下のコード例で示されているステップの概要を説明します。
1. [**ステップ 1**](#ddb-java-migrate-step1) と同様に、キーリング、テーブルスキーマ、従来の属性アクション、`allowedUnsignedAttributes`、および `DynamoDBEncryptor` の設定を続行します。
1. 新しい形式を使用して新しい項目のみを書き込むように、従来の動作を更新します。
1. `DynamoDbEncryptionInterceptor ` を作成する
1. 新しい AWS SDK DynamoDB クライアントを作成します。
1. `DynamoDBEnhancedClient` を作成し、モデル化されたクラスを含むテーブルを作成します。
DynamoDB Enhanced Client の詳細については、「[拡張クライアントを作成する](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)」を参照してください。
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
ステップ 2 の変更をデプロイした後、[ステップ 3](#ddb-java-migrate-step3) に進む前に、テーブル内のすべての古い項目を新しい形式で再暗号化する必要があります。既存の項目を迅速に暗号化するために実行できる単一のメトリクスやクエリはありません。システムにとって最も合理的なプロセスを使用してください。例えば、定義した新しい属性アクションと暗号化設定を使用して、時間をかけてテーブルをスキャンし、項目を書き換える非同期プロセスを使用できます。
### ステップ 3. 新しい形式でのみ項目を読み書きする
テーブル内のすべての項目を新しい形式で再暗号化した後、設定から従来の動作を削除できます。新しい形式でのみ項目を読み書きするようにクライアントを設定するには、次のステップを実行します。
次の手順では、以下のコード例で示されているステップの概要を説明します。
1. [**ステップ 1**](#ddb-java-migrate-step1) と同様に、キーリング、テーブルスキーマ、`allowedUnsignedAttributes` の設定を続行します。従来の属性アクションと `DynamoDBEncryptor` を設定から削除します。
1. `DynamoDbEncryptionInterceptor` を作成します。
1. 新しい AWS SDK DynamoDB クライアントを作成します。
1. `DynamoDBEnhancedClient` を作成し、モデル化されたクラスを含むテーブルを作成します。
DynamoDB Enhanced Client の詳細については、「[拡張クライアントを作成する](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)」を参照してください。
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```