Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Java
****
| |
| --- |
| Pustaka enkripsi sisi klien kami diubah namanya menjadi SDK Enkripsi AWS Database. Panduan pengembang ini masih memberikan informasi tentang Klien Enkripsi [DynamoDB](legacy-dynamodb-encryption-client.md). |
Topik ini menjelaskan cara menginstal dan menggunakan versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB. Untuk detail tentang pemrograman dengan AWS Database Encryption SDK untuk DynamoDB, lihat contoh [Java di aws-database-encryption-sdk repositori -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aktif. GitHub
**catatan**
Topik berikut fokus pada versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB.
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). AWS Database Encryption SDK terus mendukung versi Klien Enkripsi [DynamoDB lama](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Prasyarat](#ddb-java-prerequisites)
+ [Penginstalan](#ddb-java-installation)
+ [Menggunakan klien Java](ddb-java-using.md)
+ [Contoh Java](ddb-java-examples.md)
+ [Tambahkan versi 3.x ke tabel yang ada](ddb-java-config-existing-table.md)
+ [Migrasi ke versi 3.x](ddb-java-migrate.md)
## Prasyarat
Sebelum Anda menginstal versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB, pastikan Anda memiliki prasyarat berikut.
**Lingkungan pengembangan Java**
Anda akan membutuhkan Java 8 atau yang lebih baru. Di situs web Oracle, buka [Unduhan Java SE](https://www.oracle.com/java/technologies/downloads/), kemudian unduh dan instal Java SE Development Kit (JDK).
Jika Anda menggunakan Oracle JDK, Anda juga harus mengunduh dan menginstal [File Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
SDK Enkripsi AWS Database untuk DynamoDB memerlukan modul DynamoDB [Enhanced Client dari modul](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). AWS SDK for Java 2.x Anda dapat menginstal seluruh SDK atau modul ini saja.
Untuk informasi tentang memperbarui versi Anda AWS SDK untuk Java, lihat [Memigrasi dari versi 1.x ke 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK untuk Java
Tersedia melalui Apache Maven. AWS SDK untuk Java Anda dapat mendeklarasikan ketergantungan untuk keseluruhan AWS SDK untuk Java, atau hanya modul. `dynamodb-enhanced`
**Instal AWS SDK untuk Java menggunakan Apache Maven**
+ Untuk [mengimpor keseluruhan AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) sebagai dependensi, deklarasikan dalam file Anda. `pom.xml`
+ Untuk membuat dependensi hanya untuk modul Amazon DynamoDB AWS SDK untuk Java di, ikuti [petunjuk](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) untuk menentukan modul tertentu. Atur `groupId` ke `software.amazon.awssdk` dan `artifactID` ke`dynamodb-enhanced`.
**catatan**
Jika Anda menggunakan AWS KMS keyring atau keyring AWS KMS Hierarchical, Anda juga perlu membuat dependensi untuk modul. AWS KMS Atur `groupId` ke `software.amazon.awssdk` dan `artifactID` ke`kms`.
## Penginstalan
Anda dapat menginstal versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB dengan cara berikut.
**Menggunakan Apache Maven**
Amazon DynamoDB Encryption Client untuk Java tersedia melalui [Apache Maven](https://maven.apache.org/) dengan definisi dependensi berikut.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Menggunakan Gradle Kotlin**
*Anda dapat menggunakan [Gradle](https://gradle.org/) untuk mendeklarasikan dependensi pada Klien Enkripsi Amazon DynamoDB untuk Java dengan menambahkan yang berikut ini ke bagian dependensi proyek Gradle Anda.*
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Secara manual**
[Untuk menginstal pustaka enkripsi sisi klien Java untuk DynamoDB, kloning atau unduh repositori -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Setelah Anda menginstal SDK, mulailah dengan melihat kode contoh dalam panduan ini dan [contoh Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) di repositori aws-database-encryption-sdk -dynamodb aktif. GitHub
# Menggunakan pustaka enkripsi sisi klien Java untuk DynamoDB
****
| |
| --- |
| Pustaka enkripsi sisi klien kami diubah namanya menjadi SDK Enkripsi AWS Database. Panduan pengembang ini masih memberikan informasi tentang Klien Enkripsi [DynamoDB](legacy-dynamodb-encryption-client.md). |
Topik ini menjelaskan beberapa fungsi dan kelas pembantu di versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB.
Untuk detail tentang pemrograman dengan pustaka enkripsi sisi klien Java untuk DynamoDB, lihat contoh Java, [contoh Java](java-examples.md) di repositori -dynamodb [aktif](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples). aws-database-encryption-sdk GitHub
**Topics**
+ [Enkriptor item](#ddb-item-encryptors)
+ [Tindakan atribut](#ddb-attribute-actions)
+ [Konfigurasi enkripsi](#ddb-config-encrypt)
+ [Memperbarui item](#ddb-update-items)
+ [Mendekripsi set yang ditandatangani](#ddb-java-signed-sets)
## Enkriptor item
Pada intinya, AWS Database Encryption SDK untuk DynamoDB adalah enkripsi item. Anda dapat menggunakan versi 3. *x* pustaka enkripsi sisi klien Java untuk DynamoDB untuk mengenkripsi, menandatangani, memverifikasi, dan mendekripsi item tabel DynamoDB Anda dengan cara berikut.
**Klien yang Ditingkatkan DynamoDB**
Anda dapat mengkonfigurasi [DynamoDB Enhanced Client dengan untuk secara otomatis mengenkripsi dan menandatangani item sisi klien dengan `DynamoDbEncryptionInterceptor` permintaan DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Anda. `PutItem` Dengan DynamoDB Enhanced Client, Anda dapat menentukan tindakan atribut Anda menggunakan kelas data [beranotasi](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean). Sebaiknya gunakan DynamoDB Enhanced Client bila memungkinkan.
[DynamoDB Enhanced Client tidak mendukung enkripsi yang dapat dicari.](searchable-encryption.md)
SDK Enkripsi AWS Database tidak mendukung anotasi pada atribut [bersarang](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
**API DynamoDB tingkat rendah**
Anda dapat mengonfigurasi API [DynamoDB tingkat rendah dengan untuk secara otomatis mengenkripsi dan menandatangani item `DynamoDbEncryptionInterceptor` sisi klien dengan permintaan DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) Anda. `PutItem`
[Anda harus menggunakan API DynamoDB tingkat rendah untuk menggunakan enkripsi yang dapat dicari.](searchable-encryption.md)
**Tingkat yang lebih rendah `DynamoDbItemEncryptor`**
Tingkat yang lebih rendah `DynamoDbItemEncryptor` secara langsung mengenkripsi dan menandatangani atau mendekripsi dan memverifikasi item tabel Anda tanpa memanggil DynamoDB. Itu tidak membuat DynamoDB atau `PutItem` permintaan`GetItem`. Misalnya, Anda dapat menggunakan level yang lebih rendah `DynamoDbItemEncryptor` untuk langsung mendekripsi dan memverifikasi item DynamoDB yang telah Anda ambil.
Tingkat yang lebih rendah `DynamoDbItemEncryptor` tidak mendukung enkripsi yang dapat [dicari](searchable-encryption.md).
## Tindakan atribut dalam SDK Enkripsi AWS Database untuk DynamoDB
[Tindakan atribut](concepts.md#crypt-actions) menentukan nilai atribut mana yang dienkripsi dan ditandatangani, yang hanya ditandatangani, yang ditandatangani dan disertakan dalam konteks enkripsi, dan mana yang diabaikan.
**catatan**
Untuk menggunakan tindakan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kriptografi, Anda harus menggunakan SDK Enkripsi AWS Database versi 3.3 atau yang lebih baru. Terapkan versi baru ke semua pembaca sebelum [memperbarui model data Anda](ddb-update-data-model.md) untuk disertakan`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Jika Anda menggunakan API DynamoDB tingkat rendah atau level yang `DynamoDbItemEncryptor` lebih rendah, Anda harus menentukan tindakan atribut secara manual. [Jika Anda menggunakan DynamoDB Enhanced Client, Anda dapat menentukan tindakan atribut secara manual, atau Anda dapat menggunakan kelas data beranotasi untuk menghasilkan. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Untuk menyederhanakan proses konfigurasi, kami sarankan menggunakan kelas data beranotasi. Bila Anda menggunakan kelas data beranotasi, Anda hanya perlu memodelkan objek Anda sekali.
**catatan**
Setelah menentukan tindakan atribut, Anda harus menentukan atribut mana yang dikecualikan dari tanda tangan. Untuk mempermudah menambahkan atribut unsigned baru di masa mendatang, sebaiknya pilih awalan yang berbeda (seperti "`:`“) untuk mengidentifikasi atribut unsigned Anda. Sertakan awalan ini dalam nama atribut untuk semua atribut yang ditandai `DO_NOTHING` saat Anda menentukan skema DynamoDB dan tindakan atribut.
### Gunakan kelas data beranotasi
Gunakan [kelas data beranotasi](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) untuk menentukan tindakan atribut Anda dengan DynamoDB Enhanced Client dan. `DynamoDbEncryptionInterceptor` SDK Enkripsi AWS Database untuk DynamoDB menggunakan anotasi [atribut DynamoDB standar yang menentukan jenis atribut](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) untuk menentukan cara melindungi atribut. Secara default, semua atribut dienkripsi dan ditandatangani kecuali kunci utama, yang ditandatangani tetapi tidak dienkripsi.
**catatan**
Untuk menggunakan tindakan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kriptografi, Anda harus menggunakan SDK Enkripsi AWS Database versi 3.3 atau yang lebih baru. Terapkan versi baru ke semua pembaca sebelum [memperbarui model data Anda](ddb-update-data-model.md) untuk disertakan`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Lihat [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) di repositori aws-database-encryption-sdk -dynamodb untuk panduan GitHub lebih lanjut tentang anotasi DynamoDB Enhanced Client.
Secara default, atribut kunci primer ditandatangani tetapi tidak dienkripsi (`SIGN_ONLY`) dan semua atribut lainnya dienkripsi dan ditandatangani (). `ENCRYPT_AND_SIGN` Jika Anda mendefinisikan atribut apa pun sebagai`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, maka atribut partisi dan sortir juga harus`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Untuk menentukan pengecualian, gunakan anotasi enkripsi yang ditentukan dalam pustaka enkripsi sisi klien Java untuk DynamoDB. Misalnya, jika Anda ingin atribut tertentu hanya ditandatangani, gunakan `@DynamoDbEncryptionSignOnly` anotasi. Jika Anda ingin atribut tertentu ditandatangani dan disertakan dalam konteks enkripsi, gunakan`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Jika Anda ingin atribut tertentu tidak ditandatangani atau dienkripsi (`DO_NOTHING`), gunakan anotasi`@DynamoDbEncryptionDoNothing`.
**catatan**
SDK Enkripsi AWS Database tidak mendukung anotasi pada atribut [bersarang](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
Contoh berikut menunjukkan anotasi yang digunakan untuk mendefinisikan`ENCRYPT_AND_SIGN`,`SIGN_ONLY`, dan `DO_NOTHING` atribut tindakan. Untuk contoh yang menunjukkan anotasi yang digunakan untuk mendefinisikan`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, lihat [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;
}
}
```
Gunakan kelas data beranotasi Anda untuk membuat `TableSchema` seperti yang ditunjukkan dalam cuplikan berikut.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Tentukan tindakan atribut Anda secara manual
Untuk menentukan tindakan atribut secara manual, buat `Map` objek di mana pasangan nama-nilai mewakili nama atribut dan tindakan yang ditentukan.
Tentukan `ENCRYPT_AND_SIGN` untuk mengenkripsi dan menandatangani atribut. Tentukan `SIGN_ONLY` untuk menandatangani, tetapi tidak mengenkripsi, atribut. Tentukan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` untuk menandatangani atribut dan sertakan dalam konteks enkripsi. Anda tidak dapat mengenkripsi atribut tanpa menandatanganinya juga. Tentukan `DO_NOTHING` untuk mengabaikan atribut.
Partisi dan atribut sortir harus salah satu `SIGN_ONLY` atau`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Jika Anda mendefinisikan atribut apa pun sebagai`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, maka atribut partisi dan sortir juga harus`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**catatan**
Untuk menggunakan tindakan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kriptografi, Anda harus menggunakan SDK Enkripsi AWS Database versi 3.3 atau yang lebih baru. Terapkan versi baru ke semua pembaca sebelum [memperbarui model data Anda](ddb-update-data-model.md) untuk disertakan`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);
```
## Konfigurasi enkripsi dalam SDK Enkripsi AWS Database untuk DynamoDB
Bila Anda menggunakan AWS Database Encryption SDK, Anda harus secara eksplisit menentukan konfigurasi enkripsi untuk tabel DynamoDB Anda. Nilai yang diperlukan dalam konfigurasi enkripsi Anda bergantung pada apakah Anda mendefinisikan tindakan atribut secara manual atau dengan kelas data beranotasi.
Cuplikan berikut mendefinisikan konfigurasi enkripsi tabel DynamoDB menggunakan 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)dan mengizinkan atribut unsigned yang ditentukan oleh awalan yang berbeda.
```
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());
```
**Nama tabel logis**
Sebuah nama tabel logis untuk tabel DynamoDB Anda.
Nama tabel logis terikat secara kriptografis ke semua data yang disimpan dalam tabel untuk menyederhanakan operasi pemulihan DynamoDB. Kami sangat menyarankan untuk menentukan nama tabel DynamoDB Anda sebagai nama tabel logis saat Anda pertama kali menentukan konfigurasi enkripsi Anda. Anda harus selalu menentukan nama tabel logis yang sama. Agar dekripsi berhasil, nama tabel logis harus sesuai dengan nama yang ditentukan pada enkripsi. Jika nama tabel DynamoDB Anda berubah setelah [memulihkan tabel DynamoDB Anda dari cadangan, nama tabel](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) logis memastikan bahwa operasi dekripsi masih mengenali tabel.
**Atribut yang tidak ditandatangani yang diizinkan**
Atribut yang ditandai `DO_NOTHING` dalam tindakan atribut Anda.
Atribut unsigned yang diizinkan memberi tahu klien atribut mana yang dikecualikan dari tanda tangan. Klien mengasumsikan bahwa semua atribut lainnya termasuk dalam tanda tangan. Kemudian, saat mendekripsi catatan, klien menentukan atribut mana yang perlu diverifikasi dan mana yang harus diabaikan dari atribut unsigned yang diizinkan yang Anda tentukan. Anda tidak dapat menghapus atribut dari atribut yang tidak ditandatangani yang diizinkan.
Anda dapat menentukan atribut unsigned yang diizinkan secara eksplisit dengan membuat array yang mencantumkan semua atribut Anda. `DO_NOTHING` Anda juga dapat menentukan awalan yang berbeda saat menamai `DO_NOTHING` atribut Anda dan menggunakan awalan untuk memberi tahu klien atribut mana yang tidak ditandatangani. Kami sangat menyarankan untuk menentukan awalan yang berbeda karena menyederhanakan proses penambahan `DO_NOTHING` atribut baru di masa depan. Untuk informasi selengkapnya, lihat [Memperbarui model data Anda](ddb-update-data-model.md).
Jika Anda tidak menentukan awalan untuk semua `DO_NOTHING` atribut, Anda dapat mengonfigurasi `allowedUnsignedAttributes` array yang secara eksplisit mencantumkan semua atribut yang diharapkan klien tidak ditandatangani saat bertemu dengan mereka pada dekripsi. Anda hanya harus secara eksplisit mendefinisikan atribut unsigned yang diizinkan jika benar-benar diperlukan.
**Konfigurasi Pencarian (Opsional)**
`SearchConfig`Mendefinisikan versi [beacon](using-beacons.md#beacon-version).
`SearchConfig`Harus ditentukan untuk menggunakan [enkripsi yang dapat dicari](searchable-encryption.md) atau suar yang [ditandatangani](configure.md#signed-beacons).
**Suite Algoritma (Opsional)**
`algorithmSuiteId`Mendefinisikan algoritma mana yang sesuai dengan AWS Database Encryption SDK yang digunakan.
Kecuali Anda secara eksplisit menentukan rangkaian algoritme alternatif, SDK Enkripsi AWS Database menggunakan rangkaian algoritme [default](supported-algorithms.md#recommended-algorithms). [Rangkaian algoritma default menggunakan algoritma AES-GCM dengan derivasi kunci, [tanda tangan digital](concepts.md#digital-sigs), dan komitmen kunci.](concepts.md#key-commitment) Meskipun rangkaian algoritme default kemungkinan cocok untuk sebagian besar aplikasi, Anda dapat memilih rangkaian algoritma alternatif. Misalnya, beberapa model kepercayaan akan dipenuhi oleh rangkaian algoritma tanpa tanda tangan digital. Untuk informasi tentang rangkaian algoritme yang didukung SDK Enkripsi AWS Database, lihat[Rangkaian algoritme yang didukung di SDK Enkripsi AWS Database](supported-algorithms.md).
Untuk memilih [rangkaian algoritma AES-GCM tanpa tanda tangan digital ECDSA](supported-algorithms.md#other-algorithms), sertakan cuplikan berikut dalam konfigurasi enkripsi tabel Anda.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Memperbarui item dengan AWS Database Encryption SDK
SDK Enkripsi AWS Database tidak mendukung [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) untuk item yang telah dienkripsi atau ditandatangani. Untuk memperbarui item terenkripsi atau ditandatangani, Anda harus menggunakan [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Saat Anda menentukan kunci utama yang sama dengan item yang ada dalam `PutItem` permintaan Anda, item baru sepenuhnya menggantikan item yang ada. Anda juga dapat menggunakan [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) untuk menghapus dan mengganti semua atribut yang disimpan setelah memperbarui item Anda.
## Mendekripsi set yang ditandatangani
Di SDK Enkripsi AWS Database versi 3.0.0 dan 3.1.0, jika Anda menentukan atribut [tipe set](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) sebagai`SIGN_ONLY`, nilai himpunan akan dikanonikalisasi dalam urutan yang disediakan. DynamoDB tidak mempertahankan urutan set. Akibatnya, ada kemungkinan validasi tanda tangan dari item yang berisi set akan gagal. Validasi tanda tangan gagal ketika nilai set dikembalikan dalam urutan yang berbeda dari yang diberikan ke SDK Enkripsi AWS Database, meskipun atribut set berisi nilai yang sama.
**catatan**
Versi 3.1.1 dan yang lebih baru dari AWS Database Encryption SDK mengkanonikalisasikan nilai semua atribut tipe set, sehingga nilai dibaca dalam urutan yang sama dengan yang ditulis ke DynamoDB.
Jika validasi tanda tangan gagal, operasi dekripsi gagal dan mengembalikan pesan kesalahan berikut.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Tidak ada tag penerima yang cocok. |
Jika Anda menerima pesan kesalahan di atas, dan yakin bahwa item yang Anda coba dekripsi menyertakan set yang ditandatangani menggunakan versi 3.0.0 atau 3.1.0, lihat [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)direktori repositori aws-database-encryption-sdk -dynamodb-java untuk detail tentang cara berhasil memvalidasi set. GitHub
# Contoh Java
****
| |
| --- |
| Pustaka enkripsi sisi klien kami diubah namanya menjadi SDK Enkripsi AWS Database. Panduan pengembang ini masih memberikan informasi tentang Klien Enkripsi [DynamoDB](legacy-dynamodb-encryption-client.md). |
Contoh berikut menunjukkan cara menggunakan pustaka enkripsi sisi klien Java untuk DynamoDB untuk melindungi item tabel dalam aplikasi Anda. Anda dapat menemukan lebih banyak contoh (dan berkontribusi sendiri) di [contoh Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) di repositori aws-database-encryption-sdk -dynamodb di. GitHub
Contoh berikut menunjukkan cara mengonfigurasi pustaka enkripsi sisi klien Java untuk DynamoDB dalam tabel Amazon DynamoDB baru yang tidak terisi. Jika Anda ingin mengonfigurasi tabel Amazon DynamoDB yang ada untuk enkripsi sisi klien, lihat. [Tambahkan versi 3.x ke tabel yang ada](ddb-java-config-existing-table.md)
**Topics**
+ [Menggunakan klien yang disempurnakan DynamoDB](#ddb-java-enhanced-client-example)
+ [Menggunakan API DynamoDB tingkat rendah](#ddb-java-lowlevel-API-example)
+ [Menggunakan level yang lebih rendah DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Menggunakan klien yang disempurnakan DynamoDB
Contoh berikut menunjukkan cara menggunakan DynamoDB Enhanced Client `DynamoDbEncryptionInterceptor` dan dengan keyring untuk mengenkripsi item tabel DynamoDB [AWS KMS sebagai](use-kms-keyring.md) bagian dari panggilan API DynamoDB Anda.
Anda dapat menggunakan [keyring](keyrings.md) apa pun yang didukung dengan DynamoDB Enhanced Client, tetapi sebaiknya gunakan salah AWS KMS satu gantungan kunci bila memungkinkan.
**catatan**
[DynamoDB Enhanced Client tidak mendukung enkripsi yang dapat dicari.](searchable-encryption.md) Gunakan `DynamoDbEncryptionInterceptor` dengan API DynamoDB tingkat rendah untuk menggunakan enkripsi yang dapat dicari.
**Lihat contoh kode lengkapnya**: [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)
**Langkah 1: Buat AWS KMS keyring**
Contoh berikut digunakan `CreateAwsKmsMrkMultiKeyring` untuk membuat AWS KMS keyring dengan kunci KMS enkripsi simetris. `CreateAwsKmsMrkMultiKeyring`Metode ini memastikan bahwa keyring akan menangani tombol Single-region dan Multi-region dengan benar.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Langkah 2: Buat skema tabel dari kelas data beranotasi**
Contoh berikut menggunakan kelas data beranotasi untuk membuat. `TableSchema`
[Contoh ini mengasumsikan bahwa kelas data beranotasi dan tindakan atribut didefinisikan menggunakan .java. SimpleClass](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) Untuk panduan selengkapnya tentang menganotasi tindakan atribut Anda, lihat. [Gunakan kelas data beranotasi](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
SDK Enkripsi AWS Database tidak mendukung anotasi pada atribut [bersarang](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);
```
**Langkah 3: Tentukan atribut mana yang dikecualikan dari tanda tangan**
Contoh berikut mengasumsikan bahwa semua `DO_NOTHING` atribut berbagi awalan yang berbeda "`:`“, dan menggunakan awalan untuk menentukan atribut unsigned yang diizinkan. Klien mengasumsikan bahwa nama atribut apa pun dengan awalan "`:`" dikecualikan dari tanda tangan. Untuk informasi selengkapnya, lihat [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Langkah 4: Buat konfigurasi enkripsi**
Contoh berikut mendefinisikan `tableConfigs` Peta yang mewakili konfigurasi enkripsi untuk tabel DynamoDB.
[Contoh ini menentukan nama tabel DynamoDB sebagai nama tabel logis.](ddb-java-using.md#logical-table-name) Kami sangat menyarankan untuk menentukan nama tabel DynamoDB Anda sebagai nama tabel logis saat Anda pertama kali menentukan konfigurasi enkripsi Anda. Untuk informasi selengkapnya, lihat [Konfigurasi enkripsi dalam SDK Enkripsi AWS Database untuk DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Untuk menggunakan [enkripsi yang dapat dicari](searchable-encryption.md) atau [suar yang ditandatangani](configure.md#signed-beacons), Anda juga harus menyertakan [`SearchConfig`](ddb-java-using.md#ddb-search-config)dalam konfigurasi enkripsi Anda.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Langkah 5: Menciptakan `DynamoDbEncryptionInterceptor`**
Contoh berikut membuat yang baru `DynamoDbEncryptionInterceptor` dengan `tableConfigs` dari **Langkah 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Langkah 6: Buat klien AWS SDK DynamoDB baru**
**Contoh berikut membuat klien AWS SDK DynamoDB baru menggunakan `interceptor` dari Langkah 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Langkah 7: Buat DynamoDB Enhanced Client dan buat tabel**
Contoh berikut membuat DynamoDB Enhanced Client menggunakan klien AWS SDK DynamoDB yang dibuat **pada Langkah** 6 dan membuat tabel menggunakan class data beranotasi.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Langkah 8: Enkripsi dan tandatangani item tabel**
Contoh berikut menempatkan item ke dalam tabel DynamoDB menggunakan DynamoDB Enhanced Client. Item dienkripsi dan ditandatangani sisi klien sebelum dikirim ke 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);
```
## Menggunakan API DynamoDB tingkat rendah
[Contoh berikut menunjukkan cara menggunakan API DynamoDB tingkat rendah dengan keyring untuk secara otomatis mengenkripsi dan menandatangani item sisi klien dengan AWS KMS permintaan DynamoDB Anda.](use-kms-keyring.md) `PutItem`
Anda dapat menggunakan [keyring](keyrings.md) apa pun yang didukung, tetapi kami sarankan menggunakan salah satu AWS KMS gantungan kunci jika memungkinkan.
**Lihat contoh kode lengkapnya**: [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)
**Langkah 1: Buat AWS KMS keyring**
Contoh berikut digunakan `CreateAwsKmsMrkMultiKeyring` untuk membuat AWS KMS keyring dengan kunci KMS enkripsi simetris. `CreateAwsKmsMrkMultiKeyring`Metode ini memastikan bahwa keyring akan menangani tombol Single-region dan Multi-region dengan benar.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Langkah 2: Konfigurasikan tindakan atribut Anda**
Contoh berikut mendefinisikan `attributeActionsOnEncrypt` Peta yang mewakili [tindakan atribut](concepts.md#crypt-actions) sampel untuk item tabel.
Contoh berikut tidak mendefinisikan atribut apa pun sebagai`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Jika Anda menentukan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atribut apa pun, maka atribut partisi dan sortir juga harus`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);
```
**Langkah 3: Tentukan atribut mana yang dikecualikan dari tanda tangan**
Contoh berikut mengasumsikan bahwa semua `DO_NOTHING` atribut berbagi awalan yang berbeda "`:`“, dan menggunakan awalan untuk menentukan atribut unsigned yang diizinkan. Klien mengasumsikan bahwa nama atribut apa pun dengan awalan "`:`" dikecualikan dari tanda tangan. Untuk informasi selengkapnya, lihat [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Langkah 4: Tentukan konfigurasi enkripsi tabel DynamoDB**
Contoh berikut mendefinisikan `tableConfigs` Peta yang mewakili konfigurasi enkripsi untuk tabel DynamoDB ini.
[Contoh ini menentukan nama tabel DynamoDB sebagai nama tabel logis.](ddb-java-using.md#logical-table-name) Kami sangat menyarankan untuk menentukan nama tabel DynamoDB Anda sebagai nama tabel logis saat Anda pertama kali menentukan konfigurasi enkripsi Anda. Untuk informasi selengkapnya, lihat [Konfigurasi enkripsi dalam SDK Enkripsi AWS Database untuk DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Untuk menggunakan [enkripsi yang dapat dicari](searchable-encryption.md) atau [suar yang ditandatangani](configure.md#signed-beacons), Anda juga harus menyertakan [`SearchConfig`](ddb-java-using.md#ddb-search-config)dalam konfigurasi enkripsi Anda.
```
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);
```
**Langkah 5: Buat `DynamoDbEncryptionInterceptor`**
Contoh berikut menciptakan `DynamoDbEncryptionInterceptor` menggunakan `tableConfigs` dari **Langkah 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Langkah 6: Buat klien AWS SDK DynamoDB baru**
**Contoh berikut membuat klien AWS SDK DynamoDB baru menggunakan `interceptor` dari Langkah 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Langkah 7: Enkripsi dan tandatangani item tabel DynamoDB**
Contoh berikut mendefinisikan `item` Peta yang mewakili item tabel sampel dan menempatkan item dalam tabel DynamoDB. Item dienkripsi dan ditandatangani sisi klien sebelum dikirim ke 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);
```
## Menggunakan level yang lebih rendah DynamoDbItemEncryptor
Contoh berikut menunjukkan cara menggunakan level yang lebih rendah `DynamoDbItemEncryptor` dengan [AWS KMS keyring](use-kms-keyring.md) untuk langsung mengenkripsi dan menandatangani item tabel. `DynamoDbItemEncryptor`Itu tidak menempatkan item di tabel DynamoDB Anda.
Anda dapat menggunakan [keyring](keyrings.md) apa pun yang didukung dengan DynamoDB Enhanced Client, tetapi sebaiknya gunakan salah AWS KMS satu gantungan kunci bila memungkinkan.
**catatan**
Tingkat yang lebih rendah `DynamoDbItemEncryptor` tidak mendukung enkripsi yang dapat [dicari](searchable-encryption.md). Gunakan `DynamoDbEncryptionInterceptor` dengan API DynamoDB tingkat rendah untuk menggunakan enkripsi yang dapat dicari.
**Lihat contoh kode lengkapnya**: [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)
**Langkah 1: Buat AWS KMS keyring**
Contoh berikut digunakan `CreateAwsKmsMrkMultiKeyring` untuk membuat AWS KMS keyring dengan kunci KMS enkripsi simetris. `CreateAwsKmsMrkMultiKeyring`Metode ini memastikan bahwa keyring akan menangani tombol Single-region dan Multi-region dengan benar.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Langkah 2: Konfigurasikan tindakan atribut Anda**
Contoh berikut mendefinisikan `attributeActionsOnEncrypt` Peta yang mewakili [tindakan atribut](concepts.md#crypt-actions) sampel untuk item tabel.
Contoh berikut tidak mendefinisikan atribut apa pun sebagai`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Jika Anda menentukan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atribut apa pun, maka atribut partisi dan sortir juga harus`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);
```
**Langkah 3: Tentukan atribut mana yang dikecualikan dari tanda tangan**
Contoh berikut mengasumsikan bahwa semua `DO_NOTHING` atribut berbagi awalan yang berbeda "`:`“, dan menggunakan awalan untuk menentukan atribut unsigned yang diizinkan. Klien mengasumsikan bahwa nama atribut apa pun dengan awalan "`:`" dikecualikan dari tanda tangan. Untuk informasi selengkapnya, lihat [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Langkah 4: Tentukan `DynamoDbItemEncryptor` konfigurasi**
Contoh berikut mendefinisikan konfigurasi untuk. `DynamoDbItemEncryptor`
[Contoh ini menentukan nama tabel DynamoDB sebagai nama tabel logis.](ddb-java-using.md#logical-table-name) Kami sangat menyarankan untuk menentukan nama tabel DynamoDB Anda sebagai nama tabel logis saat Anda pertama kali menentukan konfigurasi enkripsi Anda. Untuk informasi selengkapnya, lihat [Konfigurasi enkripsi dalam SDK Enkripsi AWS Database untuk 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();
```
**Langkah 5: Buat `DynamoDbItemEncryptor`**
Contoh berikut membuat baru `DynamoDbItemEncryptor` menggunakan `config` dari **Langkah 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Langkah 6: Langsung mengenkripsi dan menandatangani item tabel**
Contoh berikut langsung mengenkripsi dan menandatangani item menggunakan. `DynamoDbItemEncryptor` `DynamoDbItemEncryptor`Itu tidak menempatkan item di tabel DynamoDB Anda.
```
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();
```
# Konfigurasikan tabel DynamoDB yang ada untuk menggunakan SDK Enkripsi Database untuk AWS DynamoDB
****
| |
| --- |
| Pustaka enkripsi sisi klien kami diubah namanya menjadi SDK Enkripsi AWS Database. Panduan pengembang ini masih memberikan informasi tentang Klien Enkripsi [DynamoDB](legacy-dynamodb-encryption-client.md). |
Dengan versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB, Anda dapat mengonfigurasi tabel Amazon DynamoDB yang ada untuk enkripsi sisi klien. Topik ini memberikan panduan tentang tiga langkah yang harus Anda ambil untuk menambahkan versi 3. *x* ke tabel DynamoDB yang sudah ada dan terisi.
**Prasyarat**
Versi 3. *x* [dari pustaka enkripsi sisi klien Java untuk DynamoDB memerlukan DynamoDB Enhanced Client yang disediakan di.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.x Jika Anda masih menggunakan [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), Anda harus bermigrasi ke untuk menggunakan DynamoDB AWS SDK for Java 2.x Enhanced Client.
Ikuti petunjuk untuk [bermigrasi dari versi 1.x ke 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) dari file. AWS SDK untuk Java
Kemudian, ikuti petunjuk untuk [Memulai menggunakan DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html) API.
[Sebelum mengkonfigurasi tabel Anda untuk menggunakan pustaka enkripsi sisi klien Java untuk DynamoDB, Anda perlu membuat `TableSchema`[menggunakan kelas data beranotasi dan membuat klien yang disempurnakan](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean).](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)
## Langkah 1: Bersiaplah untuk membaca dan menulis item terenkripsi
Selesaikan langkah-langkah berikut untuk mempersiapkan klien SDK Enkripsi AWS Database Anda untuk membaca dan menulis item terenkripsi. Setelah Anda menerapkan perubahan berikut, klien Anda akan terus membaca dan menulis item teks biasa. Ini tidak akan mengenkripsi atau menandatangani item baru yang ditulis ke tabel, tetapi akan dapat mendekripsi item terenkripsi segera setelah muncul. Perubahan ini mempersiapkan klien untuk mulai [mengenkripsi item baru](#ddb-java-add-step2). Perubahan berikut harus diterapkan ke setiap pembaca sebelum Anda melanjutkan ke langkah berikutnya.
**1. Tentukan [tindakan atribut](concepts.md#crypt-actions) Anda**
Perbarui kelas data beranotasi Anda untuk menyertakan tindakan atribut yang menentukan nilai atribut mana yang akan dienkripsi dan ditandatangani, yang hanya akan ditandatangani, dan mana yang akan diabaikan.
Lihat [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) di repositori aws-database-encryption-sdk -dynamodb untuk panduan GitHub lebih lanjut tentang anotasi DynamoDB Enhanced Client.
Secara default, atribut kunci primer ditandatangani tetapi tidak dienkripsi (`SIGN_ONLY`) dan semua atribut lainnya dienkripsi dan ditandatangani (). `ENCRYPT_AND_SIGN` Untuk menentukan pengecualian, gunakan anotasi enkripsi yang ditentukan dalam pustaka enkripsi sisi klien Java untuk DynamoDB. Misalnya, jika Anda ingin atribut tertentu ditandatangani hanya gunakan `@DynamoDbEncryptionSignOnly` anotasi. Jika Anda ingin atribut tertentu ditandatangani dan disertakan dalam konteks enkripsi, gunakan `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` anotasi. Jika Anda ingin atribut tertentu tidak ditandatangani atau dienkripsi (`DO_NOTHING`), gunakan anotasi`@DynamoDbEncryptionDoNothing`.
Jika Anda menentukan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atribut apa pun, maka atribut partisi dan sortir juga harus`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Untuk contoh yang menunjukkan anotasi yang digunakan untuk mendefinisikan`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, lihat [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).
Misalnya anotasi, lihat[Gunakan kelas data beranotasi](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**2. Tentukan atribut mana yang akan dikecualikan dari tanda tangan**
Contoh berikut mengasumsikan bahwa semua `DO_NOTHING` atribut berbagi awalan yang berbeda "`:`“, dan menggunakan awalan untuk menentukan atribut unsigned yang diizinkan. Klien akan menganggap bahwa nama atribut apa pun dengan awalan `:` "" dikecualikan dari tanda tangan. Untuk informasi selengkapnya, lihat [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Buat [keyring](keyrings.md)**
Contoh berikut membuat [AWS KMS keyring](use-kms-keyring.md). AWS KMS Keyring menggunakan enkripsi simetris atau RSA asimetris AWS KMS keys untuk menghasilkan, mengenkripsi, dan mendekripsi kunci data.
Contoh ini digunakan `CreateMrkMultiKeyring` untuk membuat AWS KMS keyring dengan kunci KMS enkripsi simetris. `CreateAwsKmsMrkMultiKeyring`Metode ini memastikan bahwa keyring akan menangani tombol Single-region dan Multi-region dengan benar.
```
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. Tentukan konfigurasi enkripsi tabel DynamoDB **
Contoh berikut mendefinisikan `tableConfigs` Peta yang mewakili konfigurasi enkripsi untuk tabel DynamoDB ini.
[Contoh ini menentukan nama tabel DynamoDB sebagai nama tabel logis.](ddb-java-using.md#logical-table-name) Kami sangat menyarankan untuk menentukan nama tabel DynamoDB Anda sebagai nama tabel logis saat Anda pertama kali menentukan konfigurasi enkripsi Anda. Untuk informasi selengkapnya, lihat [Konfigurasi enkripsi dalam SDK Enkripsi AWS Database untuk DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Anda harus menentukan `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` sebagai plaintext override. Kebijakan ini terus membaca dan menulis item teks biasa, membaca item terenkripsi, dan mempersiapkan klien untuk menulis item terenkripsi.
```
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. Buat `DynamoDbEncryptionInterceptor`**
Contoh berikut menciptakan `DynamoDbEncryptionInterceptor` menggunakan `tableConfigs` dari **Langkah 3**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Langkah 2: Tulis item terenkripsi dan ditandatangani
Perbarui kebijakan plaintext dalam `DynamoDbEncryptionInterceptor` konfigurasi Anda untuk memungkinkan klien menulis item terenkripsi dan ditandatangani. Setelah Anda menerapkan perubahan berikut, klien akan mengenkripsi dan menandatangani item baru berdasarkan tindakan atribut yang Anda konfigurasikan di **Langkah** 1. Klien akan dapat membaca item teks biasa dan item terenkripsi dan ditandatangani.
Sebelum Anda melanjutkan ke [Langkah 3](#ddb-java-add-step3), Anda harus mengenkripsi dan menandatangani semua item plaintext yang ada di tabel Anda. Tidak ada metrik atau kueri tunggal yang dapat Anda jalankan untuk mengenkripsi item plaintext yang ada dengan cepat. Gunakan proses yang paling masuk akal untuk sistem Anda. Misalnya, Anda dapat menggunakan proses asinkron yang memindai tabel secara perlahan dan menulis ulang item menggunakan tindakan atribut dan konfigurasi enkripsi yang Anda tentukan. Untuk mengidentifikasi item plaintext dalam tabel Anda, kami sarankan memindai semua item yang tidak berisi `aws_dbe_head` dan `aws_dbe_foot` atribut yang ditambahkan SDK Enkripsi AWS Database ke item saat dienkripsi dan ditandatangani.
Contoh berikut memperbarui konfigurasi enkripsi tabel dari **Langkah 1**. Anda harus memperbarui penggantian plaintext dengan. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Kebijakan ini terus membaca item teks biasa, tetapi juga membaca dan menulis item terenkripsi. Buat yang baru `DynamoDbEncryptionInterceptor` menggunakan yang diperbarui`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);
```
## Langkah 3: Hanya baca item terenkripsi dan ditandatangani
Setelah Anda mengenkripsi dan menandatangani semua item Anda, perbarui penggantian plaintext dalam `DynamoDbEncryptionInterceptor` konfigurasi Anda untuk hanya mengizinkan klien membaca dan menulis item terenkripsi dan ditandatangani. Setelah Anda menerapkan perubahan berikut, klien akan mengenkripsi dan menandatangani item baru berdasarkan tindakan atribut yang Anda konfigurasikan di **Langkah** 1. Klien hanya akan dapat membaca item terenkripsi dan ditandatangani.
Contoh berikut memperbarui konfigurasi enkripsi tabel dari **Langkah 2**. Anda dapat memperbarui penggantian plaintext dengan `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` atau menghapus kebijakan plaintext dari konfigurasi Anda. Klien hanya membaca dan menulis item terenkripsi dan ditandatangani secara default. Buat yang baru `DynamoDbEncryptionInterceptor` menggunakan yang diperbarui`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);
```
# Migrasi ke versi 3.x pustaka enkripsi sisi klien Java untuk DynamoDB
****
| |
| --- |
| Pustaka enkripsi sisi klien kami diubah namanya menjadi SDK Enkripsi AWS Database. Panduan pengembang ini masih memberikan informasi tentang Klien Enkripsi [DynamoDB](legacy-dynamodb-encryption-client.md). |
Versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB adalah penulisan ulang utama dari 2. basis kode *x*. Ini mencakup banyak pembaruan, seperti format data terstruktur baru, dukungan multitenancy yang ditingkatkan, perubahan skema yang mulus, dan dukungan enkripsi yang dapat dicari. Topik ini memberikan panduan tentang cara memigrasikan kode Anda ke versi 3. *x*.
## Migrasi dari versi 1.x ke 2.x
Migrasi ke versi 2. *x* sebelum Anda bermigrasi ke versi 3. *x*. Versi 2. *x* mengubah simbol untuk Penyedia Terbaru dari `MostRecentProvider` ke`CachingMostRecentProvider`. Jika saat ini Anda menggunakan versi 1. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB dengan `MostRecentProvider` simbol, Anda harus memperbarui nama simbol dalam kode Anda ke. `CachingMostRecentProvider` Untuk informasi selengkapnya, lihat [Pembaruan ke Penyedia Terbaru](most-recent-provider.md#mrp-versions).
## Migrasi dari versi 2.x ke 3.x
Prosedur berikut menjelaskan cara memigrasikan kode Anda dari versi 2. *x* ke versi 3. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB.
### Langkah 1. Bersiaplah untuk membaca item dalam format baru
Selesaikan langkah-langkah berikut untuk mempersiapkan klien SDK Enkripsi AWS Database Anda untuk membaca item dalam format baru. Setelah Anda menerapkan perubahan berikut, klien Anda akan terus berperilaku dengan cara yang sama seperti di versi 2. *x*. Klien Anda akan terus membaca dan menulis item dalam versi 2. *x* format, tetapi perubahan ini mempersiapkan klien untuk [membaca item dalam format baru](#ddb-java-migrate-step2).
**Perbarui AWS SDK untuk Java ke versi 2.x**
Versi 3. *x* [dari pustaka enkripsi sisi klien Java untuk DynamoDB memerlukan DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) DynamoDB Enhanced Client menggantikan Dynamo yang digunakan [dalam DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) versi sebelumnya. Untuk menggunakan klien yang disempurnakan, Anda harus menggunakan AWS SDK for Java 2.x.
Ikuti petunjuk untuk [bermigrasi dari versi 1.x ke 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK untuk Java
Untuk informasi lebih lanjut tentang AWS SDK for Java 2.x modul apa yang diperlukan, lihat[Prasyarat](ddb-java.md#ddb-java-prerequisites).
**Konfigurasikan klien Anda untuk membaca item yang dienkripsi oleh versi lama**
Prosedur berikut memberikan gambaran tentang langkah-langkah yang ditunjukkan dalam contoh kode di bawah ini.
1. Buat [keyring](keyrings.md).
Keyrings dan [manajer bahan kriptografi menggantikan penyedia bahan](concepts.md#crypt-materials-manager) kriptografi yang digunakan dalam versi sebelumnya dari pustaka enkripsi sisi klien Java untuk DynamoDB.
**penting**
Kunci pembungkus yang Anda tentukan saat membuat keyring harus berupa kunci pembungkus yang sama yang Anda gunakan dengan penyedia bahan kriptografi Anda di versi 2. *x*.
1. Buat skema tabel di atas kelas beranotasi Anda.
Langkah ini mendefinisikan tindakan atribut yang akan digunakan ketika Anda mulai menulis item dalam format baru.
*Untuk panduan tentang penggunaan DynamoDB Enhanced Client baru, lihat [Menghasilkan `TableSchema` a di AWS SDK untuk Java Panduan Pengembang](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html).*
Contoh berikut mengasumsikan Anda memperbarui kelas beranotasi Anda dari versi 2. *x* menggunakan anotasi tindakan atribut baru. Untuk panduan selengkapnya tentang anotasi tindakan atribut Anda, lihat. [Gunakan kelas data beranotasi](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**catatan**
Jika Anda menentukan `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atribut apa pun, maka atribut partisi dan sortir juga harus`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Untuk contoh yang menunjukkan anotasi yang digunakan untuk mendefinisikan`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, lihat [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. Tentukan [atribut mana yang dikecualikan dari tanda tangan](ddb-java-using.md#allowed-unauth).
1. Konfigurasikan peta eksplisit tindakan atribut yang dikonfigurasi di kelas model versi 2.x Anda.
Langkah ini mendefinisikan tindakan atribut yang digunakan untuk menulis item dalam format lama.
1. Konfigurasikan yang `DynamoDBEncryptor` Anda gunakan di versi 2. *x* dari pustaka enkripsi sisi klien Java untuk DynamoDB.
1. Konfigurasikan perilaku lama.
1. Buat a`DynamoDbEncryptionInterceptor`.
1. Buat klien AWS SDK DynamoDB baru.
1. Buat `DynamoDBEnhancedClient` dan buat tabel dengan kelas model Anda.
Untuk informasi selengkapnya tentang DynamoDB Enhanced Client, [lihat membuat](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) klien yang disempurnakan.
```
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);
}
}
```
### Langkah 2. Tulis item dalam format baru
Setelah Anda menerapkan perubahan dari Langkah 1 ke semua pembaca, selesaikan langkah-langkah berikut untuk mengonfigurasi klien SDK Enkripsi AWS Database Anda untuk menulis item dalam format baru. Setelah Anda menerapkan perubahan berikut, klien Anda akan melanjutkan membaca item dalam format lama dan mulai menulis dan membaca item dalam format baru.
Prosedur berikut memberikan gambaran tentang langkah-langkah yang ditunjukkan dalam contoh kode di bawah ini.
1. [**Lanjutkan mengonfigurasi keyring, skema tabel, tindakan atribut lama`allowedUnsignedAttributes`, dan `DynamoDBEncryptor` seperti yang Anda lakukan di Langkah 1.**](#ddb-java-migrate-step1)
1. Perbarui perilaku lama Anda untuk hanya menulis item baru menggunakan format baru.
1. Buat `DynamoDbEncryptionInterceptor `
1. Buat klien AWS SDK DynamoDB baru.
1. Buat `DynamoDBEnhancedClient` dan buat tabel dengan kelas model Anda.
Untuk informasi selengkapnya tentang DynamoDB Enhanced Client, [lihat membuat](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) klien yang disempurnakan.
```
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);
}
}
```
[Setelah menerapkan perubahan Langkah 2, Anda harus mengenkripsi ulang semua item lama di tabel Anda dengan format baru sebelum Anda dapat melanjutkan ke Langkah 3.](#ddb-java-migrate-step3) Tidak ada metrik atau kueri tunggal yang dapat Anda jalankan untuk mengenkripsi item yang ada dengan cepat. Gunakan proses yang paling masuk akal untuk sistem Anda. Misalnya, Anda dapat menggunakan proses asinkron yang memindai tabel secara perlahan dan menulis ulang item menggunakan tindakan atribut baru dan konfigurasi enkripsi yang Anda tentukan.
### Langkah 3. Hanya membaca dan menulis item dalam format baru
Setelah mengenkripsi ulang semua item dalam tabel Anda dengan format baru, Anda dapat menghapus perilaku lama dari konfigurasi Anda. Selesaikan langkah-langkah berikut untuk mengonfigurasi klien Anda agar hanya membaca dan menulis item dalam format baru.
Prosedur berikut memberikan gambaran tentang langkah-langkah yang ditunjukkan dalam contoh kode di bawah ini.
1. [**Lanjutkan mengkonfigurasi keyring Anda, skema tabel, dan `allowedUnsignedAttributes` seperti yang Anda lakukan di Langkah 1.**](#ddb-java-migrate-step1) Hapus tindakan atribut lama dan `DynamoDBEncryptor` dari konfigurasi Anda.
1. Buat a`DynamoDbEncryptionInterceptor`.
1. Buat klien AWS SDK DynamoDB baru.
1. Buat `DynamoDBEnhancedClient` dan buat tabel dengan kelas model Anda.
Untuk informasi selengkapnya tentang DynamoDB Enhanced Client, [lihat membuat](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) klien yang disempurnakan.
```
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);
}
}
```