Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# AWS Encryption SDK untuk Rust
<a name="rust"></a>

Topik ini menjelaskan cara menginstal dan menggunakan AWS Encryption SDK for Rust. Untuk detail tentang pemrograman dengan AWS Encryption SDK for Rust, lihat direktori [Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/) dari aws-encryption-sdk repositori di. GitHub

The AWS Encryption SDK for Rust berbeda dari beberapa implementasi bahasa pemrograman lainnya dengan AWS Encryption SDK cara berikut:
+ Tidak ada dukungan untuk [caching kunci data](data-key-caching.md). Namun, AWS Encryption SDK for Rust mendukung [keyring AWS KMS Hierarchical, solusi](use-hierarchical-keyring.md) caching bahan kriptografi alternatif.
+ Tidak ada dukungan untuk streaming data

The AWS Encryption SDK for Rust mencakup semua fitur keamanan yang diperkenalkan dalam versi 2.0. *x* dan yang lebih baru dari implementasi bahasa lain dari. AWS Encryption SDK Namun, jika Anda menggunakan for Rust AWS Encryption SDK untuk mendekripsi data yang dienkripsi oleh pra-2.0. *x* versi implementasi bahasa lain dari AWS Encryption SDK, Anda mungkin perlu menyesuaikan [kebijakan komitmen](concepts.md#commitment-policy) Anda. Lihat perinciannya di [Cara menetapkan kebijakan komitmen Anda](migrate-commitment-policy.md#migrate-commitment-step1).

The AWS Encryption SDK for Rust adalah produk dari AWS Encryption SDK in [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), bahasa verifikasi formal di mana Anda menulis spesifikasi, kode untuk mengimplementasikannya, dan bukti untuk mengujinya. Hasilnya adalah perpustakaan yang mengimplementasikan fitur-fitur AWS Encryption SDK dalam kerangka kerja yang menjamin kebenaran fungsional.

**Pelajari Lebih Lanjut**
+ Untuk contoh yang menunjukkan cara mengonfigurasi opsi di AWS Encryption SDK, seperti menentukan rangkaian algoritme alternatif, membatasi kunci data terenkripsi, dan menggunakan kunci AWS KMS Multi-region, lihat. [Mengkonfigurasi AWS Encryption SDK](configure.md)
+ Untuk contoh yang menunjukkan cara mengonfigurasi dan menggunakan AWS Encryption SDK untuk Rust, lihat [contoh Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples) di aws-encryption-sdk repositori aktif. GitHub

**Topics**
+ [

## Prasyarat
](#prerequisites-rust)
+ [

## Penginstalan
](#rust-installation)
+ [Contoh](rust-examples.md)

## Prasyarat
<a name="prerequisites-rust"></a>

Sebelum Anda menginstal AWS Encryption SDK untuk Rust, pastikan Anda memiliki prasyarat berikut.

**Instal Rust dan Cargo**  
Instal rilis stabil [Rust](https://www.rust-lang.org/) saat ini menggunakan [rustup](https://rustup.rs/).  
Untuk informasi lebih lanjut tentang mengunduh dan menginstal rustup, lihat [prosedur instalasi](https://doc.rust-lang.org/cargo/getting-started/installation.html) di The Cargo Book.

## Penginstalan
<a name="rust-installation"></a>

The AWS Encryption SDK for Rust tersedia sebagai [https://crates.io/crates/aws-esdk](https://crates.io/crates/aws-esdk)peti di Crates.io. Untuk detail tentang menginstal dan membangun AWS Encryption SDK untuk Rust, lihat [README.md di repositori](https://github.com/aws/aws-encryption-sdk/tree/mainline) di. aws-encryption-sdk GitHub

Anda dapat menginstal AWS Encryption SDK for Rust dengan cara berikut.

**Secara manual**  
Untuk menginstal AWS Encryption SDK for Rust, kloning atau unduh [aws-encryption-sdk](https://github.com/aws/aws-encryption-sdk/tree/mainline) GitHub repositori.

**Menggunakan Crates.io**  
Jalankan perintah Cargo berikut di direktori proyek Anda:  

```
cargo add aws-esdk
```
Atau tambahkan baris berikut ke Cargo.toml Anda:  

```
aws-esdk = "<version>"
```

# AWS Encryption SDK untuk kode contoh Rust
<a name="rust-examples"></a>

Contoh berikut menunjukkan pola pengkodean dasar yang Anda gunakan saat memprogram dengan AWS Encryption SDK for Rust. Secara khusus, Anda membuat instance perpustakaan AWS Encryption SDK dan penyedia materi. Kemudian, sebelum memanggil setiap metode, Anda membuat instance objek yang mendefinisikan input untuk metode tersebut.

Untuk contoh yang menunjukkan cara mengonfigurasi opsi di AWS Encryption SDK, seperti menentukan rangkaian algoritme alternatif dan membatasi kunci data terenkripsi, lihat [contoh Rust di repositori](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/) aktif. aws-encryption-sdk GitHub

## Mengenkripsi dan mendekripsi data di for Rust AWS Encryption SDK
<a name="rust-example-encrypt"></a>

Contoh ini menunjukkan pola dasar untuk mengenkripsi dan mendekripsi data. Ini mengenkripsi file kecil dengan kunci data yang dilindungi oleh satu kunci AWS KMS pembungkus.

**Langkah 1: Instantiate. AWS Encryption SDK**  
Anda akan menggunakan metode dalam AWS Encryption SDK untuk mengenkripsi dan mendekripsi data.  

```
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
```

**Langkah 2: Buat AWS KMS klien.**  

```
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
```

**Opsional: Buat konteks enkripsi Anda.**  

```
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
```

**Langkah 3: Buat instance perpustakaan penyedia materi.**  
Anda akan menggunakan metode di pustaka penyedia materi untuk membuat keyrings yang menentukan kunci mana yang melindungi data Anda.  

```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
```

**Langkah 4: Buat AWS KMS keyring.**  
Untuk membuat keyring, panggil metode keyring dengan objek input keyring. Contoh ini menggunakan `create_aws_kms_keyring()` metode dan menentukan satu kunci KMS.  

```
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;
```

**Langkah 5: Enkripsi plaintext.**  

```
let plaintext = example_data.as_bytes();

let encryption_response = esdk_client.encrypt()
    .plaintext(plaintext)
    .keyring(kms_keyring.clone())
    .encryption_context(encryption_context.clone())
    .send()
    .await?;

let ciphertext = encryption_response
                    .ciphertext
                    .expect("Unable to unwrap ciphertext from encryption response");
```

**Langkah 6: Dekripsi data terenkripsi Anda menggunakan keyring yang sama yang Anda gunakan pada enkripsi.**  

```
let decryption_response = esdk_client.decrypt()
    .ciphertext(ciphertext)
    .keyring(kms_keyring)
    // Provide the encryption context that was supplied to the encrypt method
    .encryption_context(encryption_context)
    .send()
    .await?;

let decrypted_plaintext = decryption_response
                            .plaintext
                            .expect("Unable to unwrap plaintext from decryption response");
```