Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bahasa pemrograman Amazon DynamoDB Encryption Client yang tersedia
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Amazon DynamoDB Encryption Client tersedia dalam bahasa pemrograman berikut. Pustaka spesifik-bahasa bervariasi, tetapi implementasi yang dihasilkan dapat dioperasikan. Misalnya, Anda dapat mengenkripsi (dan menandatangani) item dengan klien Java dan mendekripsi item dengan klien Python.
Untuk informasi lebih lanjut, lihat topik terkait.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# Amazon DynamoDB Encryption Client untuk Java
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Topik ini menjelaskan cara menginstal dan menggunakan Amazon DynamoDB Encryption Client untuk Java. Untuk detail tentang pemrograman dengan Klien Enkripsi DynamoDB, lihat contoh [Java](java-examples.md), contoh di repositori [ GitHubaktif](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples), dan aws-dynamodb-encryption-java [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) untuk Klien Enkripsi DynamoDB.
**catatan**
Versi 1. *x*. *x* dari Klien Enkripsi DynamoDB untuk Java sedang [end-of-support dalam](what-is-database-encryption-sdk.md#support) fase efektif Juli 2022. Tingkatkan ke versi yang lebih baru sesegera mungkin.
**Topics**
+ [Prasyarat](#java-prerequisites)
+ [Penginstalan](#java-installation)
+ [Menggunakan Amazon DynamoDB Encryption Client untuk Java](java-using.md)
+ [Contoh Java](java-examples.md)
## Prasyarat
Sebelum Anda menginstal Amazon DynamoDB Encryption Client untuk Java, 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 untuk Java**
Klien Enkripsi DynamoDB memerlukan modul DynamoDB bahkan jika aplikasi Anda tidak berinteraksi dengan DynamoDB. AWS SDK untuk Java Anda dapat menginstal seluruh SDK atau modul ini saja. Jika Anda menggunakan Maven, tambahkan `aws-java-sdk-dynamodb` ke file `pom.xml` Anda.
Untuk informasi selengkapnya tentang menginstal dan mengonfigurasi AWS SDK untuk Java, lihat [AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html).
## Penginstalan
Anda dapat menginstal Amazon DynamoDB Encryption Client untuk Java dengan cara berikut.
**Secara manual**
Untuk menginstal Klien Enkripsi Amazon DynamoDB untuk Java, kloning atau unduh repositori. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Menggunakan Apache Maven**
Amazon DynamoDB Encryption Client untuk Java tersedia melalui [Apache Maven](https://maven.apache.org/) dengan definisi dependensi berikut.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Setelah Anda menginstal SDK, mulailah dengan melihat kode contoh dalam panduan ini dan [DynamoDB](https://aws.github.io/aws-dynamodb-encryption-java/) Encryption Client Javadoc aktif. GitHub
# Menggunakan Amazon DynamoDB Encryption Client untuk Java
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Topik ini menjelaskan beberapa fitur DynamoDB Encryption Client di Java yang mungkin tidak ditemukan dalam implementasi bahasa pemrograman lainnya.
[https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)
**Topics**
+ [Enkriptor item](#attribute-encryptor)
+ [Mengonfigurasi perilaku penyimpanan](#save-behavior)
+ [Tindakan atribut di Java](#attribute-actions-java)
+ [Menimpa nama tabel](#override-table-name)
## Enkripsi item: AttributeEncryptor dan Dynamo DBEncryptor
[Klien Enkripsi DynamoDB di Java memiliki [dua enkripsi item](DDBEC-legacy-concepts.md#item-encryptor): Dynamo tingkat rendah dan. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`Ini adalah kelas pembantu yang membantu Anda menggunakan [Dynamo DBMapper di AWS SDK untuk Java dengan di Klien](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) Enkripsi DynamoDB. `DynamoDB Encryptor` Saat Anda menggunakan `AttributeEncryptor` dengan `DynamoDBMapper`, item tersebut secara transparan mengenkripsi dan menandatangani item Anda saat Anda menyimpannya. Item ini juga secara transparan memverifikasi dan mendekripsi item Anda ketika Anda memuatnya.
## Mengonfigurasi perilaku penyimpanan
Anda dapat menggunakan `AttributeEncryptor` dan `DynamoDBMapper` untuk menambah atau mengganti item tabel dengan atribut yang ditandatangani saja atau dienkripsi dan ditandatangani. Untuk tugas-tugas ini, kami sarankan Anda mengonfigurasinya untuk menggunakan perilaku penyimpanan `PUT`, seperti yang ditunjukkan dalam contoh berikut. Jika tidak, Anda mungkin tidak dapat mendekripsi data.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Jika Anda menggunakan perilaku penyimpanan default, yang hanya memperbarui atribut yang dimodelkan dalam item tabel, atribut yang tidak dimodelkan tidak disertakan dalam tanda tangan, dan tidak diubah oleh penulisan tabel. Akibatnya, pada pembacaan semua atribut nanti, tanda tangan tidak akan memvalidasi, karena tidak menyertakan atribut yang tidak dimodelkan.
Anda juga dapat menggunakan perilaku penyimpanan `CLOBBER`. Perilaku ini identik dengan perilaku penyimpanan `PUT` kecuali pada bagian perilaku ini menonaktifkan penguncian optimis dan menimpa item dalam tabel.
Untuk mencegah kesalahan tanda tangan, Klien Enkripsi DynamoDB melempar pengecualian runtime jika `AttributeEncryptor` digunakan dengan `DynamoDBMapper` yang tidak dikonfigurasi dengan perilaku penyimpanan atau. `CLOBBER` `PUT`
Untuk melihat kode ini digunakan dalam contoh, lihat [Menggunakan Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) dan [AwsKmsEncryptedObjectcontoh.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) di `aws-dynamodb-encryption-java` repositori di. GitHub
## Tindakan atribut di Java
[Tindakan atribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) menentukan mana nilai atribut yang dienkripsi dan ditandatangani, mana yang hanya ditandatangani, dan mana yang diabaikan. [Metode yang Anda gunakan untuk menentukan tindakan atribut tergantung pada apakah Anda menggunakan `DynamoDBMapper` dan`AttributeEncryptor`, atau Dynamo tingkat yang lebih rendah. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**penting**
Setelah Anda menggunakan tindakan atribut untuk mengenkripsi item tabel Anda, menambahkan atau menghapus atribut dari model data Anda dapat menyebabkan kesalahan validasi tanda tangan yang mencegah Anda mendekripsi data Anda. Untuk penjelasan detail, lihat [Mengubah model data Anda](data-model.md).
### Tindakan atribut untuk Dynamo DBMapper
Saat Anda menggunakan `DynamoDBMapper` dan `AttributeEncryptor`, Anda menggunakan anotasi untuk menentukan tindakan atribut. DynamoDB Encryption Client menggunakan [anotasi atribut DynamoDB standar](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) yang menentukan jenis atribut untuk menentukan cara melindungi atribut. Secara default, semua atribut dienkripsi dan ditandatangani kecuali kunci utama, yang ditandatangani tetapi tidak dienkripsi.
**catatan**
Jangan mengenkripsi nilai atribut dengan [anotasi DBVersion Atribut @Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), meskipun Anda dapat (dan harus) menandatanganinya. Jika dilakukan, syarat yang menggunakan nilai tersebut akan memiliki efek yang tidak diinginkan.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Untuk menentukan pengecualian, gunakan anotasi enkripsi yang didefinisikan dalam DynamoDB Encryption Client untuk Java. Jika Anda menentukannya di tingkat kelas, pengecualian itu menjadi nilai default untuk kelas tersebut.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Sebagai contoh, anotasi ini menandatangani tetapi tidak mengenkripsi atribut `PublicationYear`, dan tidak mengenkripsi atau menandatangani nilai atribut `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Tindakan atribut untuk Dynamo DBEncryptor
Untuk menentukan tindakan atribut saat Anda menggunakan [Dynamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) secara langsung, buat `HashMap` objek di mana pasangan nama-nilai mewakili nama atribut dan tindakan yang ditentukan.
Nilai-nilai yang valid adalah untuk tindakan atribut yang didefinisikan dalam jenis `EncryptionFlags` yang disebutkan. Anda dapat menggunakan `ENCRYPT` dan `SIGN` secara bersamaan, menggunakan `SIGN` saja, atau tidak menggunakan keduanya. Namun, jika Anda menggunakan `ENCRYPT` saja, DynamoDB Encryption Client menyebabkan kesalahan. Anda tidak dapat mengenkripsi atribut yang tidak Anda tanda tangani.
```
ENCRYPT
SIGN
```
**Awas**
Jangan mengenkripsi atribut kunci utama. Atribut tersebut harus tetap dalam plaintext sehingga DynamoDB dapat menemukan item tanpa memindai keseluruhan tabel.
Jika Anda menentukan kunci utama dalam konteks enkripsi dan kemudian menetapkan `ENCRYPT` dalam tindakan atribut untuk atribut kunci utama, DynamoDB Encryption Client membuat pengecualian.
Misalnya, kode Java berikut membuat sebuah `actions` HashMap yang mengenkripsi dan menandatangani semua atribut dalam item. `record` Pengecualiannya adalah atribut kunci partisi dan kunci penyortiran, yang ditandatangani tetapi tidak dienkripsi, dan atribut `test`, yang tidak ditandatangani atau dienkripsi.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Kemudian, ketika Anda memanggil metode [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-) `DynamoDBEncryptor`, tentukan peta sebagai nilai parameter `attributeFlags`. Sebagai contoh, panggilan untuk `encryptRecord` ini menggunakan peta `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Menimpa nama tabel
Pada DynamoDB Encryption Client, nama tabel DynamoDB adalah elemen [konteks enkripsi DynamoDB](concepts.md#encryption-context) yang diteruskan ke metode enkripsi dan dekripsi. Ketika Anda mengenkripsi atau menandatangani item tabel, konteks enkripsi DynamoDB, termasuk nama tabel, secara kriptografis terikat pada ciphertext. Jika konteks enkripsi DynamoDB yang diteruskan ke metode dekripsi tidak cocok dengan konteks enkripsi DynamoDB yang diteruskan ke metode enkripsi, operasi dekripsi gagal.
Kadang-kadang, nama tabel berubah, seperti ketika Anda membuat cadangan tabel atau melakukan [point-in-time pemulihan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html). Ketika Anda mendekripsi atau memverifikasi tanda tangan item ini, Anda harus menggunakan konteks enkripsi DynamoDB yang sama yang digunakan untuk mengenkripsi dan menandatangani item, termasuk nama tabel asli. Nama tabel saat ini tidak diperlukan.
Saat Anda menggunakan `DynamoDBEncryptor`, Anda menyusun konteks enkripsi DynamoDB secara manual. Namun, jika Anda menggunakan `DynamoDBMapper`, `AttributeEncryptor` membuat konteks enkripsi DynamoDB untuk Anda, termasuk nama tabel saat ini. Untuk memerintahkan `AttributeEncryptor` agar membuat konteks enkripsi dengan nama tabel yang berbeda, gunakan `EncryptionContextOverrideOperator`.
Sebagai contoh, kode berikut menciptakan instans penyedia materi kriptografis (CMP) dan `DynamoDBEncryptor`. Kemudian kode itu memanggil metode `setEncryptionContextOverrideOperator` pada `DynamoDBEncryptor`. Kode itu menggunakan operator `overrideEncryptionContextTableName`, yang menimpa satu nama tabel. Ketika dikonfigurasi dengan cara ini, `AttributeEncryptor` membuat konteks enkripsi DynamoDB yang mencakup `newTableName` menggantikan `oldTableName`. Untuk contoh lengkap, lihat [EncryptionContextOverridesWithDynamoDBMapper.java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Ketika Anda memanggil metode beban pada `DynamoDBMapper`, yang mendekripsi dan memverifikasi item, Anda menentukan nama tabel asli.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Anda juga dapat menggunakan operator `overrideEncryptionContextTableNameUsingMap`, yang menimpa beberapa nama tabel.
Operator penimpa nama tabel biasanya digunakan ketika mendekripsi data dan memverifikasi tanda tangan. Namun, Anda dapat menggunakannya untuk menetapkan nama tabel dalam konteks enkripsi DynamoDB dengan nilai yang berbeda saat mengenkripsi dan menandatangani.
Jangan gunakan operator penimpa nama tabel jika Anda menggunakan `DynamoDBEncryptor`. Sebaliknya, buatlah konteks enkripsi dengan nama tabel asli dan kirimkan ke metode dekripsi.
# Contoh kode untuk DynamoDB Encryption Client untuk Java
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Contoh berikut menunjukkan cara menggunakan DynamoDB Encryption Client untuk Java guna melindungi item tabel DynamoDB dalam aplikasi Anda. Anda dapat menemukan lebih banyak contoh (dan berkontribusi sendiri) di direktori [contoh [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)repositori di. GitHub
**Topics**
+ [Menggunakan Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Menggunakan Dynamo DBMapper](#java-example-dynamodb-mapper)
## Menggunakan Dynamo DBEncryptor
Contoh ini menunjukkan cara menggunakan [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) tingkat rendah DBEncryptor dengan [Direct](direct-kms-provider.md) KMS Provider. Penyedia KMS Langsung menghasilkan dan melindungi materi kriptografinya di bawah [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) yang Anda tentukan.
Anda dapat menggunakan [penyedia materi kriptografi](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) yang kompatibel dengan`DynamoDBEncryptor`, dan Anda dapat menggunakan Penyedia KMS Langsung dengan dan. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**Lihat contoh kode lengkapnya**: [AwsKmsEncryptedItem.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
Langkah 1: Buat Penyedia KMS Langsung
Buat instance AWS KMS klien dengan wilayah yang ditentukan. Kemudian, gunakan instance klien untuk membuat instance Penyedia KMS Langsung dengan pilihan AWS KMS key Anda.
Contoh ini menggunakan Amazon Resource Name (ARN) untuk mengidentifikasi AWS KMS key, tetapi Anda dapat menggunakan pengidentifikasi [kunci yang valid](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Langkah 2: Buat item
Contoh ini mendefinisikan `record` HashMap yang mewakili item tabel sampel.
```
final String partitionKeyName = "partition_attribute";
final String sortKeyName = "sort_attribute";
final Map record = new HashMap<>();
record.put(partitionKeyName, new AttributeValue().withS("value1"));
record.put(sortKeyName, new AttributeValue().withN("55"));
record.put("example", new AttributeValue().withS("data"));
record.put("numbers", new AttributeValue().withN("99"));
record.put("binary", new AttributeValue().withB(ByteBuffer.wrap(new byte[]{0x00, 0x01, 0x02})));
record.put("test", new AttributeValue().withS("test-value"));
```
Langkah 3: Buat Dynamo DBEncryptor
Buat instans `DynamoDBEncryptor` dengan Penyedia KMS Langsung.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Langkah 4: Buat konteks enkripsi DynamoDB
[Konteks enkripsi DynamoDB](concepts.md#encryption-context) berisi informasi tentang struktur tabel dan bagaimana tabel itu dienkripsi dan ditandatangani. Jika Anda menggunakan `DynamoDBMapper`, `AttributeEncryptor` membuat konteks enkripsi untuk Anda.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Langkah 5: Buat objek tindakan atribut
[Tindakan atribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) menentukan mana atribut item yang dienkripsi dan ditandatangani, mana yang hanya ditandatangani, dan mana yang tidak dienkripsi dan ditandatangani.
Di Java, untuk menentukan tindakan atribut, Anda membuat HashMap nama atribut dan pasangan `EncryptionFlags` nilai.
Misalnya, kode Java berikut membuat `actions` HashMap yang mengenkripsi dan menandatangani semua atribut dalam `record` item, kecuali untuk kunci partisi dan atribut kunci sortir, yang ditandatangani, tetapi tidak dienkripsi, dan `test` atribut, yang tidak ditandatangani atau dienkripsi.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // fall through to the next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Neither encrypted nor signed
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Langkah 6: Enkripsi dan tanda tangani item
Untuk mengenkripsi dan menandatangani item tabel, panggil metode `encryptRecord` pada instans `DynamoDBEncryptor`. Tentukan item tabel (`record`), tindakan atribut (`actions`), dan konteks enkripsi (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Langkah 7: Masukkan item ke dalam tabel DynamoDB
Akhirnya, letakkan item yang dienkripsi dan ditandatangani ke dalam tabel DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Menggunakan Dynamo DBMapper
Contoh berikut menunjukkan kepada Anda cara menggunakan kelas bantuan DynamoDB Mapper dengan [Penyedia KMS Langsung](direct-kms-provider.md). Penyedia KMS Langsung menghasilkan dan melindungi materi kriptografinya di bawah [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) yang Anda tentukan.
Anda dapat menggunakan [penyedia materi kriptografis](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) yang kompatibel dengan `DynamoDBMapper`, dan Anda dapat menggunakan Penyedia KMS Langsung dengan `DynamoDBEncryptor` yang tingkatnya lebih rendah.
**Lihat contoh kode lengkapnya**: [AwsKmsEncryptedObject.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)
Langkah 1: Buat Penyedia KMS Langsung
Buat instance AWS KMS klien dengan wilayah yang ditentukan. Kemudian, gunakan instance klien untuk membuat instance Penyedia KMS Langsung dengan pilihan AWS KMS key Anda.
Contoh ini menggunakan Amazon Resource Name (ARN) untuk mengidentifikasi AWS KMS key, tetapi Anda dapat menggunakan pengidentifikasi [kunci yang valid](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Langkah 2: Buat DynamoDB Encryptor dan Dynamo DBMapper
Gunakan Penyedia KMS Langsung yang Anda buat di langkah sebelumnya untuk membuat instans [DynamoDB Encryptor](java-using.md#attribute-encryptor). Anda perlu membuat instans bagi DynamoDB Encryptor yang tingkatnya lebih rendah untuk menggunakan DynamoDB Mapper.
Berikutnya, membuat sebuah instans dari database DynamoDB Anda dan konfigurasi mapper, dan menggunakannya untuk membuat sebuah instance dari DynamoDB Mapper.
Saat menggunakan `DynamoDBMapper` untuk menambah atau mengedit item yang ditandatangani (atau dienkripsi dan ditandatangani), atur konfigurasinya untuk [menggunakan perilaku penympanan](java-using.md#save-behavior), seperti `PUT`, yang mencakup semua atribut, seperti yang ditunjukkan dalam contoh berikut. Jika tidak, Anda mungkin tidak dapat mendekripsi data.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp)
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Langkah 3: Tentukan tabel DynamoDB Anda
Selanjutnya, tentukan tabel DynamoDB Anda. Gunakan anotasi untuk menentukan [tindakan atribut](java-using.md#attribute-actions-java). Contoh ini membuat tabel DynamoDB, `ExampleTable`, dan kelas `DataPoJo` yang mewakili item tabel.
Dalam tabel contoh ini, atribut kunci utama akan ditandatangani tetapi tidak dienkripsi. Hal ini berlaku untuk `partition_attribute`, yang dianotasikan dengan `@DynamoDBHashKey`, dan `sort_attribute`, yang dianotasikan dengan `@DynamoDBRangeKey`.
Atribut yang dianotasikan dengan `@DynamoDBAttribute`, seperti `some numbers`, akan dienkripsi dan ditandatangani. Pengecualiannya mencakup atribut yang menggunakan anotasi enkripsi `@DoNotEncrypt` (hanya ditandatangani) atau `@DoNotTouch` (jangan dienkripsi atau ditandatangani) yang didefinisikan oleh DynamoDB Encryption Client. Sebagai contoh, karena atribut `leave me` memiliki anotasi `@DoNotTouch`, atribut ini tidak akan dienkripsi atau ditandatangani.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String example;
private long someNumbers;
private byte[] someBinary;
private String leaveMe;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "example")
public String getExample() {
return example;
}
public void setExample(String example) {
this.example = example;
}
@DynamoDBAttribute(attributeName = "some numbers")
public long getSomeNumbers() {
return someNumbers;
}
public void setSomeNumbers(long someNumbers) {
this.someNumbers = someNumbers;
}
@DynamoDBAttribute(attributeName = "and some binary")
public byte[] getSomeBinary() {
return someBinary;
}
public void setSomeBinary(byte[] someBinary) {
this.someBinary = someBinary;
}
@DynamoDBAttribute(attributeName = "leave me")
@DoNotTouch
public String getLeaveMe() {
return leaveMe;
}
public void setLeaveMe(String leaveMe) {
this.leaveMe = leaveMe;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ", sortAttribute="
+ sortAttribute + ", example=" + example + ", someNumbers=" + someNumbers
+ ", someBinary=" + Arrays.toString(someBinary) + ", leaveMe=" + leaveMe + "]";
}
}
```
Langkah 4: Enkripsi dan simpan item tabel
Sekarang, ketika Anda membuat item tabel dan menggunakan DynamoDB Mapper untuk menyimpannya, item secara otomatis dienkripsi dan ditandatangani sebelum ditambahkan ke tabel.
Contoh ini mendefinisikan item tabel yang disebut `record`. Sebelum disimpan dalam tabel, atributnya dienkripsi dan ditandatangani berdasarkan anotasi di kelas `DataPoJo`. Dalam hal ini, semua atribut kecuali `PartitionAttribute`, `SortAttribute`, dan `LeaveMe` dienkripsi dan ditandatangani. `PartitionAttribute` dan `SortAttributes` hanya ditandatangani. Atribut `LeaveMe` tidak dienkripsi atau ditandatangani.
Untuk mengenkripsi dan menandatangani item `record`, dan kemudian menambahkannya ke `ExampleTable`, panggil metode `save` kelas `DynamoDBMapper`. Karena DynamoDB Mapper Anda dikonfigurasi untuk menggunakan perilaku penyimpanan `PUT`, item tersebut menggantikan semua item dengan kunci utama yang sama, bukan memperbaruinya. Hal ini memastikan tanda tangan cocok dan Anda dapat mendekripsi item ketika Anda mendapatkannya dari tabel.
```
DataPoJo record = new DataPoJo();
record.setPartitionAttribute("is this");
record.setSortAttribute(55);
record.setExample("data");
record.setSomeNumbers(99);
record.setSomeBinary(new byte[]{0x00, 0x01, 0x02});
record.setLeaveMe("alone");
mapper.save(record);
```
# DynamoDB Encryption Client untuk Python
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Topik ini menjelaskan cara menginstal dan menggunakan DynamoDB Encryption Client untuk Python. Anda dapat menemukan kode di [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repositori GitHub, termasuk [kode sampel](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) lengkap dan teruji untuk membantu Anda memulai.
**catatan**
Versi 1. *x*. *x* dan 2. *x*. *x* [dari Klien Enkripsi DynamoDB untuk Python sedang end-of-support dalam fase efektif Juli 2022.](what-is-database-encryption-sdk.md#support) Tingkatkan ke versi yang lebih baru sesegera mungkin.
**Topics**
+ [Prasyarat](#python-prerequisites)
+ [Penginstalan](#python-installation)
+ [Menggunakan DynamoDB Encryption Client untuk Python](python-using.md)
+ [Contoh Python](python-examples.md)
## Prasyarat
Sebelum Anda menginstal Amazon DynamoDB Encryption Client untuk Python, pastikan Anda memiliki prasyarat berikut.
**Versi Python yang didukung**
Python 3.8 atau yang lebih baru diperlukan oleh Klien Enkripsi Amazon DynamoDB untuk Python versi 3.3.0 dan yang lebih baru. Untuk mengunduh Python, lihat [Unduh Python](https://www.python.org/downloads/).
Versi sebelumnya dari Amazon DynamoDB Encryption Client untuk Python mendukung Python 2.7 dan Python 3.4 dan yang lebih baru, tetapi kami menyarankan Anda menggunakan versi terbaru dari DynamoDB Encryption Client.
**Alat instalasi pip untuk Python**
Python 3.6 dan yang lebih baru menyertakan **pip**, meskipun Anda mungkin ingin memutakhirkannya. Untuk informasi selengkapnya tentang meningkatkan atau menginstal pip, lihat [Instalasi](https://pip.pypa.io/en/latest/installation/) dalam dokumentasi **pip**.
## Penginstalan
Gunakan **pip** untuk menginstal Amazon DynamoDB Encryption Client, seperti yang ditunjukkan dalam contoh berikut.
**Pasang versi terbaru**
```
pip install dynamodb-encryption-sdk
```
Untuk detail lebih lanjut tentang menggunakan **pip** untuk menginstal dan meng-upgrade paket, lihat [Menginstal Paket](https://packaging.python.org/tutorials/installing-packages/).
DynamoDB Encryption Client memerlukan [pustaka kriptografi](https://cryptography.io/en/latest/) di semua platform. Semua versi **pip** menginstal dan membangun **kriptografi** pada pip. **Windows** 8.1 dan versi lebih baru menginstal dan membangun **kriptografi** di Linux. Jika Anda menggunakan versi sebelumnya dari **pip** dan lingkungan Linux Anda tidak memiliki alat yang diperlukan untuk membangun **pustaka** kriptografi, Anda perlu menginstalnya. Untuk informasi selengkapnya, lihat [Membangun kriptografi di Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
Anda bisa mendapatkan versi pengembangan terbaru dari DynamoDB Encryption Client dari [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repositori. GitHub
Setelah Anda menginstal DynamoDB Encryption Client, mulailah dengan melihat kode contoh Python dalam panduan ini.
# Menggunakan DynamoDB Encryption Client untuk Python
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Topik ini menjelaskan beberapa fitur DynamoDB Encryption Client untuk Python yang mungkin tidak ditemukan dalam implementasi bahasa pemrograman lainnya. Fitur-fitur ini dirancang untuk membuatnya lebih mudah untuk menggunakan DynamoDB Encryption Client dengan cara yang paling aman. Jika Anda tidak memiliki kasus penggunaan yang tidak biasa, kami sarankan Anda menggunakannya.
[Untuk detail tentang pemrograman dengan Klien Enkripsi DynamoDB, lihat contoh [Python](python-examples.md) dalam panduan ini, contoh di repositori GitHub aktif, dan dokumentasi [Python aws-dynamodb-encryption-python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) untuk Klien Enkripsi DynamoDB.](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples)
**Topics**
+ [Kelas pembantu klien](#python-helpers)
+ [TableInfo kelas](#table-info)
+ [Tindakan atribut di Python](#python-attribute-actions)
## Kelas pembantu klien
DynamoDB Encryption Client untuk Python termasuk beberapa kelas pembantu klien yang mencerminkan kelas-kelas Boto 3 untuk DynamoDB. Kelas-kelas pembantu ini dirancang untuk membuatnya lebih mudah untuk menambahkan enkripsi dan penandatanganan ke aplikasi DynamoDB yang ada dan menghindari masalah yang paling umum, sebagai berikut:
+ Mencegah Anda mengenkripsi kunci utama dalam item Anda, baik dengan menambahkan tindakan penggantian untuk kunci utama ke [AttributeActions](#python-attribute-actions)objek, atau dengan melempar pengecualian jika `AttributeActions` objek Anda secara eksplisit memberi tahu klien untuk mengenkripsi kunci utama. Jika tindakan default di objek `AttributeActions` Anda adalah `DO_NOTHING`, kelas pembantu klien menggunakan tindakan tersebut untuk kunci primer. Jika tidak, mereka menggunakan `SIGN_ONLY`.
+ Buat [TableInfo objek](#python-helpers) dan isi konteks [enkripsi DynamoDB berdasarkan panggilan ke DynamoDB](concepts.md#encryption-context). Ini membantu untuk memastikan bahwa konteks enkripsi DynamoDB Anda akurat dan klien dapat mengidentifikasi kunci utama.
+ Metode Support, seperti `put_item` dan `get_item`, yang secara transparan mengenkripsi dan mendekripsi tabel item ketika Anda menulis atau membaca dari tabel DynamoDB. Hanya metode `update_item` yang tidak didukung.
Anda dapat menggunakan kelas pembantu klien,alih-alih berinteraksi langsung dengan [enkriptor item](DDBEC-legacy-concepts.md#item-encryptor) yang tingkatnya lebih rendah. Gunakan kelas-kelas ini kecuali Anda perlu mengatur opsi lanjutan dalam enkriptor item.
Kelas pembantu klien meliputi:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)untuk aplikasi yang menggunakan sumber daya [Tabel](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) di DynamoDB untuk memproses satu tabel pada satu waktu.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)untuk aplikasi yang menggunakan kelas [Service Resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) di DynamoDB untuk pemrosesan batch.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)untuk aplikasi yang menggunakan [klien tingkat rendah di DynamoDB](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client).
Untuk menggunakan kelas pembantu klien, pemanggil harus memiliki izin untuk memanggil operasi DynamoDB pada tabel target [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html).
## TableInfo kelas
[TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)Kelas adalah kelas pembantu yang mewakili tabel DynamoDB, lengkap dengan bidang untuk kunci utama dan indeks sekunder. Ini membantu Anda untuk mendapatkan informasi akurat dan real-time tentang tabel.
Jika Anda menggunakan[kelas pembantu klien](#python-helpers), itu menciptakan dan menggunakan objek `TableInfo` untuk Anda. Jika tidak, Anda dapat membuat satu secara eksplisit. Sebagai contoh, lihat [Gunakan enkriptor item](python-examples.md#python-example-item-encryptor).
Ketika Anda memanggil `refresh_indexed_attributes` metode pada `TableInfo` objek, itu mengisi nilai properti objek dengan memanggil operasi DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Kueri tabel jauh lebih dapat diandalkan daripada nama indeks hard-coding. Kelas `TableInfo` juga mencakup sebuah properti `encryption_context_values` yang menyediakan nilai-nilai yang diperlukan untuk [konteks enkripsi DynamoDB](concepts.md#encryption-context).
Untuk menggunakan `refresh_indexed_attributes` metode ini, pemanggil harus memiliki izin untuk memanggil operasi [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB pada tabel target.
## Tindakan atribut di Python
[Tindakan atribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) memberitahukan kepada enkriptor item tentang tindakan yang dilakukan pada setiap atribut item. Untuk menentukan tindakan atribut di Python, buat objek `AttributeActions` dengan tindakan default dan pengecualian untuk atribut tertentu. Nilai-nilai yang valid adalah untuk tindakan atribut yang didefinisikan dalam jenis `CryptoAction` yang disebutkan.
**penting**
Setelah Anda menggunakan tindakan atribut untuk mengenkripsi item tabel Anda, menambahkan atau menghapus atribut dari model data Anda dapat menyebabkan kesalahan validasi tanda tangan yang mencegah Anda mendekripsi data Anda. Untuk penjelasan detail, lihat [Mengubah model data Anda](data-model.md).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Misalnya, objek `AttributeActions` ini menetapkan `ENCRYPT_AND_SIGN` sebagai default untuk semua atribut, dan menentukan pengecualian untuk atribut `ISBN` dan `PublicationYear`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Jika Anda menggunakan sebuah [kelas pembantu klien](#python-helpers), Anda tidak perlu menentukan tindakan atribut untuk atribut kunci primer. Kelas pembantu klien mencegah Anda mengenkripsi kunci utama Anda.
Jika Anda tidak menggunakan kelas pembantu klien dan tindakan default adalah `ENCRYPT_AND_SIGN`, Anda harus menentukan tindakan untuk kunci primer. Tindakan yang direkomendasikan untuk kunci primer adalah `SIGN_ONLY`. Untuk mempermudahnya, gunakan metode `set_index_keys`, yang menggunakan SIGN\$1ONLY untuk kunci primer, atau DO\$1NOTHING, ketika itu adalah tindakan default.
**Awas**
Jangan mengenkripsi atribut kunci utama. Atribut tersebut harus tetap dalam plaintext sehingga DynamoDB dapat menemukan item tanpa memindai keseluruhan tabel.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Contoh kode untuk DynamoDB Encryption Client untuk Python
**catatan**
Pustaka enkripsi sisi klien kami [diubah namanya menjadi AWS Database Encryption SDK](DDBEC-rename.md). Topik berikut memberikan informasi tentang versi 1. *x* —2. *x* dari DynamoDB Encryption Client untuk Java dan versi 1. *x* —3. *x* dari Klien Enkripsi DynamoDB untuk Python. Untuk informasi selengkapnya, lihat [SDK Enkripsi AWS Database untuk dukungan versi DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Contoh berikut menunjukkan cara menggunakan DynamoDB Encryption Client untuk Python guna melindungi data DynamoDB dalam aplikasi Anda. Anda dapat menemukan lebih banyak contoh (dan berkontribusi sendiri) di direktori [contoh [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples)repositori di. GitHub
**Topics**
+ [Gunakan kelas pembantu EncryptedTable klien](#python-example-table)
+ [Gunakan enkriptor item](#python-example-item-encryptor)
## Gunakan kelas pembantu EncryptedTable klien
Contoh berikut menunjukkan cara menggunakan [Provider KMS Langsung](direct-kms-provider.md)dengan [kelas pembantu klien](python-using.md#python-helpers) `EncryptedTable`. Contoh ini menggunakan [penyedia bahan kriptografi](DDBEC-legacy-concepts.md#concept-material-provider) yang sama seperti contoh [Gunakan enkriptor item](#python-example-item-encryptor) berikut. Namun, contoh tersebut menggunakan kelas `EncryptedTable` alih-alih berinteraksi langsung dengan [enkriptor item](DDBEC-legacy-concepts.md#item-encryptor) yang tingkatnya lebih rendah.
Dengan membandingkan contoh-contoh ini, Anda dapat melihat pekerjaan yang kelas pembantu klien untuk Anda. Hal ini mencakup pembuatan [konteks enkripsi DynamoDB](concepts.md#encryption-context) dan memastikan atribut kunci primer selalu ditandatangani, tetapi tidak pernah dienkripsi. Untuk membuat konteks enkripsi dan menemukan kunci utama, kelas pembantu klien memanggil operasi DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Untuk menjalankan kode ini, Anda harus memiliki izin untuk memanggil operasi ini.
**Lihat contoh kode lengkap**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Langkah 1: Buat Tabel
Mulailah dengan membuat sebuah instans dari tabel DynamoDB standar dengan nama tabel.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Langkah 2: Buat penyedia bahan kriptografi
Buat instans [penyedia bahan kriptografi](crypto-materials-providers.md) (CMP) yang Anda pilih.
Contoh ini menggunakan [Penyedia KMS Langsung](direct-kms-provider.md), tetapi Anda dapat menggunakan CMP mana pun yang kompatibel. Untuk membuat Penyedia KMS Langsung, tentukan. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Contoh ini menggunakan Amazon Resource Name (ARN) dari AWS KMS key, tetapi Anda dapat menggunakan pengenal kunci yang valid.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Langkah 3: Buat objek tindakan atribut
[Tindakan atribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) memberitahukan kepada enkriptor item tentang tindakan yang dilakukan pada setiap atribut item. Objek `AttributeActions` dalam contoh ini mengenkripsi dan menandatangani semua item kecuali untuk atribut `test`, yang diabaikan.
Jangan tentukan tindakan atribut untuk atribut kunci primer saat Anda menggunakan kelas pembantu klien. Kelas `EncryptedTable` menandatangani, tetapi tidak pernah mengenkripsi, atribut kunci utama.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Langkah 4: Buat tabel terenkripsi
Membuat tabel dienkripsi menggunakan tabel standar, Penyedia KMS Langsung, dan tindakan atribut. Langkah ini melengkapi konfigurasi.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Langkah 5: Masukkan item plaintext ke dalam tabel
Ketika Anda memanggil metode `put_item` di `encrypted_table`, item tabel Anda secara transparan dienkripsi, ditandatangani, dan ditambahkan ke tabel DynamoDB Anda.
Pertama, tentukan item tabel.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Lalu, taruh di tabel.
```
encrypted_table.put_item(Item=plaintext_item)
```
Untuk mendapatkan item dari daftar tabel DynamoDB dalam bentuk terenkripsi, panggil metode `get_item` di objek `table`. Untuk mendapatkan item didekripsi, panggil metode `get_item` di objek `encrypted_table`.
## Gunakan enkriptor item
Contoh ini menunjukkan kepada Anda bagaimana untuk berinteraksi langsung dengan [enkriptor item](DDBEC-legacy-concepts.md#item-encryptor) di DynamoDB Encryption Client ketika mengenkripsi item tabel, alih-alih menggunakan [kelas pembantu klien](python-using.md#python-helpers) yang berinteraksi dengan enkriptor item untuk Anda.
Bila Anda menggunakan teknik ini, Anda membuat konteks enkripsi DynamoDB dan konfigurasi objek (`CryptoConfig`) secara manual. Anda juga mengenkripsi item dalam satu panggilan dan menempatkannya dalam tabel DynamoDB Anda dalam panggilan terpisah. Hal ini memungkinkan Anda untuk menyesuaikan panggilan `put_item` Anda dan menggunakan DynamoDB Encryption Client untuk mengenkripsi dan menandatangani data terstruktur yang tidak pernah dikirim ke DynamoDB.
Contoh ini menggunakan [Penyedia KMS Langsung](direct-kms-provider.md), tetapi Anda dapat menggunakan CMP kompatibel.
**Lihat contoh kode lengkap**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Langkah 1: Buat Tabel
Mulailah dengan membuat sebuah instans dari sumber daya tabel DynamoDB standar dengan nama tabel.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Langkah 2: Buat penyedia bahan kriptografi
Buat instans [penyedia bahan kriptografi](crypto-materials-providers.md) (CMP) yang Anda pilih.
Contoh ini menggunakan [Penyedia KMS Langsung](direct-kms-provider.md), tetapi Anda dapat menggunakan CMP mana pun yang kompatibel. Untuk membuat Penyedia KMS Langsung, tentukan. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Contoh ini menggunakan Amazon Resource Name (ARN) dari AWS KMS key, tetapi Anda dapat menggunakan pengenal kunci yang valid.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Langkah 3: Gunakan TableInfo kelas pembantu
Untuk mendapatkan informasi tentang tabel dari DynamoDB, buat instance dari [TableInfo](python-using.md#python-helpers)kelas helper. Apabila Anda bekerja secara langsung dengan enkriptor item, Anda perlu membuat instans `TableInfo` dan memanggil metodenya. [Kelas pembantu klien](python-using.md#python-helpers) melakukan ini untuk Anda.
`refresh_indexed_attributes`Metode `TableInfo` menggunakan operasi [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB untuk mendapatkan informasi real-time dan akurat tentang tabel. Ini termasuk kunci primer dan indeks sekunder lokal dan global. Pemanggil perlu memiliki izin untuk memanggil `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Langkah 4: Buat konteks enkripsi DynamoDB
[Konteks enkripsi DynamoDB](concepts.md#encryption-context) berisi informasi tentang struktur tabel dan bagaimana tabel itu dienkripsi dan ditandatangani. Contoh ini menciptakan konteks enkripsi DynamoDB secara eksplisit, karena berinteraksi dengan enkriptor item. [Kelas pembantu klien](python-using.md#python-helpers) membuat konteks enkripsi DynamoDB untuk Anda.
Untuk mendapatkan kunci partisi dan kunci sortir, Anda dapat menggunakan properti kelas [TableInfo](python-using.md#python-helpers)pembantu.
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Langkah 5: Buat objek tindakan atribut
[Tindakan atribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) memberitahukan kepada enkriptor item tentang tindakan yang dilakukan pada setiap atribut item. Objek `AttributeActions` dalam contoh ini mengenkripsi dan menandatangani semua item kecuali atribut kunci utama, yang ditandatangani, tetapi tidak dienkripsi, dan atribut `test`, yang diabaikan.
Ketika Anda berinteraksi langsung dengan item enkripsi dan tindakan default Anda adalah `ENCRYPT_AND_SIGN`, Anda harus menentukan tindakan alternatif untuk kunci primer. Anda dapat menggunakan metode `set_index_keys`, yang menggunakan `SIGN_ONLY` untuk kunci primer, atau menggunakan `DO_NOTHING` jika itu adalah tindakan default.
Untuk menentukan kunci utama, contoh ini menggunakan kunci indeks dalam [TableInfo](python-using.md#python-helpers)objek, yang diisi oleh panggilan ke DynamoDB. Teknik ini lebih aman daripada nama kunci primer hard-coding.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Langkah 6: Buat konfigurasi untuk item
Untuk mengonfigurasi Klien Enkripsi DynamoDB, gunakan objek yang baru saja Anda buat dalam [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)konfigurasi untuk item tabel. Kelas pembantu klien membuat CryptoConfig untuk Anda.
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Langkah 7: Enkripsi item
Langkah ini mengenkripsi dan menandai item, tetapi tidak memasukkannya ke dalam tabel DynamoDB.
Ketika Anda menggunakan kelas pembantu klien, item Anda secara transparan dienkripsi dan ditandatangani, dan kemudian ditambahkan ke tabel DynamoDB Anda ketika Anda memanggil metode `put_item` kelas pembantu. Ketika Anda menggunakan item enkripsi secara langsung, enkripsi dan tindakan independen.
Pertama, buat item plaintext.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Kemudian, enkripsi dan tanda tangani. Metode `encrypt_python_item` memerlukan objek konfigurasi `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Langkah 8: Masukkan item ke dalam tabel DynamoDB
Akhirnya, letakkan item yang dienkripsi dan ditandatangani ke dalam tabel DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Untuk melihat item yang dienkripsi, panggil metode `get_item` pada objek `table` asli, bukan dari objek `encrypted_table`. Item didapatkan dari tabel DynamoDB tanpa memverifikasi dan mendekripsinya.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
Gambar berikut menunjukkan bagian dari contoh item tabel yang dienkripsi dan ditandatangani.
Nilai atribut terenkripsi adalah data biner. Nama dan nilai atribut kunci primer (`partition_attribute` dan `sort_attribute`) dan atribut `test` tetap dalam plaintext. Output juga menunjukkan atribut yang berisi tanda tangan (`*amzn-ddb-map-sig*`) dan [atribut deskripsi materi](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Kutipan dari item yang dienkripsi dan ditandatangani\]](http://docs.aws.amazon.com/id_id/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)