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 Managed Streaming for Apache Kafka
O modelo de [responsabilidade AWS compartilhada O modelo](https://aws.amazon.com/compliance/shared-responsibility-model/) se aplica à proteção de dados no Amazon Managed Streaming for Apache Kafka. Conforme descrito neste modelo, AWS é responsável por proteger a infraestrutura global que executa todos os 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 saber mais sobre a privacidade de dados, consulte as [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/). Para saber mais 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 Conta da AWS as credenciais e configure usuários 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 AWS os recursos. Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Configure a API e o registro de atividades do usuário com AWS CloudTrail. Para obter informações sobre o uso de CloudTrail trilhas para capturar AWS atividades, consulte Como [trabalhar com CloudTrail trilhas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) no *Guia AWS CloudTrail do usuário*.
+ Use soluções de AWS criptografia, juntamente com todos os controles de segurança padrão Serviços da AWS.
+ Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados sensíveis armazenados no Amazon S3.
+ Se você precisar de módulos criptográficos validados pelo FIPS 140-3 ao acessar AWS por meio de uma interface de linha de comando ou de uma API, use um endpoint FIPS. Para saber mais 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 sensíveis, como endereços de e-mail de clientes, em tags ou campos de formato livre, como um campo **Nome**. Isso inclui quando você trabalha com o Amazon MSK ou outro Serviços da AWS usando o console, a API ou AWS SDKs. AWS CLI 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 do Amazon MSK](msk-encryption.md)
+ [Conceitos básicos sobre criptografia do Amazon MSK](msk-working-with-encryption.md)
+ [Use o Amazon MSK APIs com endpoints de interface VPC](privatelink-vpc-endpoints.md)
# Criptografia do Amazon MSK
O Amazon MSK fornece opções de criptografia de dados que você pode usar para atender a requisitos rigorosos de gerenciamento de dados. É necessário renovar a cada 13 meses os certificados que o Amazon MSK usa para criptografia. O Amazon MSK renova automaticamente esses certificados para todos os clusters. Os clusters de agentes Express permanecem no estado `ACTIVE` quando o Amazon MSK inicia a operação de atualização de certificado. Para clusters de agentes Standard, o Amazon MSK define o estado do cluster como `MAINTENANCE` quando inicia a operação de atualização de certificado. Quando a atualização é concluída, o estado é definido novamente como `ACTIVE`. Enquanto um cluster está na operação de atualização de certificado, você pode continuar a produzir e consumir dados, mas não pode executar nenhuma operação de atualização nele.
## Criptografia do Amazon MSK em repouso
O Amazon MSK se integra ao [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (KMS) para oferecer uma criptografia transparente no lado do servidor. O Amazon MSK sempre criptografa seus dados em repouso. Ao criar um cluster do MSK, você pode especificar a AWS KMS key que deseja que o Amazon MSK use para criptografar seus dados em repouso. Se você não especificar uma chave do KMS, o Amazon MSK criará uma [Chave gerenciada pela AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) para você e a usará em seu nome. Para ter mais informações sobre as chaves do KMS, consulte [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys) no *Guia do desenvolvedor do AWS Key Management Service *.
## Criptografia do Amazon MSK em trânsito
O Amazon MSK usa TLS 1.2. Por padrão, ele criptografa os dados em trânsito entre os agentes do seu cluster do MSK. É possível substituir esse padrão no momento de criação do cluster.
Para a comunicação entre clientes e agentes, é necessário especificar uma destas três configurações:
+ Permitir somente dados criptografados por TLS. Essa é a configuração padrão.
+ Permitir dados não criptografados e dados criptografados por TLS.
+ Permitir apenas dados não criptografados.
Os corretores do Amazon MSK usam certificados públicos AWS Certificate Manager . Portanto, qualquer armazenamento confiável que confie no Amazon Trust Services também confia nos agentes do Amazon MSK.
Embora seja altamente recomendável habilitar a criptografia em trânsito, isso pode acrescentar sobrecarga à CPU e alguns milissegundos de latência. Contudo, a maioria dos casos de uso não é afetada por essas diferenças, e a magnitude do impacto depende da configuração do cluster, dos clientes e do perfil de uso.
# Conceitos básicos sobre criptografia do Amazon MSK
Ao criar um cluster do MSK, você pode especificar configurações de criptografia no formato JSON. Veja um exemplo do a seguir:
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "arn:aws:kms:us-east-1:123456789012:key/abcdabcd-1234-abcd-1234-abcd123e8e8e"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Para `DataVolumeKMSKeyId`, é possível especificar uma [chave gerenciada pelo cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) ou a Chave gerenciada pela AWS para o MSK na sua conta (`alias/aws/kafka`). Se você não especificar`EncryptionAtRest`, o Amazon MSK ainda criptografa seus dados em repouso sob o. Chave gerenciada pela AWS Para determinar qual chave o cluster está usando, envie uma solicitação `GET` ou invoque a operação de API `DescribeCluster`.
Para `EncryptionInTransit`, o valor padrão de `InCluster` é verdadeiro, mas será possível defini-lo como falso se não quiser que o Amazon MSK criptografe seus dados conforme eles passam pelos agentes.
Para especificar o modo de criptografia para dados em trânsito entre clientes e agentes, defina `ClientBroker` como um dos três valores: `TLS`, `TLS_PLAINTEXT` ou `PLAINTEXT`.
**Topics**
+ [Especificar as configurações de criptografia ao criar um cluster do Amazon MSK](msk-working-with-encryption-cluster-create.md)
+ [Testar a criptografia TLS do Amazon MSK](msk-working-with-encryption-test-tls.md)
# Especificar as configurações de criptografia ao criar um cluster do Amazon MSK
Este processo descreve como especificar as configurações de criptografia ao criar um cluster do Amazon MSK.
**Especificar as configurações de criptografia ao criar um cluster**
1. Salve o conteúdo do exemplo anterior em um arquivo e dê ao arquivo qualquer nome que desejar. Por exemplo, nomeie-o como `encryption-settings.json`.
1. Execute o comando `create-cluster` e use a opção `encryption-info` para apontar para o arquivo onde você salvou a configuração JSON. Veja um exemplo do a seguir: *\$1YOUR MSK VERSION\$1*Substitua por uma versão que corresponda à versão do cliente Apache Kafka. Para obter informações sobre como encontrar a versão de cluster do MSK, consulte [Determinação da versão do cluster do MSK](create-topic.md#find-msk-cluster-version). Esteja ciente de que usar uma versão do cliente Apache Kafka que não seja igual à sua versão de cluster do MSK pode resultar em corrupção, perda e tempo de inatividade dos dados do Apache Kafka.
```
aws kafka create-cluster --cluster-name "ExampleClusterName" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --kafka-version "{YOUR MSK VERSION}" --number-of-broker-nodes 3
```
Veja a seguir um exemplo de uma resposta bem-sucedida após a execução desse comando.
```
{
"ClusterArn": "arn:aws:kafka:us-east-1:123456789012:cluster/SecondTLSTest/abcdabcd-1234-abcd-1234-abcd123e8e8e",
"ClusterName": "ExampleClusterName",
"State": "CREATING"
}
```
# Testar a criptografia TLS do Amazon MSK
Este processo descreve como testar a criptografia TLS no Amazon MSK.
**Como testar a criptografia por TLS**
1. Crie uma máquina de cliente seguindo as orientações em [Etapa 3: criar uma máquina cliente](create-client-machine.md).
1. Instale o Apache Kafka na máquina de cliente.
1. Neste exemplo, o armazenamento confiável da JVM para se comunicar com o cluster do MSK. Para fazer isso, crie primeiramente uma pasta chamada `/tmp` na máquina cliente. Depois, acesse a pasta `bin` da instalação do Apache Kafka e execute o comando a seguir. (Seu caminho da JVM pode ser diferente.)
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. Enquanto ainda estiver na pasta `bin` da instalação do Apache Kafka na máquina cliente, crie um arquivo de texto chamado `client.properties` com o conteúdo a seguir.
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka.client.truststore.jks
```
1. Execute o comando a seguir em uma máquina que tenha o AWS CLI instalado, *clusterARN* substituindo-o pelo ARN do seu cluster.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
Um resultado bem-sucedido tem a aparência a seguir. Salve este resultado porque você precisará dele na próxima etapa.
```
{
"BootstrapBrokerStringTls": "a-1.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-3.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-2.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123"
}
```
1. Execute o comando a seguir, *BootstrapBrokerStringTls* substituindo-o por um dos endpoints do broker que você obteve na etapa anterior.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringTls --producer.config client.properties --topic TLSTestTopic
```
1. Abra uma nova janela de comando e conecte-se à mesma máquina cliente. Depois, execute o comando a seguir para criar um consumidor de console.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringTls --consumer.config client.properties --topic TLSTestTopic
```
1. Na janela do produtor, digite uma mensagem de texto seguida de um retorno e procure a mesma mensagem na janela do consumidor. O Amazon MSK criptografou essa mensagem em trânsito.
Para obter mais informações sobre como configurar clientes do Apache Kafka para trabalhar com dados criptografados, consulte [Configurar clientes do Kafka](https://kafka.apache.org/documentation/#security_configclients).
# Use o Amazon MSK APIs com endpoints de interface VPC
Você pode usar uma interface VPC Endpoint, alimentada por AWS PrivateLink, para evitar que o tráfego entre sua Amazon VPC e Amazon MSK saia APIs da rede Amazon. Os VPC Endpoints de interface não exigem um gateway de internet, dispositivo NAT, conexão VPN ou conexão Direct AWS Connect. [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html)é uma AWS tecnologia que permite a comunicação privada entre AWS serviços usando uma interface de rede elástica com privacidade IPs em sua Amazon VPC. Para obter mais informações, consulte [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) e [Interface VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint) ().AWS PrivateLink
Seus aplicativos podem se conectar ao Amazon MSK Provisioned e ao MSK Connect usando. APIs AWS PrivateLink Para iniciar, crie um endpoint da VPC de interface para que o tráfego da API do Amazon MSK fluindo dos recursos de e para os seus recursos do Amazon VPC comece a fluir através do endpoint da VPC de interface. Os endpoints da VPC de interface habilitada para FIPS estão disponíveis para as regiões dos EUA. Para obter mais informações, consulte [Criar um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).
Usando esse recurso, seus clientes do Apache Kafka podem buscar dinamicamente as cadeias de conexão para se conectar aos recursos do MSK Provisioned ou do MSK Connect sem percorrer a Internet para recuperar as cadeias de conexão.
Ao criar um endpoint da VPC de interface, escolha um dos seguintes endpoints de nome de serviço:
**Para o MSK Provisioned:**
+ Os seguintes endpoints de nome de serviço não são mais compatíveis com novas conexões:
+ com.amazonaws.region.kafka
+ com.amazonaws.region.kafka-fips (habilitado para FIPS)
+ O serviço de endpoint Dualstack que suporta ambos IPv4 e o tráfego são: IPv6
+ aws.api.region.kafka-api
+ aws.api.region. kafka-api-fips (Habilitado para FIPS)
Para configurar os endpoints de pilha dupla, você deve seguir as diretrizes de endpoints de pilha [dupla](https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html) e FIPS.
Em que “region” é o nome da sua região. Escolha esse nome de serviço para trabalhar com o MSK APIs Provisioned compatível. Para obter mais informações, consulte [Operações na referência https://docs.aws.amazon.com/msk/](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) *1.0/api/*.
**Para o MSK Connect:**
+ com.amazonaws.region.kafkaconnect
Em que “region” é o nome da sua região. Escolha esse nome de serviço para trabalhar com o MSK Connect APIs compatível. Para obter mais informações, consulte [Ações](https://docs.aws.amazon.com/MSKC/latest/mskc/API_Operations.html) na *Referência de API do Amazon Connect*.
*Para obter mais informações, incluindo step-by-step instruções para criar um endpoint VPC de interface, consulte [Criação de um endpoint de interface no Guia](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).AWS PrivateLink *
## Controle o acesso aos VPC endpoints para Amazon MSK Provisioned ou MSK Connect APIs
As políticas de endpoint da VPC permitem que você controle o acesso anexando uma política a um endpoint da VPC ou usando campos adicionais em uma política anexada a um usuário, perfil ou grupo do IAM para restringir o acesso para ocorrer somente por meio do endpoint da VPC especificado. Use o exemplo de política apropriado para definir as permissões de acesso para o serviço do MSK Provisioned ou do MSK Connect.
Se você não associar uma política ao criar um endpoint, a Amazon VPC associará uma política padrão que permita o acesso total ao serviço. Uma política de endpoint não substitui as políticas do IAM nem as políticas fundamentadas na identidade e específicas do serviço. É uma política separada para controlar o acesso do endpoint ao serviço especificado.
Para obter mais informações, consulte [Controlar o acesso a serviços com endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) no *Guia do AWS PrivateLink *.
------
#### [ MSK Provisioned — VPC policy example ]
**Acesso somente leitura.**
Esse exemplo de política pode ser anexado a um endpoint da VPC. (Para obter mais informações, consulte Como controlar o acesso aos recursos da Amazon VPC). Ele restringe as ações a somente listar e a descrever operações por meio do endpoint da VPC ao qual está anexado.
```
{
"Statement": [
{
"Sid": "MSKReadOnly",
"Principal": "*",
"Action": [
"kafka:List*",
"kafka:Describe*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**MSK Provisioned — exemplo de política de endpoint da VPC**
Restringir acesso a um cluster específico do MSK
Esse exemplo de política pode ser anexado a um endpoint da VPC. Ele restringe o acesso a cluster específico do Kafka por meio do endpoint da VPC ao qual está anexado.
```
{
"Statement": [
{
"Sid": "AccessToSpecificCluster",
"Principal": "*",
"Action": "kafka:*",
"Effect": "Allow",
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/MyCluster"
}
]
}
```
------
#### [ MSK Connect — VPC endpoint policy example ]
**Listar conectores e criar um conector**
Veja a seguir um exemplo de política de endpoint para o MSK Connect. Essa política permite que a função especificada liste conectores e crie um conector.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "MSKConnectPermissions",
"Effect": "Allow",
"Action": [
"kafkaconnect:ListConnectors",
"kafkaconnect:CreateConnector"
],
"Resource": "*",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/MyMSKConnectExecutionRole"
]
}
}
]
}
```
**MSK Connect: exemplo de política de endpoint da VPC**
Permite somente solicitações de um endereço IP específico na VPC especificada
O exemplo a seguir mostra uma política que só permite a efetivação de solicitações provenientes de um endereço IP especificado na VPC estabelecida. Solicitações de outros endereços IP não são aceitas.
```
{
"Statement": [
{
"Action": "kafkaconnect:*",
"Effect": "Allow",
"Principal": "*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:VpcSourceIp": "192.0.2.123"
},
"StringEquals": {
"aws:SourceVpc": "vpc-555555555555"
}
}
}
]
}
```
------