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á.
# Proteção de dados no Amazon DocumentDB
O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) da AWS é aplicado à proteção de dados no Amazon DocumentDB (compatível com MongoDB). Conforme descrito nesse modelo, a AWS é responsável por proteger a infraestrutura global que executa toda a Nuvem AWS. Você é responsável por manter o controle sobre o conteúdo hospedado nessa infraestrutura. Você também é responsável pelas tarefas de configuração e gerenciamento de segurança dos Serviços da AWS que usa. Para obter mais informações sobre a privacidade de dados, consulte as [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/). Para obter mais informações sobre a proteção de dados na Europa, consulte a postagem do blog [AWS Shared Responsibility Model and RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no *Blog de segurança da AWS*.
Para fins de proteção de dados, recomendamos que você proteja as credenciais da Conta da AWS e configure as contas de usuário individuais com Centro de Identidade do AWS IAM ou AWS Identity and Access Management (IAM). Dessa maneira, cada usuário receberá apenas as permissões necessárias para cumprir suas obrigações de trabalho. Recomendamos também que você proteja seus dados das seguintes formas:
+ Use uma autenticação multifator (MFA) com cada conta.
+ Use SSL/TLS para se comunicar com os recursos da AWS. Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Configure os logs de API e atividade do usuário com AWS CloudTrail. Para obter informações sobre como usar as trilhas do CloudTrail para capturar atividades da AWS, consulte [Working with CloudTrail trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) no *Guia do usuário do AWS CloudTrail*.
+ Use as soluções de criptografia AWS, juntamente com todos os controles de segurança padrão em Serviços da AWS.
+ Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados sigilosos armazenados no Amazon S3.
+ Se você precisar de módulos criptográficos validados pelo FIPS 140-3 ao acessar a AWS por meio de uma interface de linha de comandos ou de uma API, use um endpoint do FIPS. Para obter mais informações sobre os endpoints FIPS disponíveis, consulte [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
É altamente recomendável que nunca sejam colocadas informações confidenciais ou sigilosas, como endereços de e-mail de clientes, em tags ou campos de formato livre, como um campo **Nome**. Isso também vale para o uso do Amazon DocumentDB ou de outros Serviços da AWS com o console, a API, a AWS CLI ou os AWS SDKs. Quaisquer dados inseridos em tags ou em campos de texto de formato livre usados para nomes podem ser usados para logs de faturamento ou de diagnóstico. Se você fornecer um URL para um servidor externo, é fortemente recomendável que não sejam incluídas informações de credenciais no URL para validar a solicitação nesse servidor.
**Topics**
+ [Criptografia em nível de campo do lado do cliente](field-level-encryption.md)
+ [Criptografar dados em repouso](encryption-at-rest.md)
+ [Criptografia de dados em trânsito](security.encryption.ssl.md)
+ [Gerenciamento de chaves](security.encryption.ssl.public-key.md)
# Criptografia em nível de campo do lado do cliente
A Field Level Encryption (FLE – Criptografia em nível de campo) do lado do cliente do Amazon DocumentDB permite que você criptografe dados confidenciais em aplicações clientes antes de serem transferidos para um cluster do Amazon DocumentDB. Os dados confidenciais permanecem criptografados quando armazenados e processados em um cluster e são descriptografados na aplicação cliente quando recuperados.
**Topics**
+ [Começar](#fle-getting-started)
+ [Consulta no FLE do lado do cliente](#fle-querying)
+ [Limitações](#fle-limitationa)
## Começar
A configuração inicial da FLE do lado do cliente no Amazon DocumentDB é um processo de quatro etapas que inclui a criação de uma chave de criptografia, a associação de um perfil à aplicação, a configuração da aplicação e a definição da operação CRUD com opções de criptografia.
**Topics**
+ [Etapa 1: criar as chaves de criptografia](#fle-step-create-key)
+ [Etapa 2: associar um perfil à aplicação](#fle-step-associate-role)
+ [Etapa 3: configurar a aplicação](#fle-step-config-app)
+ [Etapa 4: definir uma operação CRUD](#fle-step-crud-ops)
+ [Exemplo: arquivo de configuração de criptografia em nível de campo do lado do cliente](#fle-config-example)
### Etapa 1: criar as chaves de criptografia
Usando o AWS Key Management Service, crie uma chave simétrica que seja usada para criptografar e descriptografar o campo de dados confidenciais e forneça a ela as permissões de uso do IAM necessárias. O AWS KMS armazena a chave do cliente (CK) que é usada para criptografar chaves de dados (DKs). Recomendamos armazenar a chave do cliente no KMS para fortalecer sua postura de segurança. A chave de dados é a chave secundária que é armazenada em uma coleção do Amazon DocumentDB e é necessária para criptografar campos confidenciais antes de armazenar o documento no Amazon DocumentDB. A chave do cliente criptografa a chave de dados que, por sua vez, criptografa e descriptografa seus dados. Se estiver usando um cluster global, você poderá criar uma chave multirregional que pode ser usada por diferentes perfis de serviço em diferentes regiões.
Para obter mais informações sobre o AWS Key Management Service, inclusive como criar uma chave, consulte o [Guia do desenvolvedor do Key Management ServiceAWS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
### Etapa 2: associar um perfil à aplicação
Criar uma política do IAM com permissões para o AWS KMS. Essa política permite que as identidades do IAM às quais está associada obtenham e descriptografem a chave do KMS especificada no campo do recurso. Sua aplicação assume esse perfil do IAM para se autenticar com o AWS KMS.
A política deve ter a seguinte aparência:
```
{ "Effect": "Allow",
"Action": ["kms:Decrypt", "kms:Encrypt"],
"Resource": "Customer Key ARN"
}
```
### Etapa 3: configurar a aplicação
Até agora, você definiu uma chave do cliente em AWS KMS e criou um perfil do IAM e forneceu a ele as permissões corretas do IAM para acessar a chave do cliente. Importe os pacotes necessários.
```
import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
ClientEncryption)
```
```
# create a session object:
my_session = boto3.session.Session()
# get access_key and secret_key programmatically using get_frozen_credentials() method:
current_credentials = my_session.get_credentials().get_frozen_credentials()
```
1. Especifique 'aws' como tipo de provedor do KMS e insira as credenciais da sua conta que foram recuperadas na etapa anterior.
```
provider = "aws"
kms_providers = {
provider: {
"accessKeyId": current_credentials.access_key,
"secretAccessKey": current_credentials.secret_key
}
}
```
1. Especifique a chave do cliente que é usada para criptografar a chave de dados:
```
customer_key = {
“region”: “AWS region of the customer_key”,
“key”: “customer_key ARN”
}
key_vault_namespace = "encryption.dataKeys"
key_alt_name = 'TEST_DATA_KEY'
```
1. Configure o objeto do MongoClient:
```
client = MongoClient(connection_string)
coll = client.test.coll
coll.drop()
client_encryption = ClientEncryption(
kms_providers, # pass in the kms_providers variable from the previous step
key_vault_namespace = key_vault_namespace,
client,
coll.codec_options
)
```
1. Gere sua chave de dados:
```
data_key_id = client_encryption.create_data_key(provider,
customer_key,
key_alt_name = [key_alt_name])
```
1. Recupere sua chave de dados existente:
```
data_key = DataKey("aws",
master_key = customer_key)
key_id = data_key["_id"]
data_key_id = client[key_vault_namespace].find_one({"_id": key_id})
```
### Etapa 4: definir uma operação CRUD
Defina a operação CRUD com opções de criptografia.
1. Defina a coleção para gravar/ler/excluir um único documento:
```
coll = client.gameinfo.users
```
1. Criptografia explícita - criptografe campos e insira:
**nota**
É necessário fornecer exatamente um “key\$1id” ou “key\$1alt\$1name”.
```
encrypted_first_name = client_encryption.encrypt(
"Jane",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
encrypted_last_name = client_encryption.encrypt(
"Doe",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
encrypted_dob = client_encryption.encrypt(
"1990-01-01",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Random,
key_alt_name=data_key_id
)
coll.insert_one(
{"gamerTag": "jane_doe90",
"firstName": encrypted_first_name,
"lastName": encrypted_last_name,
"dateOfBirth":encrypted_dob,
"Favorite_games":["Halo","Age of Empires 2","Medal of Honor"]
})
```
### Exemplo: arquivo de configuração de criptografia em nível de campo do lado do cliente
No exemplo a seguir, substitua cada *espaço reservado para entrada do usuário* por suas próprias informações.
```
# import python packages:
import boto3
import json
import base64
from pymongo import MongoClient
from pymongo.encryption import (Algorithm,
ClientEncryption)
def main():
# create a session object:
my_session = boto3.session.Session()
# get aws_region from session object:
aws_region = my_session.region_name
# get access_key and secret_key programmatically using get_frozen_credentials() method:
current_credentials = my_session.get_credentials().get_frozen_credentials()
provider = "aws"
# define the kms_providers which is later used to create the Data Key:
kms_providers = {
provider: {
"accessKeyId": current_credentials.access_key,
"secretAccessKey": current_credentials.secret_key
}
}
# enter the kms key ARN. Replace the example ARN value.
kms_arn = "arn:aws:kms:us-east-1:123456789:key/abcd-efgh-ijkl-mnop"
customer_key = {
"region": aws_region,
"key":kms_arn
}
# secrets manager is used to strore and retrieve user credentials for connecting to an Amazon DocumentDB cluster.
# retrieve the secret using the secret name. Replace the example secret key.
secret_name = "/dev/secretKey"
docdb_credentials = json.loads(my_session.client(service_name = 'secretsmanager', region_name = "us-east-1").get_secret_value(SecretId = secret_name)['SecretString'])
connection_params = '/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false'
conn_str = 'mongodb://' + docdb_credentials["username"] + ':' + docdb_credentials["password"] + '@' + docdb_credentials["host"] + ':' + str(docdb_credentials["port"]) + connection_params
client = MongoClient(conn_str)
coll = client.test.coll
coll.drop()
# store the encryption data keys in a key vault collection (having naming convention as db.collection):
key_vault_namespace = "encryption.dataKeys"
key_vault_db_name, key_vault_coll_name = key_vault_namespace.split(".", 1)
# set up the key vault (key_vault_namespace) for this example:
key_vault = client[key_vault_db_name][key_vault_coll_name]
key_vault.drop()
key_vault.create_index("keyAltNames", unique=True)
client_encryption = ClientEncryption(
kms_providers,
key_vault_namespace,
client,
coll.codec_options)
# create a new data key for the encrypted field:
data_key_id = client_encryption.create_data_key(provider, master_key=customer_key, key_alt_names=["some_key_alt_name"], key_material = None)
# explicitly encrypt a field:
encrypted_first_name = client_encryption.encrypt(
"Jane",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_id=data_key_id
)
coll.insert_one(
{"gamerTag": "jane_doe90",
"firstName": encrypted_first_name
})
doc = coll.find_one()
print('Encrypted document: %s' % (doc,))
# explicitly decrypt the field:
doc["encryptedField"] = client_encryption.decrypt(doc["encryptedField"])
print('Decrypted document: %s' % (doc,))
# cleanup resources:
client_encryption.close()
client.close()
if __name__ == "__main__":
main()
```
## Consulta no FLE do lado do cliente
O Amazon DocumentDB é compatível com consultas de igualdade de pontos com FLE do lado do cliente. Consultas de desigualdade e comparação podem retornar resultados imprecisos. As operações de leitura e gravação podem ter um comportamento inesperado ou incorreto em comparação com a emissão da mesma operação em relação ao valor descriptografado.
Por exemplo, para consultar filtros para documentos em que a pontuação do jogador é maior que 500:
```
db.users.find( {
"gamerscore" : { $gt : 500 }
})
```
O cliente usa um método de criptografia explícito para criptografar o valor da consulta:
```
encrypted_gamerscore_filter = client_encryption.encrypt(
500,
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
db.users.find( {
"gamerscore" : { $gt : encrypted_gamerscore_filter }
} )
```
na operação de busca, o Amazon DocumentDB compara o valor criptografado de 500 com os valores de campo criptografados armazenados em cada documento usando a verificação maior que a desigualdade. A verificação de desigualdade na operação de busca pode retornar um resultado diferente quando executada usando dados e valores descriptografados, mesmo que a operação tenha gerado resultados com êxito.
## Limitações
As limitações a seguir se aplicam à criptografia em nível de campo do lado do cliente do Amazon DocumentDB:
+ O Amazon DocumentDB é compatível apenas com consultas de igualdade de pontos. Consultas de desigualdade e comparação podem retornar resultados imprecisos. As operações de leitura e gravação podem ter um comportamento inesperado ou incorreto em comparação com a emissão da mesma operação em relação ao valor descriptografado. Para consultar filtros para documentos em que a pontuação do jogador é maior que 500.
```
db.users.find( {
"gamerscore" : { $gt : 500 }
})
```
O cliente usa um método explícito de criptografia para criptografar o valor da consulta.
```
encrypted_gamerscore_filter = client_encryption.encrypt(
500,
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name=data_key_id
)
db.users.find({
"gamerscore" : { $gt : encrypted_gamerscore_filter }
})
```
Na operação de busca, o Amazon DocumentDB compara o valor criptografado de 500 com os valores de campo criptografados armazenados em cada documento usando a verificação maior que a desigualdade. A verificação de desigualdade na operação de busca pode retornar um resultado diferente quando executada usando dados e valores descriptografados, mesmo que a operação tenha gerado resultados com êxito.
+ O Amazon DocumentDB não é compatível com a FLE explícita do lado do cliente a partir do Mongo Shell. No entanto, o atributo funciona com qualquer um dos nossos drivers compatíveis.
# Criptografar dados em repouso do Amazon DocumentDB
**nota**
AWS KMS está substituindo o termo *chave mestre do cliente (CMK)* por *AWS KMS key* e *Chave KMS*. O conceito não mudou. Para evitar alterações interrompidas, o AWS KMS está mantendo algumas variações deste termo.
Você criptografa os dados em repouso em seu cluster do Amazon DocumentDB especificando a opção de criptografia de armazenamento ao criar o cluster. A criptografia de armazenamento é ativada em todo o cluster e é aplicada a todas as instâncias, incluindo a instância principal e todas as réplicas. Ela também é aplicada a volumes de armazenamento, dados, índices, logs, backups automatizados e snapshots do cluster.
O Amazon DocumentDB usa o Advanced Encryption Standard de 256 bits (AES-256) para criptografar seus dados usando chaves de criptografia armazenadas em AWS Key Management Service (AWS KMS). Ao usar um cluster Amazon DocumentDB com criptografia em repouso ativada, você não precisa modificar a lógica da aplicação ou a conexão do cliente. O Amazon DocumentDB lida de forma transparente com a descriptografia de seus dados com um impacto mínimo sobre o desempenho.
O Amazon DocumentDB integra-se ao AWS KMS e usa um método conhecido como criptografia envelopada para proteger seus dados. Quando um cluster do Amazon DocumentDB é criptografado com um AWS KMS, o Amazon DocumentDB solicita ao AWS KMS o uso da sua chave KMS para [gerar uma chave de dados de texto cifrado](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) para criptografar o volume de armazenamento. A chave de dados de texto cifrado é criptografada usando a chave KMS definida e armazenada com os dados criptografados e os metadados de armazenamento. Quando o Amazon DocumentDB precisa acessar os dados criptografados, ele solicita que o AWS KMS descriptografe a chave de dados do texto cifrado usando a chave KMS e armazena em cache a chave de dados de texto simples na memória para criptografar e descriptografar dados de forma eficiente no volume de armazenamento.
O recurso de criptografia de armazenamento no Amazon DocumentDB está disponível para todos os tamanhos de instância compatíveis e em todas as Regiões da AWS nas quais o Amazon DocumentDB está disponível.
## Ativar a criptografia em repouso para um cluster do Amazon DocumentDB
É possível habilitar ou desabilitar a criptografia em repouso em um cluster do Amazon DocumentDB quando o cluster é provisionado usando Console de gerenciamento da AWS ou AWS Command Line Interface (AWS CLI). Os clusters criados usando o console têm a criptografia em repouso habilitada por padrão. Os clusters criados usando a AWS CLI têm a criptografia em repouso desabilitada por padrão. Portanto, você deve explicitamente habilitar a criptografia em repouso usando o parâmetro `--storage-encrypted`. Em ambos os casos, após o cluster ser criado, não é possível alterar a opção de criptografia em repouso.
O Amazon DocumentDB usa o AWS KMS para recuperar e gerenciar chaves de criptografia e definir as políticas que controlam como elas podem ser usadas. Se você não especificar um identificador de chaves do AWS KMS, o Amazon DocumentDB usará a chave KMS do serviço gerenciado da AWS padrão. O Amazon DocumentDB cria uma chave KMS separada para cada Região da AWS uma em sua Conta da AWS. Para obter mais informações, consulte [Conceitos do AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html).
Para começar a criar sua própria chave KMS, consulte [Conceitos básicos](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) no *Guia do Desenvolvedor da AWS Key Management Service*.
**Importante**
É necessário usar uma chave do KMS de criptografia simétrica para criptografar seu cluster, pois o Amazon DocumentDB só oferece suporte a chaves KMS de criptografia simétrica. Não use uma chave KMS assimétrica para tentar criptografar os dados nos clusters do Amazon DocumentDB. Para ter mais informações, consulte [Chaves assimétricas do AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html) no *Guia do desenvolvedor do AWS Key Management Service*.
Se o Amazon DocumentDB não puder mais obter acesso à chave de criptografia de um cluster por exemplo, quando o acesso a uma chave for revogado o cluster criptografado entrará em um estado de terminal. Nesse caso, só é possível restaurar o cluster a partir de um backup. Para o Amazon DocumentDB, os backups estão sempre habilitados para 1 dia.
Além disso, se você desativar a chave para um cluster criptografado do Amazon DocumentDB, acabará perdendo o acesso de leitura e gravação a esse cluster. Quando o Amazon DocumentDB encontra um cluster que é criptografado por uma chave à qual ele não tem acesso, ele coloca o cluster em um estado terminal. Nesse estado, o cluster deixa de estar disponível e o estado atual do banco de dados não pode ser recuperado. Para restaurar o cluster, você deve reativar o acesso à chave de criptografia para o Amazon DocumentDB e, depois, restaurar o cluster a partir de um backup.
**Importante**
Não é possível alterar a chave KMS para um cluster criptografado depois de já tê-lo criado. Certifique-se de determinar seus requisitos de chave de criptografia antes de criar seu cluster criptografado.
------
#### [ Using the Console de gerenciamento da AWS ]
Especifique a opção de criptografia em repouso ao criar um cluster. A criptografia em repouso é habilitada por padrão quando você cria um cluster usando o Console de gerenciamento da AWS. Não é possível alterá-la após criar o cluster.
**Para especificar a opção de criptografia em repouso ao criar o cluster**
1. Crie um cluster do Amazon DocumentDB conforme descrito na seção [Conceitos básicos](https://docs.aws.amazon.com/documentdb/latest/developerguide/connect-ec2.launch-cluster.html). No entanto, na etapa 6, não selecione **Criar cluster**.
1. Abaixo da seção **Autenticação**, escolha **Mostrar configurações avançadas**.
1. Role para baixo até a seção **Criptografia em repouso**.
1. Escolha a opção que deseja para a criptografia em repouso. Seja qual for a opção que escolher, não será possível alterá-la após criar o cluster.
+ Para criptografar dados em repouso nesse cluster, selecione **Habilitar criptografia**.
+ Caso não queira criptografar dados em repouso nesse cluster, selecione **Desabilitar criptografia**.
1. Escolha a chave primária que você deseja. O Amazon DocumentDB usa o AWS Key Management Service (AWS KMS) para recuperar e gerenciar chaves de criptografia e definir as políticas que controlam como elas podem ser usadas. Se você não especificar um identificador de chaves do AWS KMS, o Amazon DocumentDB usará a chave KMS do serviço gerenciado da AWS padrão. Para obter mais informações, consulte [Conceitos do AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html).
**nota**
Depois de criar um cluster criptografado, não é possível alterar a chave KMS para esse cluster. Certifique-se de determinar seus requisitos de chave de criptografia antes de criar seu cluster criptografado.
1. Complete as outras seções conforme o necessário e crie o cluster.
------
#### [ Using the AWS CLI ]
Para criptografar um cluster do Amazon DocumentDB usando a AWS CLI, execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html) e especifique a opção `--storage-encrypted`. Os clusters do Amazon DocumentDB criados usando o AWS CLI não habilitam a criptografia de armazenamento por padrão.
Veja a seguir um exemplo de como criar um cluster do Amazon DocumentDB com a criptografia de armazenamento ativada.
Nos exemplos a seguir, substitua cada *espaço reservado ao usuário* pelas informações do seu cluster.
**Example**
Para Linux, macOS ou Unix:
```
aws docdb create-db-cluster \
--db-cluster-identifier mydocdbcluster \
--port 27017 \
--engine docdb \
--master-username SampleUser1 \
--master-user-password primaryPassword \
--storage-encrypted
```
Para Windows:
```
aws docdb create-db-cluster ^
--db-cluster-identifier SampleUser1 ^
--port 27017 ^
--engine docdb ^
--master-username SampleUser1 ^
--master-user-password primaryPassword ^
--storage-encrypted
```
Quando você cria um cluster criptografado do Amazon DocumentDB, é possível especificar um identificador de chaves do AWS KMS, como no exemplo a seguir.
**Example**
Para Linux, macOS ou Unix:
```
aws docdb create-db-cluster \
--db-cluster-identifier SampleUser1 \
--port 27017 \
--engine docdb \
--master-username primaryUsername \
--master-user-password yourPrimaryPassword \
--storage-encrypted \
--kms-key-id key-arn-or-alias
```
Para Windows:
```
aws docdb create-db-cluster ^
--db-cluster-identifier SampleUser1 ^
--port 27017 ^
--engine docdb ^
--master-username SampleUser1 ^
--master-user-password primaryPassword ^
--storage-encrypted ^
--kms-key-id key-arn-or-alias
```
**nota**
Depois de criar um cluster criptografado, não é possível alterar a chave KMS para esse cluster. Certifique-se de determinar seus requisitos de chave de criptografia antes de criar seu cluster criptografado.
------
## Limitações para clusters criptografados do Amazon DocumentDB
As seguintes limitações existem para clusters criptografados do Amazon DocumentDB.
+ É possível habilitar ou desabilitar a criptografia em repouso para um cluster do Amazon DocumentDB somente no momento em que ele é criado, e não após a criação ser concluída. No entanto, é possível criar uma cópia criptografada de um cluster decriptografado criando um snapshot do cluster decriptografado e, em seguida, restaure o snapshot decriptografado como um novo cluster ao especificar a opção de criptografia em repouso.
Para obter mais informações, consulte os tópicos a seguir.
+ [Criação de um snapshot manual de cluster](backup_restore-create_manual_cluster_snapshot.md)
+ [Restauração de um snapshot de cluster](backup_restore-restore_from_snapshot.md)
+ [Cópia de snapshots de cluster do Amazon DocumentDB](backup_restore-copy_cluster_snapshot.md)
+ Os clusters do Amazon DocumentDB com criptografia de armazenamento habilitada não podem ser modificados para desabilitar a criptografia.
+ Todas as instâncias, os backups automatizados, os snapshots e os índices em um cluster do Amazon DocumentDB são criptografados com a mesma chave KMS.
# Criptografia de dados em trânsito
É possível usar o Transport Layer Security (TLS) para criptografar a conexão entre sua aplicação e um cluster do Amazon DocumentDB. Por padrão, a criptografia em trânsito é ativada para clusters recém-criados do Amazon DocumentDB. É possível desabilitá-la ao criar o cluster ou depois da criação ser concluída. Ao habilitar a criptografia em trânsito, as conexões seguras usando o TLS são obrigatórias para se conectar ao cluster. Para obter mais informações sobre como se conectar ao Amazon DocumentDB usando TLS, consulte [Conectar-se de forma programática ao Amazon DocumentDB](connect_programmatically.md).
## Gerenciar configurações de TLS de cluster do Amazon DocumentDB
A criptografia em trânsito para um cluster do Amazon DocumentDB é gerenciada por meio do parâmetro TLS em um [grupo de parâmetros de cluster](https://docs.aws.amazon.com/documentdb/latest/developerguide/cluster_parameter_groups.html). É possível gerenciar as configurações de TLS do seu cluster do Amazon DocumentDB usando o Console de gerenciamento da AWS ou a AWS Command Line Interface (AWS CLI). Consulte as seções a seguir para saber como verificar e modificar suas configurações de TLS atuais.
------
#### [ Using the Console de gerenciamento da AWS ]
Para gerenciar a criptografia usando TLS e o , como identificar grupos de parâmetros, verificar o valor de TLS e fazer as modificações necessárias, use as etapas a seguir.
**nota**
A menos que você especifique de outra forma ao criar o cluster, ele será criado com o grupo de parâmetros de cluster padrão. Os parâmetros no grupo de parâmetros de cluster `default` não podem ser modificados (por exemplo, `tls` habilitado/desabilitado). Portanto, se o cluster estiver usando um grupo de parâmetros de cluster `default`, será necessário modificar o cluster para usar um grupo de parâmetros de cluster que não seja padrão. Primeiro, será necessário criar um grupo de parâmetros de cluster personalizado. Para obter mais informações, consulte [Criando grupos de parâmetros de cluster do Amazon DocumentDB](cluster_parameter_groups-create.md).
1. **Determine o grupo de parâmetros de cluster usado pelo cluster.**
1. Abra o console do Amazon DocumentDB em [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. No painel de navegação, escolha **Clusters**.
**dica**
Caso não visualize o painel de navegação à esquerda da tela, selecione o ícone do menu (![\[Hamburger menu icon with three horizontal lines.\]](http://docs.aws.amazon.com/pt_br/documentdb/latest/developerguide/images/docdb-menu-icon.png)) no canto superior esquerdo da página.
1. Observe que na caixa de navegação **Clusters**, a coluna **Identificador do cluster** mostra clusters e instâncias. As instâncias estão listadas abaixo dos clusters. Veja o snapshot abaixo para referência.
![\[Imagem da caixa de navegação Clusters mostrando uma lista de links de cluster existentes e seus links de instância correspondentes.\]](http://docs.aws.amazon.com/pt_br/documentdb/latest/developerguide/images/clusters.png)
1. Escolha o cluster que você deseja usar.
1. Escolha a guia **Configuração** e role para baixo até a parte inferior dos **Detalhes do cluster** e localize o **Grupo de parâmetros do cluster.**. Anote o nome do grupo de parâmetros de cluster.
Se o nome do grupo de parâmetros do cluster para `default` (por exemplo `default.docdb3.6`), será necessário criar um grupo de parâmetros de cluster personalizado e defini-lo como o grupo de parâmetros do cluster antes de continuar. Para obter mais informações, consulte:
1. [Criando grupos de parâmetros de cluster do Amazon DocumentDB](cluster_parameter_groups-create.md) — Se você não tiver um grupo de parâmetros de cluster personalizado para usar, crie um.
1. [Modificar um cluster do Amazon DocumentDB](db-cluster-modify.md) — Modifique seu cluster para usar o grupo de parâmetros de cluster personalizado.
1. **Determine o valor atual do parâmetro `tls` do cluster.**
1. Abra o console do Amazon DocumentDB em [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. No painel de navegação, escolha **Grupos de parâmetros**.
1. Na lista de grupos de parâmetros, selecione o nome do grupo de parâmetros de cluster desejado.
1. Localize a seção **Parâmetros do cluster**. Na lista de parâmetros de cluster, localize a linha do parâmetro de cluster `tls`. Nesse momento, as quatro colunas a seguir são importantes:
+ **Nome do parâmetro de cluster** — O nome dos parâmetros do cluster. Para gerenciar TLS, você está interessado no parâmetro de cluster `tls`.
+ **Valores** — O valor atual de cada parâmetro do cluster.
+ **Valores permitidos** — Uma lista de valores que podem ser aplicados a um parâmetro de cluster.
+ **Aplicar tipo** — **estático** ou **dinâmico**. As alterações em parâmetros de cluster estáticos poderão ser aplicadas somente quando as instâncias forem reiniciadas. As alterações feitas em parâmetros de cluster dinâmicos podem ser aplicadas imediatamente ou quando as instâncias são reiniciadas.
1. **Modifique o valor do parâmetro `tls` do cluster.**
Se o valor de `tls` não for o que é necessário, modifique o valor para esse grupo de parâmetros de cluster. Para alterar o valor do parâmetro de cluster `tls`, continue na seção anterior seguindo estas etapas.
1. Escolha o botão à esquerda do nome do parâmetro de cluster (`tls`).
1. Escolha **Editar**.
1. Para alterar o valor de `tls`, na caixa de diálogo **Modificar `tls`**, escolha o valor desejado para o parâmetro do cluster na lista suspensa.
Os valores válidos são:
+ **desabilitado** — Desativa o TLS
+ **habilitado**: habilita as versões de 1.0 a 1.3 do TLS.
+ **fips-140-3** — Ativa o TLS com FIPS. O cluster só aceita conexões seguras de acordo com os requisitos da publicação 140-3 do Federal Information Processing Standards (FIPS). Isso só é suportado a partir dos clusters do Amazon DocumentDB 5.0 (versão do motor 3.0.3727) nas seguintes regiões: ca-central-1, us-west-2, us-east-1, us-east-2, us-gov-east-1, us-gov-west-1.
+ **tls1.2\$1**: habilita as versões 1.2 e posteriores do TLS. Só há suporte para isso a partir do Amazon DocumentDB 4.0 (versão de mecanismo 2.0.10980) e do Amazon DocumentDB (versão de mecanismo 3.0.11051).
+ **tls1.3\$1**: habilita as versões 1.3 e posteriores do TLS. Só há suporte para isso a partir do Amazon DocumentDB 4.0 (versão de mecanismo 2.0.10980) e do Amazon DocumentDB (versão de mecanismo 3.0.11051).
![\[Imagem de uma caixa de diálogo Modificar TLS específica de cluster.\]](http://docs.aws.amazon.com/pt_br/documentdb/latest/developerguide/images/modify-tls.png)
1. Escolha **Modificar parâmetro de cluster**. A alteração será aplicada a cada instância do cluster quando ela for reinicializada.
1. **Reinicie a instância do Amazon DocumentDB.**
Reinicialize cada instância do cluster para que a alteração seja aplicada a todas as instâncias no cluster.
1. Abra o console do Amazon DocumentDB em [https://console.aws.amazon.com/docdb](https://console.aws.amazon.com/docdb).
1. No painel de navegação, escolha **Instâncias**.
1. Para especificar a reinicialização de uma instância, localize a instância na lista de instâncias e escolha o botão à esquerda de seu nome.
1. Escolha **Ações** e **Reiniciar**. Confirme se deseja reinicializar, selecionando **Reiniciar**.
------
#### [ Using the AWS CLI ]
Para gerenciar a criptografia usando TLS e o AWS CLI, como identificar grupos de parâmetros, verificar o valor de TLS e fazer as modificações necessárias, use as etapas a seguir.
**nota**
A menos que você especifique de outra forma ao criar o cluster, ele será criado com o grupo de parâmetros de cluster padrão. Os parâmetros no grupo de parâmetros de cluster `default` não podem ser modificados (por exemplo, `tls` habilitado/desabilitado). Portanto, se o cluster estiver usando um grupo de parâmetros de cluster `default`, será necessário modificar o cluster para usar um grupo de parâmetros de cluster que não seja padrão. Pode ser necessário primeiro criar um grupo de parâmetros de cluster personalizado. Para obter mais informações, consulte [Criando grupos de parâmetros de cluster do Amazon DocumentDB](cluster_parameter_groups-create.md).
1. **Determine o grupo de parâmetros de cluster usado pelo cluster.**
Execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-clusters.html) com as opções a seguir:
+ `--db-cluster-identifier`
+ `--query`
No exemplo a seguir, substitua cada *espaço reservado ao usuário* pelas informações do seu cluster.
```
aws docdb describe-db-clusters \
--db-cluster-identifier mydocdbcluster \
--query 'DBClusters[*].[DBClusterIdentifier,DBClusterParameterGroup]'
```
A saída dessa operação é semelhante ao seguinte (formato JSON):
```
[
[
"mydocdbcluster",
"myparametergroup"
]
]
```
Se o nome do grupo de parâmetros do cluster for `default` (por exemplo, `default.docdb3.6`), será necessário ter um grupo de parâmetros de cluster personalizado e defini-lo como o grupo de parâmetros do cluster antes de continuar. Para obter mais informações, consulte os tópicos a seguir.
1. [Criando grupos de parâmetros de cluster do Amazon DocumentDB](cluster_parameter_groups-create.md) — Se você não tiver um grupo de parâmetros de cluster personalizado para usar, crie um.
1. [Modificar um cluster do Amazon DocumentDB](db-cluster-modify.md) — Modifique seu cluster para usar o grupo de parâmetros de cluster personalizado.
1. **Determine o valor atual do parâmetro `tls` de cluster.**
Para obter mais informações sobre esse grupo de parâmetros de cluster, execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-cluster-parameters.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/describe-db-cluster-parameters.html) com as opções a seguir:
+ `--db-cluster-parameter-group-name`
+ `--query`
Limita a saída apenas aos campos de interesse: `ParameterName`, `ParameterValue`, `AllowedValues` e `ApplyType`.
No exemplo a seguir, substitua cada *espaço reservado ao usuário* pelas informações do seu cluster.
```
aws docdb describe-db-cluster-parameters \
--db-cluster-parameter-group-name myparametergroup \
--query 'Parameters[*].[ParameterName,ParameterValue,AllowedValues,ApplyType]'
```
A saída dessa operação é semelhante ao seguinte (formato JSON):
```
[
[
"audit_logs",
"disabled",
"enabled,disabled",
"dynamic"
],
[
"tls",
"disabled",
"disabled,enabled,fips-140-3,tls1.2+,tls1.3+",
"static"
],
[
"ttl_monitor",
"enabled",
"disabled,enabled",
"dynamic"
]
]
```
1. **Modifique o valor do parâmetro `tls` do cluster.**
Se o valor de `tls` for o que ele precisa ser, modifique seu valor para este grupo de parâmetros de cluster. Para alterar o valor do parâmetro de cluster `tls`, execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/modify-db-cluster-parameter-group.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/modify-db-cluster-parameter-group.html) com as opções a seguir:
+ `--db-cluster-parameter-group-name` — Obrigatório. O nome do grupo de parâmetros de cluster a ser modificado. Não pode ser um grupo de parâmetros de cluster `default.*`.
+ `--parameters` — Obrigatório. Uma lista de parâmetros do grupo de parâmetros de cluster para modificar.
+ `ParameterName` — Obrigatório. O nome do parâmetro do cluster a ser modificado.
+ `ParameterValue` — Obrigatório. O novo valor desse parâmetro de cluster. Deve ser um dos `AllowedValues` do parâmetro de cluster.
+ `enabled`: o cluster aceita conexões seguras usando TLS versões de 1.0 a 1.3.
+ `disabled` — O cluster não aceita conexões seguras usando o TLS.
+ `fips-140-3`— O cluster só aceita conexões seguras de acordo com os requisitos da publicação 140-3 do Federal Information Processing Standards (FIPS). Isso só tem suporte a partir dos clusters do Amazon DocumentDB 5.0 (versão do motor 3.0.3727) nas seguintes regiões: ca-central-1, us-west-2, us-east-1, us-east-2, us-gov-east-1, us-gov-west-1.
+ `tls1.2+`: o cluster aceita conexões seguras usando TLS versões 1.2 e posteriores Só há suporte para isso a partir do Amazon DocumentDB 4.0 (versão de mecanismo 2.0.10980) e do Amazon DocumentDB 5.0 (versão de mecanismo 3.0.11051).
+ `tls1.3+`: o cluster aceita conexões seguras usando TLS versões 1.3 e posteriores Só há suporte para isso a partir do Amazon DocumentDB 4.0 (versão de mecanismo 2.0.10980) e do Amazon DocumentDB 5.0 (versão de mecanismo 3.0.11051).
+ `ApplyMethod` — Quando essa modificação deve ser aplicada. Para parâmetros de cluster estáticos, como `tle`, esse valor deve ser `pending-reboot`.
+ `pending-reboot` — A alteração é aplicada a uma instância somente depois de ser reinicializada. É necessário reinicializar cada instância de cluster individualmente para que essa mudança ocorra em todas as instâncias do cluster.
Nos exemplos a seguir, substitua cada *espaço reservado ao usuário* pelas informações do seu cluster.
O código a seguir *desabilita* o `tls`, aplicando a alteração a cada instância quando ela for reinicializada.
```
aws docdb modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name myparametergroup \
--parameters "ParameterName=tls,ParameterValue=disabled,ApplyMethod=pending-reboot"
```
O código a seguir *habilita* o `tls` (versões de 1.0 a 1.3), aplicando a alteração a cada instância quando ela é reinicializada.
```
aws docdb modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name myparametergroup \
--parameters "ParameterName=tls,ParameterValue=enabled,ApplyMethod=pending-reboot"
```
O código a seguir *habilita* o TLS com `fips-140-3`, aplicando a alteração a cada instância quando ela é reinicializada.
```
aws docdb modify-db-cluster-parameter-group \
‐‐db-cluster-parameter-group-name myparametergroup2 \
‐‐parameters "ParameterName=tls,ParameterValue=fips-140-3,ApplyMethod=pending-reboot"
```
A saída dessa operação é semelhante ao seguinte (formato JSON):
```
{
"DBClusterParameterGroupName": "myparametergroup"
}
```
1. **Reinicialize sua instância do Amazon DocumentDB.**
Reinicialize cada instância do cluster para que a alteração seja aplicada a todas as instâncias no cluster. Para reinicializar uma instância do Amazon DocumentDB, execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/reboot-db-instance.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/docdb/reboot-db-instance.html) com a opção a seguir:
+ `--db-instance-identifier`
O código a seguir reinicializa a instância `mydocdbinstance`.
Nos exemplos a seguir, substitua cada *espaço reservado ao usuário* pelas informações do seu cluster.
**Example**
Para Linux, macOS ou Unix:
```
aws docdb reboot-db-instance \
--db-instance-identifier mydocdbinstance
```
Para Windows:
```
aws docdb reboot-db-instance ^
--db-instance-identifier mydocdbinstance
```
A saída dessa operação é semelhante ao seguinte (formato JSON):
```
{
"DBInstance": {
"AutoMinorVersionUpgrade": true,
"PubliclyAccessible": false,
"PreferredMaintenanceWindow": "fri:09:32-fri:10:02",
"PendingModifiedValues": {},
"DBInstanceStatus": "rebooting",
"DBSubnetGroup": {
"Subnets": [
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1a"
},
"SubnetIdentifier": "subnet-4e26d263"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1c"
},
"SubnetIdentifier": "subnet-afc329f4"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1e"
},
"SubnetIdentifier": "subnet-b3806e8f"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1d"
},
"SubnetIdentifier": "subnet-53ab3636"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1b"
},
"SubnetIdentifier": "subnet-991cb8d0"
},
{
"SubnetStatus": "Active",
"SubnetAvailabilityZone": {
"Name": "us-east-1f"
},
"SubnetIdentifier": "subnet-29ab1025"
}
],
"SubnetGroupStatus": "Complete",
"DBSubnetGroupDescription": "default",
"VpcId": "vpc-91280df6",
"DBSubnetGroupName": "default"
},
"PromotionTier": 2,
"DBInstanceClass": "db.r5.4xlarge",
"InstanceCreateTime": "2018-11-05T23:10:49.905Z",
"PreferredBackupWindow": "00:00-00:30",
"KmsKeyId": "arn:aws:kms:us-east-1:012345678901:key/0961325d-a50b-44d4-b6a0-a177d5ff730b",
"StorageEncrypted": true,
"VpcSecurityGroups": [
{
"Status": "active",
"VpcSecurityGroupId": "sg-77186e0d"
}
],
"EngineVersion": "3.6.0",
"DbiResourceId": "db-SAMPLERESOURCEID",
"DBInstanceIdentifier": "mydocdbinstance",
"Engine": "docdb",
"AvailabilityZone": "us-east-1a",
"DBInstanceArn": "arn:aws:rds:us-east-1:012345678901:db:sample-cluster-instance-00",
"BackupRetentionPeriod": 1,
"Endpoint": {
"Address": "mydocdbinstance.corcjozrlsfc.us-east-1.docdb.amazonaws.com",
"Port": 27017,
"HostedZoneId": "Z2R2ITUGPM61AM"
},
"DBClusterIdentifier": "mydocdbcluster"
}
}
```
Demora alguns minutos para sua instância reinicializar. É possível usar a instância somente quando seu status for *disponível*. É possível monitorar o status da instância usando o console ou a AWS CLI. Para obter mais informações, consulte [Monitoramento do status de uma instância do Amazon DocumentDB](monitoring_docdb-instance_status.md).
------
# Gerenciamento de chaves
O Amazon DocumentDB usa o AWS Key Management Service (AWS KMS) para recuperar e gerenciar chaves de criptografia. O AWS KMS combina hardware e software seguros e altamente disponíveis para fornecer um sistema de gerenciamento de chave com escalabilidade para a nuvem. utilizando o AWS KMS, é possível criar chaves de criptografia e definir as políticas que controlam como elas podem ser usadas. O AWS KMS é compatível com o AWS CloudTrail, o que possibilita a auditoria do uso de chaves para verificar se elas estão sendo usadas adequadamente.
As chaves do AWS KMS podem ser usadas em combinação com o Amazon DocumentDB e serviços compatíveis da AWS, como Amazon Simple Storage Service (Amazon S3),Amazon Relational Database Service (Amazon RDS), Amazon Elastic Block Store (Amazon EBS) e Amazon Redshift. Para obter uma lista de serviços compatíveis com o AWS KMS, consulte [Como os serviços da AWS usam o AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/service-integration.html) no *Guia do desenvolvedor do AWS Key Management Service*. Para obter informações sobre o AWS KMS, consulte [O que é o AWS Key Management Service?](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)