As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# AWS Encryption SDK para código de exemplo de Rust
<a name="rust-examples"></a>

Os exemplos a seguir mostram os padrões básicos de codificação que você usa ao programar com o AWS Encryption SDK for Rust. Especificamente, você instancia a biblioteca AWS Encryption SDK e os fornecedores de materiais. Em seguida, antes de chamar cada método, você instancia o objeto que define a entrada para o método.

Para exemplos que mostram como configurar opções no AWS Encryption SDK, como especificar um conjunto alternativo de algoritmos e limitar chaves de dados criptografadas, consulte os [exemplos de Rust no aws-encryption-sdk repositório](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/) em. GitHub

## Criptografando e descriptografando dados no for Rust AWS Encryption SDK
<a name="rust-example-encrypt"></a>

Este exemplo mostra o padrão básico para criptografar e descriptografar dados. Ele criptografa um pequeno arquivo com chaves de dados protegidas por uma chave de AWS KMS empacotamento.

**Etapa 1: Instancie o. AWS Encryption SDK**  
Você usará os métodos do AWS Encryption SDK para criptografar e descriptografar dados.  

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

**Etapa 2: Crie um AWS KMS cliente.**  

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

**Opcional: crie seu contexto de criptografia.**  

```
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()),
]);
```

**Etapa 3: Instanciar a biblioteca de fornecedores de materiais.**  
Você usará os métodos na biblioteca de fornecedores de materiais para criar os tokens de autenticação que especificam quais chaves protegem seus dados.  

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

**Etapa 4: Crie um AWS KMS chaveiro.**  
Para criar o token de autenticação, chame o método do token de autenticação com o objeto de entrada do token de autenticação. Este exemplo usa o `create_aws_kms_keyring()` método e especifica uma chave KMS.  

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

**Etapa 5: criptografar o texto sem formatação.**  

```
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");
```

**Etapa 6: descriptografe seus dados criptografados usando o mesmo chaveiro que você usou na criptografia.**  

```
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");
```