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 em Go
<a name="go-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 Go. Especificamente, você instancia a biblioteca AWS Encryption SDK e a biblioteca de fornecedores de materiais. Então, antes de chamar cada método, você instancia o objeto que define a entrada para o método.

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

## Criptografando e descriptografando dados no AWS Encryption SDK para Go
<a name="go-example-encrypt"></a>

Este exemplo mostra o padrão básico para criptografar e descriptografar dados. Ele criptografa uma pequena quantidade de dados com chaves de dados que são 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.  

```
import (
    "context"

    mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
    mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
    client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
    esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
    panic(err)
}
```

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

```
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})
```

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

```
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}
```

**Etapa 3: Instancie 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.  

```
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}
```

**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 `CreateAwsKmsKeyring` método e especifica uma chave KMS. A `kmsKeyId` variável representa o ARN da chave KMS que você fornece.  

```
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
    KmsClient: kmsClient,
    KmsKeyId:  kmsKeyId,
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
    panic(err)
}
```

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

```
res, err := encryptionClient.Encrypt(context.Background(), esdktypes.EncryptInput{
    Plaintext:         []byte(exampleText),
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}

ciphertext := res.Ciphertext
```

**Etapa 6: Descriptografe seus dados criptografados usando o mesmo chaveiro usado na criptografia.**  

```
decryptOutput, err := encryptionClient.Decrypt(context.Background(), esdktypes.DecryptInput{
    Ciphertext:        ciphertext,
    // Provide the encryption context that was supplied to the encrypt method
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}

decrypted := decryptOutput.Plaintext
```