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á.
# Segurança no Amazon MSK
A segurança na nuvem AWS é a maior prioridade. Como AWS cliente, você se beneficia de uma arquitetura de data center e rede criada para atender aos requisitos das organizações mais sensíveis à segurança.
A segurança é uma responsabilidade compartilhada entre você AWS e você. O [Modelo de Responsabilidade Compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isso como segurança *da* nuvem e segurança *na* nuvem:
+ **Segurança da nuvem** — AWS é responsável por proteger a infraestrutura que executa AWS os serviços na AWS nuvem. AWS também fornece serviços que você pode usar com segurança. Auditores terceirizados testam e verificam regularmente a eficácia de nossa segurança como parte dos Programas de Conformidade Programas de [AWS](https://aws.amazon.com/compliance/programs/) de . Para saber mais sobre os programas de conformidade aplicáveis ao Amazon Managed Streaming for Apache Kafka, consulte [Serviços da Amazon Web Services no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/).
+ **Segurança na nuvem** — Sua responsabilidade é determinada pelo AWS serviço que você usa. Você também é responsável por outros fatores, incluindo a confidencialidade de seus dados, os requisitos da sua empresa e as leis e normas aplicáveis.
Esta documentação ajuda você a entender como aplicar o modelo de responsabilidade compartilhada ao usar o Amazon MSK. Os tópicos a seguir mostram como configurar o Amazon MSK para atender aos seus objetivos de segurança e compatibilidade. Saiba também como usar outros serviços da Amazon Web Services que ajudam você a monitorar e proteger seus recursos do Amazon MSK.
**Topics**
+ [Proteção de dados no Amazon Managed Streaming for Apache Kafka](data-protection.md)
+ [Autenticação e autorização para Amazon MSK APIs](security-iam.md)
+ [Autenticação e autorização para o Apache Kafka APIs](kafka_apis_iam.md)
+ [Alterar o grupo de segurança do cluster no Amazon MSK](change-security-group.md)
+ [Controle o acesso aos ZooKeeper nós do Apache em seu cluster Amazon MSK](zookeeper-security.md)
+ [Validação de conformidade do Amazon Managed Streaming for Apache Kafka](MSK-compliance.md)
+ [Resiliência no Amazon Managed Streaming for Apache Kafka](disaster-recovery-resiliency.md)
+ [Segurança de infraestrutura no Amazon Managed Streaming for Apache Kafka](infrastructure-security.md)
# 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"
}
}
}
]
}
```
------
# Autenticação e autorização para Amazon MSK APIs
AWS Identity and Access Management (IAM) é uma ferramenta AWS service (Serviço da AWS) que ajuda o administrador a controlar com segurança o acesso aos AWS recursos. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (ter permissões) para utilizar os recursos do Amazon MSK. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.
**Topics**
+ [Como o Amazon MSK funciona com o IAM](security_iam_service-with-iam.md)
+ [Exemplos de política baseada em identidade do Amazon MSK](security_iam_id-based-policy-examples.md)
+ [Perfis vinculados ao serviço para o Amazon MSK](using-service-linked-roles.md)
+ [AWS políticas gerenciadas para o Amazon MSK](security-iam-awsmanpol.md)
+ [Solução de problemas de identidade e acesso do Amazon MKS](security_iam_troubleshoot.md)
# Como o Amazon MSK funciona com o IAM
Antes de usar o IAM para gerenciar o acesso ao Amazon MSK, você deve entender quais recursos do IAM estão disponíveis para uso com o Amazon MSK. Para obter uma visão de alto nível de como o Amazon MSK e outros AWS serviços funcionam com o IAM, consulte [AWS Serviços que funcionam com o IAM no Guia do](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) *usuário do IAM*.
**Topics**
+ [Políticas baseadas em identidade do Amazon MSK](security_iam_service-with-iam-id-based-policies.md)
+ [Políticas baseadas em recurso do Amazon MSK](security_iam_service-with-iam-resource-based-policies.md)
+ [Autorização baseada em tags do Amazon MSK](security_iam_service-with-iam-tags.md)
+ [Perfis do IAM para o Amazon MSK](security_iam_service-with-iam-roles.md)
# Políticas baseadas em identidade do Amazon MSK
Com as políticas baseadas em identidade do IAM, é possível especificar ações e recursos permitidos ou negados, assim como as condições sob as quais as ações são permitidas ou negadas. O Amazon MSK é compatível com ações, chaves de condição e recursos específicos. Para conhecer todos os elementos usados em uma política JSON, consulte [Referência de elementos de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *Guia do usuário do IAM*.
## Ações para políticas baseadas em identidade do Amazon MSK
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. Incluem ações em uma política para conceder permissões para executar a operação associada.
As ações de política no Amazon MSK usam o seguinte prefixo antes da ação: `kafka:`. Por exemplo, para conceder permissão a alguém para descrever um cluster do MSK com a operação de API `DescribeCluster` do Amazon MSK, inclua a ação `kafka:DescribeCluster` na política. As instruções de política devem incluir um elemento `Action` ou `NotAction`. O Amazon MSK define seu próprio conjunto de ações que descrevem as tarefas que você pode executar com esse serviço.
Observe que as ações de política para o tópico MSK APIs usam o `kafka-cluster` prefixo antes da ação, consulte o. [Semântica das ações e recursos da política de autorização do IAM](kafka-actions.md)
Para especificar várias ações em uma única instrução, separe-as com vírgulas, como segue:
```
"Action": ["kafka:action1", "kafka:action2"]
```
Você também pode especificar várias ações usando caracteres curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `Describe`, inclua a seguinte ação:
```
"Action": "kafka:Describe*"
```
Para ver uma lista de ações do Amazon MSK, consulte [Ações, recursos e chaves de condição do Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonmanagedstreamingforapachekafka.html) no *Guia do usuário do IAM*.
## Recursos para políticas baseadas em identidade do Amazon MSK
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento de política JSON `Resource` especifica o objeto ou os objetos aos quais a ação se aplica. Como prática recomendada, especifique um recurso usando seu [nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Para ações que não oferecem compatibilidade com permissões em nível de recurso, use um curinga (\$1) para indicar que a instrução se aplica a todos os recursos.
```
"Resource": "*"
```
O recurso de instância do Amazon MSK tem o seguinte ARN:
```
arn:${Partition}:kafka:${Region}:${Account}:cluster/${ClusterName}/${UUID}
```
Para obter mais informações sobre o formato de ARNs, consulte [Amazon Resource Names (ARNs) e AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Por exemplo, para especificar a instância `CustomerMessages` na instrução, use o seguinte ARN:
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/CustomerMessages/abcd1234-abcd-dcba-4321-a1b2abcd9f9f-2"
```
Para especificar todas as instâncias que pertencem a uma conta específica, use o caractere curinga (\$1):
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*"
```
Algumas ações do Amazon MSK, como as usadas para a criação de recursos, não podem ser executadas em um recurso específico. Nesses casos, é necessário utilizar o caractere curinga (\$1).
```
"Resource": "*"
```
Para especificar vários recursos em uma única instrução, separe-os ARNs com vírgulas.
```
"Resource": ["resource1", "resource2"]
```
*Para ver uma lista dos tipos de recursos do Amazon MSK e seus ARNs, consulte [Resources Defined by Amazon Managed Streaming for Apache](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-resources-for-iam-policies) Kafka no Guia do usuário do IAM.* Para saber com quais ações você pode especificar o ARN de cada recurso, consulte [Ações definidas pelo Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Chaves de condição para políticas baseadas em identidade do Amazon MSK
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição AWS globais, consulte as [chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
O Amazon MSK define seu próprio conjunto de chaves de condição e também é compatível com o uso de algumas chaves de condição globais. Para ver todas as chaves de condição AWS globais, consulte [Chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
Para ver uma lista das chaves de condição do Amazon MSK, consulte [Chaves de condição para o Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-policy-keys) no *Guia do usuário do IAM*. Para saber com quais ações e recursos você pode usar uma chave de condição, consulte [Ações definidas pelo Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Exemplos de políticas baseadas em identidade do Amazon MSK
Para visualizar exemplos de políticas baseadas em identidade do Amazon MSK, consulte [Exemplos de política baseada em identidade do Amazon MSK](security_iam_id-based-policy-examples.md).
# Políticas baseadas em recurso do Amazon MSK
O Amazon MSK é compatível com uma política de cluster (também conhecida como política baseada em recurso) para uso com clusters do Amazon MSK. Você pode usar uma política de cluster para definir quais entidades principais do IAM têm permissões entre contas para configurar a conectividade privada com seu cluster do Amazon MSK. Quando usada com a autenticação de cliente do IAM, você também pode usar a política de cluster para definir de modo granular as permissões do plano de dados do Kafka para os clientes conectados.
O tamanho máximo aceito para uma política de cluster é de 20 KB.
Para ver um exemplo de como configurar uma política de cluster, consulte [Etapa 2: anexar uma política de cluster ao cluster do MSK](mvpc-cluster-owner-action-policy.md).
# Autorização baseada em tags do Amazon MSK
É possível anexar tags a clusters do Amazon MSK. Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `kafka:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`. Para obter informações sobre a atribuição de tags a recursos do Amazon MSK, consulte [Marcar um cluster do Amazon MSK](msk-tagging.md).
Você só pode controlar o acesso ao cluster com a ajuda de tags. Para definir tags para grupos de consumidores e tópicos, você precisa adicionar uma declaração separada em suas políticas sem tags.
Para visualizar um exemplo de política baseada em identidades a fim de limitar o acesso a um cluster baseado nas tags desse cluster, consulte [Como acessar clusters do Amazon MSK com base em tags](security_iam_id-based-policy-examples-view-widget-tags.md).
Você pode usar condições em sua política baseada em identidade para controlar o acesso aos recursos do Amazon MSK com base em tags. O exemplo a seguir mostra como você pode criar uma política que permita que o usuário descreva o cluster, obtenha seus agentes de bootstrap, liste seus nós de agente, atualize-o e exclua-o. No entanto, essa política concede a permissão somente se a tag de cluster `Owner` tiver o valor do `username` do usuário. A segunda declaração na política a seguir permite acesso aos tópicos do cluster. A primeira declaração desta política não autoriza acesso a nenhum tópico.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/*"
]
}
]
}
```
------
# Perfis do IAM para o Amazon MSK
Um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma entidade dentro da sua conta da Amazon Web Services que tem permissões específicas.
## Usar credenciais temporárias com o Amazon MSK
É possível usar credenciais temporárias para fazer login com federação, assumir um perfil do IAM ou assumir um perfil entre contas. Você obtém credenciais de segurança temporárias chamando operações de AWS STS API, como [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)ou [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html).
A Amazon MSK é compatível com o uso de credenciais temporárias.
## Perfis vinculados ao serviço
Os [perfis vinculados a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) permitem que os serviços da Amazon Web Services acessem recursos em outros serviços para concluir uma ação em seu nome. Os perfis vinculados a serviço aparecem em sua conta do IAM e são de propriedade do serviço. Um administrador do pode visualizar, mas não pode editar as permissões para funções vinculadas ao serviço.
O Amazon ECS MSK é compatível com perfis vinculados a serviço. Para obter detalhes sobre como criar ou gerenciar perfis vinculados a serviço do Amazon MSK, consulte [Perfis vinculados ao serviço para o Amazon MSK](using-service-linked-roles.md).
# Exemplos de política baseada em identidade do Amazon MSK
Por padrão, usuários e perfis do IAM não têm permissão para executar ações de API do Amazon MSK. Um administrador deve criar as políticas do IAM que concedam aos usuários e aos perfis permissões para executar operações de API específicas nos recursos especificados que precisam. O administrador deve anexar essas políticas aos usuários ou grupos do IAM que exigem essas permissões.
Para saber como criar uma política baseada em identidade do IAM usando esses exemplos de documentos de política JSON, consulte [Criar políticas na guia JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) no *Guia do usuário do IAM*.
**Topics**
+ [Práticas recomendadas de política](security_iam_service-with-iam-policy-best-practices.md)
+ [Permitir que os usuários visualizem suas próprias permissões](security_iam_id-based-policy-examples-view-own-permissions.md)
+ [Acessar um cluster do Amazon MSK](security_iam_id-based-policy-examples-access-one-cluster.md)
+ [Como acessar clusters do Amazon MSK com base em tags](security_iam_id-based-policy-examples-view-widget-tags.md)
# Práticas recomendadas de política
As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir recursos do Amazon MSK em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas AWS gerenciadas e avance para as permissões de privilégios mínimos — Para começar a conceder permissões** aos seus usuários e cargas de trabalho, use as *políticas AWS gerenciadas* que concedem permissões para muitos casos de uso comuns. Eles estão disponíveis no seu Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo AWS cliente que sejam específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Você também pode usar condições para conceder acesso às ações de serviço se elas forem usadas por meio de uma ação específica AWS service (Serviço da AWS), como CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA**) — Se você tiver um cenário que exija usuários do IAM ou um usuário root, ative Conta da AWS a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.
Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
# Permitir que os usuários visualizem suas próprias permissões
Este exemplo mostra como criar uma política que permita que os usuários do IAM visualizem as políticas gerenciadas e em linha anexadas a sua identidade de usuário. Essa política inclui permissões para concluir essa ação no console ou programaticamente usando a API AWS CLI ou AWS .
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Acessar um cluster do Amazon MSK
Neste exemplo, você vai permitir que um usuário do IAM na sua conta da Amazon Web Services acesse um dos seus cluster, `purchaseQueriesCluster`. Esta política permite que o usuário descreva o cluster, obtenha seus agentes de bootstrap, liste seus nós de agente e o atualize.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"UpdateCluster",
"Effect":"Allow",
"Action":[
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*"
],
"Resource":"arn:aws:kafka:us-east-1:012345678012:cluster/purchaseQueriesCluster/abcdefab-1234-abcd-5678-cdef0123ab01-2"
}
]
}
```
------
# Como acessar clusters do Amazon MSK com base em tags
Você pode usar condições em sua política baseada em identidade para controlar o acesso aos recursos do Amazon MSK com base em tags. Este exemplo mostra como você pode criar uma política que permita que o usuário descreva o cluster, obtenha seus agentes de bootstrap, liste seus nós de agente, atualize-o e exclua-o. No entanto, a permissão será concedida somente se a tag de cluster `Owner` tiver o valor do nome desse usuário.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:012345678012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
}
]
}
```
------
É possível anexar essa política aos usuários do IAM na sua conta. Se um usuário chamado `richard-roe` tentar atualizar um cluster do MSK, o cluster deverá estar marcado como `Owner=richard-roe` ou `owner=richard-roe`. Caso contrário, ele terá o acesso negado. A chave da tag de condição `Owner` corresponde a `Owner` e a `owner` porque os nomes das chaves de condição não fazem distinção entre maiúsculas e minúsculas. Para obter mais informações, consulte [IAM JSON Policy Elements: Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) (Elementos da política JSON do IAM: Condição) no *Guia do usuário do IAM*.
# Perfis vinculados ao serviço para o Amazon MSK
O Amazon MSK usa funções [vinculadas a serviços AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) (IAM). Um perfil vinculado a serviço é um tipo especial de perfil do IAM vinculado diretamente ao Amazon MSK. As funções vinculadas ao serviço são predefinidas pelo Amazon MSK e incluem todas as permissões que o serviço exige para chamar outros AWS serviços em seu nome.
Um perfil vinculado a serviço facilita a configuração do Amazon MSK porque você não precisa adicionar as permissões necessárias manualmente. O Amazon MSK define as permissões dos perfis vinculados a serviço. A menos que definido de outra forma, somente o Amazon MSK pode assumir seus perfis. As permissões definidas incluem a política de confiança e a política de permissões, que não pode ser anexada a nenhuma outra entidade do IAM.
Para obter informações sobre outros serviços compatíveis com perfis vinculados a serviço, consulte [Serviços da Amazon Web Services compatíveis com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) e procure os serviços que exibem **Sim** na coluna **Perfil vinculado a serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço.
**Topics**
+ [Permissões de perfil vinculado ao serviço](slr-permissions.md)
+ [Criar um perfil vinculado ao serviço](create-slr.md)
+ [Editar um perfil vinculado ao serviço](edit-slr.md)
+ [Regiões suportadas por perfis vinculados a serviço do](slr-regions.md)
# Permissões de perfil vinculado a serviço para o Amazon MSK
O Amazon MSK usa o perfil vinculado a serviço chamado **AWSServiceRoleForKafka**. O Amazon MSK usa esse perfil para acessar seus recursos e realizar operações como:
+ `*NetworkInterface`: criar e gerenciar interfaces de rede na conta do cliente que tornem os agentes de cluster acessíveis aos clientes na VPC do cliente.
+ `*VpcEndpoints`— gerencie endpoints de VPC na conta do cliente que tornam os agentes de cluster acessíveis aos clientes que usam a VPC do cliente. AWS PrivateLink O Amazon MSK usa permissões para `DescribeVpcEndpoints`, `ModifyVpcEndpoint` e `DeleteVpcEndpoints`.
+ `secretsmanager`— gerencie as credenciais do cliente com AWS Secrets Manager.
+ `GetCertificateAuthorityCertificate`: recuperar o certificado para sua autoridade de certificação privada.
+ `*Ipv6Addresses`— atribua e cancele a atribuição de IPv6 endereços às interfaces de rede na conta do cliente para permitir a IPv6 conectividade dos clusters MSK.
+ `ModifyNetworkInterfaceAttribute`— modifique os atributos da interface de rede na conta do cliente para definir IPv6 as configurações de conectividade do cluster MSK.
Essa função vinculada ao serviço é anexada à seguinte política gerenciada: `KafkaServiceRolePolicy`. Para obter atualizações dessa política, consulte [KafkaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/KafkaServiceRolePolicy.html).
O perfil vinculado ao serviço AWSServiceRoleForKafka confia nos seguintes serviços para aceitar o perfil:
+ `kafka.amazonaws.com`
A política de permissões do perfil permite que o Amazon MSK execute as seguintes ações nos recursos.
Você deve configurar permissões para que uma entidade do IAM (por exemplo, um usuário, grupo ou função) crie, edite ou exclua um perfil vinculado a serviço. Para saber mais, consulte [Permissões de Função Vinculadas ao Serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) no *Guia do Usuário do IAM*.
# Criar um perfil vinculado ao serviço para o Amazon MSK
Não é necessário criar uma função vinculada ao serviço manualmente. Quando você cria um cluster do Amazon MSK na Console de gerenciamento da AWS, na ou na AWS API AWS CLI, o Amazon MSK cria a função vinculada ao serviço para você.
Se excluir esse perfil vinculado ao serviço e precisar criá-lo novamente, será possível usar esse mesmo processo para recriar o perfil em sua conta. Quando você cria um cluster do Amazon MSK, o Amazon MSK cria um perfil vinculado a serviço para você novamente.
# Editar um perfil vinculado ao serviço para o Amazon MSK
O Amazon MSK não permite que você edite o perfil vinculado a serviço do AWSServiceRoleForKafka. Depois que criar um perfil vinculado ao serviço, você não poderá alterar o nome do perfil, pois várias entidades podem fazer referência a ele. No entanto, será possível editar a descrição do perfil usando o IAM. Para saber mais, consulte [Editar uma função vinculada a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) no *Guia do usuário do IAM*.
# Regiões compatíveis com perfis vinculados a serviço do Amazon MSK
O Amazon MSK é compatível com perfis vinculados a serviço em todas as regiões nas quais o serviço esteja disponível. Para mais informações, consulte [Regiões e endpoints da AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS políticas gerenciadas para o Amazon MSK
Uma política AWS gerenciada é uma política autônoma criada e administrada por AWS. AWS as políticas gerenciadas são projetadas para fornecer permissões para muitos casos de uso comuns, para que você possa começar a atribuir permissões a usuários, grupos e funções.
Lembre-se de que as políticas AWS gerenciadas podem não conceder permissões de privilégio mínimo para seus casos de uso específicos porque elas estão disponíveis para uso de todos os AWS clientes. Recomendamos que você reduza ainda mais as permissões definindo as [ políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) que são específicas para seus casos de uso.
Você não pode alterar as permissões definidas nas políticas AWS gerenciadas. Se AWS atualizar as permissões definidas em uma política AWS gerenciada, a atualização afetará todas as identidades principais (usuários, grupos e funções) às quais a política está anexada. AWS é mais provável que atualize uma política AWS gerenciada quando uma nova AWS service (Serviço da AWS) é lançada ou novas operações de API são disponibilizadas para serviços existentes.
Para saber mais, consulte [AWS Políticas gerenciadas pela ](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
# AWS política gerenciada: Amazon MSKFull Access
Essa política concede permissões administrativas que permitem que a entidade principal tenha acesso total a todas as ações do Amazon MSK. As permissões nessa política são agrupadas da seguinte forma:
+ As permissões do Amazon MSK permitem todas as ações do Amazon MSK.
+ **Permissões do `Amazon EC2`**: nesta política são necessárias para validar os recursos passados em uma solicitação de API. Isso serve para garantir que o Amazon MSK seja capaz de usar adequadamente os recursos com um cluster. O restante das permissões do Amazon EC2 nesta política permitem que o Amazon MSK crie AWS os recursos necessários para possibilitar a conexão com seus clusters.
+ **Permissões do `AWS KMS`**: são usadas durante as chamadas de API para validar os recursos transmitidos em uma solicitação. Elas são necessárias para que o Amazon MSK consiga usar a chave transmitida com o cluster do Amazon MSK.
+ **Permissões do `CloudWatch Logs, Amazon S3, and Amazon Data Firehose`**: são necessárias para que o Amazon MSK possa garantir que os destinos de entrega de logs sejam acessíveis e válidos para o uso de logs do agente.
+ **Permissões do `IAM`**: são necessárias para que o Amazon MSK possa criar uma perfil vinculado ao serviço na conta e para permitir que você passe um perfil de execução de serviço para o Amazon MSK.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kafka:*",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeSecurityGroups",
"ec2:DescribeRouteTables",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcAttribute",
"kms:DescribeKey",
"kms:CreateGrant",
"logs:CreateLogDelivery",
"logs:GetLogDelivery",
"logs:UpdateLogDelivery",
"logs:DeleteLogDelivery",
"logs:ListLogDeliveries",
"logs:PutResourcePolicy",
"logs:DescribeResourcePolicies",
"logs:DescribeLogGroups",
"S3:GetBucketPolicy",
"firehose:TagDeliveryStream"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc/*",
"arn:*:ec2:*:*:subnet/*",
"arn:*:ec2:*:*:security-group/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc-endpoint/*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/AWSMSKManaged": "true"
},
"StringLike": {
"aws:RequestTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateVpcEndpoint"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteVpcEndpoints"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:ResourceTag/AWSMSKManaged": "true"
},
"StringLike": {
"ec2:ResourceTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/delivery.logs.amazonaws.com/AWSServiceRoleForLogDelivery*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "delivery.logs.amazonaws.com"
}
}
}
]
}
```
------
# AWS política gerenciada: Amazon MSKRead OnlyAccess
Essa política concede permissões de acesso somente leitura que permitem que os usuários visualizem informações no Amazon MSK. As entidades principais com essa política anexada não podem fazer nenhuma atualização ou excluir recursos existentes, nem criar novos recursos do Amazon MSK. Por exemplo, entidades principais com essas permissões podem visualizar a lista de clusters e configurações associadas à conta, mas não podem alterar a configuração ou as definições de nenhum cluster. As permissões nessa política são agrupadas da seguinte forma:
+ **Permissões do `Amazon MSK`**: permitem que você liste os recursos do Amazon MSK, descreva-os e obtenha informações sobre eles.
+ **`Amazon EC2`permissões** — são usadas para descrever a Amazon VPC, sub-redes, grupos de segurança e ENIs que estão associados a um cluster.
+ **Permissão do `AWS KMS`**: é usada para descrever a chave associada ao cluster.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"kafka:Describe*",
"kafka:List*",
"kafka:Get*",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"kms:DescribeKey"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
# AWS política gerenciada: KafkaServiceRolePolicy
Você não pode se vincular KafkaServiceRolePolicy às suas entidades do IAM. Essa política é anexada a um perfil vinculado a serviço que permite que o Amazon MSK realize ações como gerenciar endpoints da VPC (conectores) em clusters do MSK, gerenciar interfaces de rede e gerenciar credenciais de cluster com o AWS Secrets Manager. Para obter mais informações, consulte [Perfis vinculados ao serviço para o Amazon MSK](using-service-linked-roles.md).
A tabela a seguir descreve as atualizações da política KafkaServiceRolePolicy gerenciada desde que o Amazon MSK começou a rastrear as alterações.
| Alteração | Descrição | Data |
| --- | --- | --- |
| [IPv6 suporte de conectividade adicionado a KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy) — Atualização de uma política existente | O Amazon MSK adicionou permissões para KafkaServiceRolePolicy habilitar a IPv6 conectividade para clusters MSK. Essas permissões permitem que a Amazon MSK atribua e cancele a atribuição de IPv6 endereços às interfaces de rede e modifique os atributos da interface de rede na conta do cliente. | 17 de novembro de 2025 |
| [KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy) – atualização para uma política existente | O Amazon MSK adicionou permissões para compatibilidade com conectividade privada multi-VPC. | 8 de março de 2023 |
| O Amazon MSK passou a monitorar alterações | A Amazon MSK começou a monitorar as alterações na política KafkaServiceRolePolicy gerenciada. | 8 de março de 2023 |
# AWS política gerenciada: AWSMSKReplicator ExecutionRole
A política `AWSMSKReplicatorExecutionRole` concede permissões ao Replicador do Amazon MSK para replicar dados entre clusters do MSK. As permissões nessa política são agrupadas da seguinte forma:
+ **`cluster`**: concede ao Replicador do Amazon MSK permissões para se conectar ao cluster usando a autenticação do IAM. Também concede permissões para descrever e alterar o cluster.
+ **`topic`**: concede ao Replicador do Amazon MSK permissões para descrever, criar e alterar um tópico e alterar a configuração dinâmica dele.
+ **`consumer group`**: concede ao Replicador do Amazon MSK permissões para descrever e alterar grupos de consumidores, ler e gravar datas de um cluster do MSK e excluir tópicos internos criados pelo replicador.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ClusterPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:DescribeCluster",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:*:*:cluster/*"
]
},
{
"Sid": "TopicPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:AlterCluster"
],
"Resource": [
"arn:aws:kafka:*:*:topic/*/*"
]
},
{
"Sid": "GroupPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:*:*:group/*/*"
]
}
]
}
```
------
# Atualizações do Amazon MSK para políticas AWS gerenciadas
Veja detalhes sobre as atualizações das políticas AWS gerenciadas do Amazon MSK desde que esse serviço começou a rastrear essas alterações.
| Alteração | Descrição | Data |
| --- | --- | --- |
| [WriteDataIdempotently permissão adicionada a AWSMSKReplicator ExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md) — Atualização de uma política existente | O Amazon MSK adicionou WriteDataIdempotently permissão à AWSMSKReplicator ExecutionRole política para oferecer suporte à replicação de dados entre clusters MSK. | 12 de março de 2024 |
| [AWSMSKReplicatorExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md) – Nova política | O Amazon MSK adicionou uma AWSMSKReplicator ExecutionRole política para dar suporte ao Amazon MSK Replicator. | 4 de dezembro de 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Atualização de uma política existente | O Amazon MSK adicionou permissões para compatibilidade com o replicador do Amazon MSK. | 28 de setembro de 2023 |
| [KafkaServiceRolePolicy](security-iam-awsmanpol-KafkaServiceRolePolicy.md) – atualização para uma política existente | O Amazon MSK adicionou permissões para compatibilidade com conectividade privada multi-VPC. | 8 de março de 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Atualização de uma política existente | O Amazon MSK adicionou novas permissões do Amazon EC2 para possibilitar a conexão a um cluster. | 30 de novembro de 2021 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Atualização de uma política existente | O Amazon MSK adicionou uma nova permissão para permitir a descrição das tabelas de rotas do Amazon EC2. | 19 de novembro de 2021 |
| O Amazon MSK passou a monitorar alterações | A Amazon MSK começou a monitorar as mudanças em suas políticas AWS gerenciadas. | 19 de novembro de 2021 |
# Solução de problemas de identidade e acesso do Amazon MKS
Use as informações a seguir para ajudar a diagnosticar e corrigir problemas comuns que você pode encontrar ao trabalhar com o Amazon MSK e o IAM.
**Topics**
+ [Não tenho autorização para executar uma ação no Amazon MSK](#security_iam_troubleshoot-no-permissions)
## Não tenho autorização para executar uma ação no Amazon MSK
Se isso Console de gerenciamento da AWS indicar que você não está autorizado a realizar uma ação, entre em contato com o administrador para obter ajuda. Caso seu administrador seja a pessoa que forneceu suas credenciais de início de sessão.
O exemplo de erro a seguir ocorre quando o usuário do IAM `mateojackson` tenta usar o console para excluir um cluster, mas não tem permissões `kafka:DeleteCluster`.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: kafka:DeleteCluster on resource: purchaseQueriesCluster
```
Neste caso, Mateo pede ao administrador para atualizar suas políticas para permitir a ele o acesso ao recurso `purchaseQueriesCluster` usando a ação `kafka:DeleteCluster`.
# Autenticação e autorização para o Apache Kafka APIs
É possível usar o IAM para autenticar clientes e permitir ou proibir ações do Apache Kafka. Como alternativa, você pode usar o TLS ou SASL/SCRAM para autenticar clientes e o Apache Kafka ACLs para permitir ou negar ações.
Para obter informações sobre como controlar quem pode realizar [operações do Amazon MSK](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) em seu cluster, consulte [Autenticação e autorização para Amazon MSK APIs](security-iam.md).
**Topics**
+ [Controle de acesso do IAM](iam-access-control.md)
+ [Autenticação mútua de cliente TLS para o Amazon MSK](msk-authentication.md)
+ [Autenticação de credenciais de login com Secrets Manager AWS](msk-password.md)
+ [Apache Kafka ACLs](msk-acls.md)
# Controle de acesso do IAM
O controle de acesso do IAM para o Amazon MSK permite que você gerencie a autenticação e a autorização para seu cluster do MSK. Isso elimina a necessidade de usar um mecanismo para autenticação e outro para autorização. Por exemplo, quando um cliente tenta gravar em seu cluster, o Amazon MSK usa o IAM para verificar se esse cliente é uma identidade autenticada e também se ele está autorizado a produzir para seu cluster.
O controle de acesso do IAM funciona para clientes Java e não Java, incluindo clientes Kafka escritos em Python, Go e .NET. JavaScript O controle de acesso do IAM para clientes não Java está disponível para clusters do MSK com o Kafka versão 2.7.1 ou posterior.
Para viabilizar o controle de acesso do IAM, o Amazon MSK faz pequenas modificações no código-fonte do Apache Kafka. Essas modificações não causarão uma diferença perceptível na sua experiência com o Apache Kafka. O Amazon MSK registra eventos de acesso para que você possa auditá-los.
Você pode invocar o Apache Kafka ACL APIs para um cluster MSK que usa o controle de acesso do IAM. No entanto, o Apache Kafka não ACLs tem efeito na autorização de identidades do IAM. Você deve usar políticas do IAM para controlar o acesso de identidades do IAM.
**Considerações importantes**
Ao usar o controle de acesso do IAM com o cluster do MSK, lembre das importantes considerações a seguir:
O controle de acesso do IAM não se aplica aos ZooKeeper nós do Apache. Para obter informações sobre como você pode controlar o acesso a esses nós, consulte [Controle o acesso aos ZooKeeper nós do Apache em seu cluster Amazon MSK](zookeeper-security.md).
A configuração `allow.everyone.if.no.acl.found` do Apache Kafka não tem efeito se seu cluster usar o controle de acesso do IAM.
Você pode invocar o Apache Kafka ACL APIs para um cluster MSK que usa o controle de acesso do IAM. No entanto, o Apache Kafka não ACLs tem efeito na autorização de identidades do IAM. Você deve usar políticas do IAM para controlar o acesso de identidades do IAM.
# Funcionamento do controle de acesso do IAM para o Amazon MSK
Para usar o controle de acesso do IAM para o Amazon MSK, execute as etapas a seguir, descritas em mais detalhes nestes tópicos:
+ [Criar um cluster do Amazon MSK que use o controle de acesso do IAM](create-iam-access-control-cluster-in-console.md)
+ [Configurar clientes para controle de acesso do IAM](configure-clients-for-iam-access-control.md)
+ [Criar políticas de autorização para o perfil do IAM](create-iam-access-control-policies.md)
+ [Obter os agente de bootstrap para controle de acesso do IAM](get-bootstrap-brokers-for-iam.md)
# Criar um cluster do Amazon MSK que use o controle de acesso do IAM
Esta seção explica como você pode usar a Console de gerenciamento da AWS API ou a AWS CLI para criar um cluster Amazon MSK que usa o controle de acesso do IAM. Para obter informações sobre como ativar o controle de acesso do IAM para um cluster existente, consulte [Atualizar as configurações de segurança de um cluster do Amazon MSK](msk-update-security.md).
**Use o Console de gerenciamento da AWS para criar um cluster que usa o controle de acesso do IAM**
1. Abra o console do Amazon MSK em [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Selecione **Criar cluster**.
1. Escolha **Criar cluster com configurações personalizadas**.
1. Na seção **Autenticação**, escolha **Controle de acesso do IAM**.
1. Preencha o restante do fluxo de trabalho para criar um cluster.
**Use a API ou a AWS CLI para criar um cluster que usa o controle de acesso do IAM**
+ Para criar um cluster com o controle de acesso IAM ativado, use a [CreateCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters.html#CreateCluster)API ou o comando da CLI [create-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/create-cluster.html) e passe o seguinte JSON para o parâmetro:. `ClientAuthentication` `"ClientAuthentication": { "Sasl": { "Iam": { "Enabled": true } }`
# Configurar clientes para controle de acesso do IAM
Para permitir que os clientes se comuniquem com um cluster do MSK que use o controle de acesso do IAM, você pode usar um dos seguintes mecanismos:
+ Configuração de cliente não Java usando mecanismo SASL\$1OAUTHBEARER
+ Configuração do cliente Java usando SASL\$1OAUTHBEARER mecanismo ou AWS\$1MSK\$1IAM mecanismo
## Use o SASL\$1OAUTHBEARER mecanismo para configurar o IAM
1. Edite o arquivo de configuração client.properties usando o exemplo do cliente do Python Kafka abaixo. As alterações das configurações são semelhantes em outros idiomas.
```
from kafka import KafkaProducer
from kafka.errors import KafkaError
from kafka.sasl.oauth import AbstractTokenProvider
import socket
import time
from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
class MSKTokenProvider():
def token(self):
token, _ = MSKAuthTokenProvider.generate_auth_token('')
return token
tp = MSKTokenProvider()
producer = KafkaProducer(
bootstrap_servers='',
security_protocol='SASL_SSL',
sasl_mechanism='OAUTHBEARER',
sasl_oauth_token_provider=tp,
client_id=socket.gethostname(),
)
topic = ""
while True:
try:
inp=input(">")
producer.send(topic, inp.encode())
producer.flush()
print("Produced!")
except Exception:
print("Failed to send message:", e)
producer.close()
```
1. Baixe a biblioteca auxiliar para o idioma de configuração escolhido e siga as instruções na seção *Conceitos básicos* na página inicial desta biblioteca de idiomas.
+ JavaScript: [https://github.com/aws/aws-msk-iam-sasl-signer-js \$1getting -iniciado](https://github.com/aws/aws-msk-iam-sasl-signer-js#getting-started)
+ Python: [https://github.com/aws/aws-msk-iam-sasl-signer-python \$1get -started](https://github.com/aws/aws-msk-iam-sasl-signer-python#get-started)
+ Go: [https://github.com/aws/aws-msk-iam-sasl-signer-go](https://github.com/aws/aws-msk-iam-sasl-signer-go#getting-started) \$1getting -started
+ .NET: [https://github.com/aws/aws-msk-iam-sasl-signer-net](https://github.com/aws/aws-msk-iam-sasl-signer-net#getting-started) \$1getting -iniciado
+ JAVA: o SASL\$1OAUTHBEARER suporte para Java está disponível por meio do arquivo [https://github.com/aws/aws-msk-iam-auth/releases](https://github.com/aws/aws-msk-iam-auth/releases)jar
## Use o AWS\$1MSK\$1IAM mecanismo personalizado do MSK para configurar o IAM
1. Adicione o seguinte ao arquivo `client.properties`. **Substitua pelo caminho totalmente qualificado para o arquivo de armazenamento confiável no cliente.
**nota**
Se você não quiser usar um certificado específico, poderá remover `ssl.truststore.location=` do seu arquivo `client.properties`. Se você não especificar um valor para `ssl.truststore.location`, o processo Java usará o certificado padrão.
```
ssl.truststore.location=
security.protocol=SASL_SSL
sasl.mechanism=AWS_MSK_IAM
sasl.jaas.config=software.amazon.msk.auth.iam.IAMLoginModule required;
sasl.client.callback.handler.class=software.amazon.msk.auth.iam.IAMClientCallbackHandler
```
Para usar um perfil nomeado que você criou para AWS credenciais, inclua `awsProfileName="your profile name";` no arquivo de configuração do cliente. Para obter informações sobre perfis nomeados, consulte [Perfis nomeados](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html) na AWS CLI documentação.
1. Baixe o arquivo [aws-msk-iam-auth](https://github.com/aws/aws-msk-iam-auth/releases)JAR estável mais recente e coloque-o no caminho da classe. Se você usa o Maven, adicione a seguinte dependência, ajustando o número da versão conforme necessário:
```
software.amazon.msk
aws-msk-iam-auth
1.0.0
```
O plug-in do cliente do Amazon MSK é de código aberto sob a licença do Apache 2.0.
# Criar políticas de autorização para o perfil do IAM
Anexe uma política de autorização ao perfil do IAM correspondente ao cliente. Em uma política de autorização, você especifica quais ações permitir ou proibir para o perfil. Se seu cliente estiver em uma instância do Amazon EC2, associe a política de autorização ao perfil do IAM para essa instância do Amazon EC2. Como alternativa, você pode configurar seu cliente para usar um perfil nomeado e, em seguida, associar a política de autorização ao perfil desse perfil nomeado. [Configurar clientes para controle de acesso do IAM](configure-clients-for-iam-access-control.md) descreve como configurar um cliente para usar um perfil nomeado.
Para obter informações sobre como criar uma política do IAM, consulte [Criar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
Veja a seguir um exemplo de política de autorização para um cluster chamado MyTestCluster. Para entender a semântica dos elementos `Action` e `Resource`, consulte [Semântica das ações e recursos da política de autorização do IAM](kafka-actions.md).
**Importante**
As alterações que você faz em uma política do IAM são refletidas no IAM APIs e AWS CLI imediatamente. No entanto, a implementação da alteração da política pode levar um tempo considerável. Na maioria dos casos, as mudanças na política entram em vigor em menos de um minuto. Às vezes, as condições da rede podem aumentar o atraso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster"
],
"Resource": [
"arn:aws:kafka:us-east-1:111122223333:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/*"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:group/MyTestCluster/*"
]
}
]
}
```
------
Para saber como criar uma política com elementos de ação que correspondam aos casos de uso comuns do Apache Kafka, como produzir e consumir dados, consulte [Casos de uso comuns para a política de autorização de clientes](iam-access-control-use-cases.md).
[Para as versões 2.8.0 e superiores do Kafka, a **WriteDataIdempotently**permissão está obsoleta (KIP-679).](https://cwiki.apache.org/confluence/display/KAFKA/KIP-679%3A+Producer+will+enable+the+strongest+delivery+guarantee+by+default) `enable.idempotence = true` é usado por padrão. Portanto, para as versões 2.8.0 e superiores do Kafka, o IAM não oferece a mesma funcionalidade do Kafka. ACLs Não é possível atribuir `WriteDataIdempotently` a um tópico fornecendo apenas acesso `WriteData` a esse tópico. Isso não afeta o caso quando `WriteData` é fornecido para **TODOS** os tópicos. Nesse caso, `WriteDataIdempotently` é permitido. Isso se deve às diferenças na implementação da lógica do IAM e na forma como os Kafka ACLs são implementados. E escrever em um tópico de forma idempotente também requer acesso a `transactional-ids`.
Para contornar a questão, recomendamos o uso de uma política semelhante à política abaixo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/TestTopic",
"arn:aws:kafka:us-east-1:123456789012:transactional-id/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*"
]
}
]
}
```
------
Nesse caso, `WriteData` permite gravações em `TestTopic`, enquanto `WriteDataIdempotently` permite gravações idempotentes no cluster. Essa política também adiciona acesso aos recursos `transactional-id` que serão necessários.
Como `WriteDataIdempotently` é uma permissão no nível do cluster, você não pode usá-la no nível do tópico. Se `WriteDataIdempotently` estiver restrita ao nível do tópico, essa política não funcionará.
# Obter os agente de bootstrap para controle de acesso do IAM
Consulte [Obter os agentes de bootstrap para um cluster do Amazon MSK](msk-get-bootstrap-brokers.md).
# Semântica das ações e recursos da política de autorização do IAM
**nota**
Para clusters que executam o Apache Kafka versão 3.8 ou posterior, o controle de acesso do IAM é compatível com a WriteTxnMarkers API para encerrar transações. Para clusters que executam versões do Kafka anteriores à 3.8, o controle de acesso do IAM não oferece suporte a ações internas de cluster, incluindo. WriteTxnMarkers Para essas versões anteriores, para encerrar transações, use a autenticação SCRAM ou mTLS com a autenticação apropriada ACLs em vez da autenticação IAM.
Esta seção explica a semântica dos elementos de ação e recurso que você pode usar em uma política de autorização do IAM. Para visualizar um exemplo de política, consulte [Criar políticas de autorização para o perfil do IAM](create-iam-access-control-policies.md).
## Ações da política de autorização
A tabela a seguir lista as ações que você pode incluir em uma política de autorização ao usar o controle de acesso do IAM para o Amazon MSK. Ao incluir uma ação da coluna *Ação* da tabela em sua política de autorização, você também deve incluir as ações correspondentes da coluna *Ações obrigatórias*.
| Ação | Description | Ações necessárias | Recursos necessários | Aplicável a clusters com a tecnologia sem servidor |
| --- | --- | --- | --- | --- |
| kafka-cluster:Connect | Concede permissão para se conectar e se autenticar no cluster. | Nenhum | cluster | Sim |
| kafka-cluster:DescribeCluster | Concede permissão para descrever vários aspectos do cluster, equivalente à ACL DESCRIBE CLUSTER do Apache Kafka. | `kafka-cluster:Connect` | cluster | Sim |
| kafka-cluster:AlterCluster | Concede permissão para alterar vários aspectos do cluster, equivalente à ACL ALTER CLUSTER do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeCluster` | cluster | Não |
| kafka-cluster:DescribeClusterDynamicConfiguration | Concede permissão para descrever a configuração dinâmica de um cluster, equivalente à ACL DESCRIBE\$1CONFIGS CLUSTER do Apache Kafka. | `kafka-cluster:Connect` | cluster | Não |
| kafka-cluster:AlterClusterDynamicConfiguration | Concede permissão para alterar a configuração dinâmica de um cluster, equivalente à ACL ALTER\$1CONFIGS CLUSTER do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` | cluster | Não |
| kafka-cluster:WriteDataIdempotently | Concede permissão para gravar dados em um cluster de modo idempotente, equivalente à ACL IDEMPOTENT\$1WRITE CLUSTER do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:WriteData` | cluster | Sim |
| kafka-cluster:CreateTopic | Concede permissão para criar tópicos em um cluster, equivalente à CREATE ACL do Apache Kafka. CLUSTER/TOPIC | `kafka-cluster:Connect` | tópico | Sim |
| kafka-cluster:DescribeTopic | Concede permissão para descrever os tópicos de um cluster, equivalente à ACL DESCRIBE TOPIC do Apache Kafka. | `kafka-cluster:Connect` | tópico | Sim |
| kafka-cluster:AlterTopic | Concede permissão para alterar os tópicos de um cluster, equivalente à ACL ALTER TOPIC do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tópico | Sim |
| kafka-cluster:DeleteTopic | Concede permissão para excluir tópicos de um cluster, equivalente à ACL DELETE TOPIC do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tópico | Sim |
| kafka-cluster:DescribeTopicDynamicConfiguration | Concede permissão para descrever a configuração dinâmica dos tópicos de um cluster, equivalente à ACL DESCRIBE\$1CONFIGS TOPIC do Apache Kafka. | `kafka-cluster:Connect` | tópico | Sim |
| kafka-cluster:AlterTopicDynamicConfiguration | Concede permissão para alterar a configuração dinâmica dos tópicos de um cluster, equivalente à ACL ALTER\$1CONFIGS TOPIC do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` | tópico | Sim |
| kafka-cluster:ReadData | Concede permissão para ler dados dos tópicos de um cluster, equivalente à ACL READ TOPIC do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterGroup` | tópico | Sim |
| kafka-cluster:WriteData | Concede permissão para gravar dados em tópicos de um cluster, equivalente a WRITE TOPIC ACL do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | tópico | Sim |
| kafka-cluster:DescribeGroup | Concede permissão para descrever os grupos de um cluster, equivalente à ACL DESCRIBE GROUP do Apache Kafka. | `kafka-cluster:Connect` | grupo | Sim |
| kafka-cluster:AlterGroup | Concede permissão para entrar em grupos de um cluster, equivalente à ACL READ GROUP do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | grupo | Sim |
| kafka-cluster:DeleteGroup | Concede permissão para excluir grupos de um cluster, equivalente à ACL DELETE GROUP do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | grupo | Sim |
| kafka-cluster:DescribeTransactionalId | Concede permissão para descrever transações IDs em um cluster, equivalente à ACL DESCRIBE TRANSACTIONAL\$1ID do Apache Kafka. | `kafka-cluster:Connect` | transactional-id | Sim |
| kafka-cluster:AlterTransactionalId | Concede permissão para alterar a transação IDs em um cluster, equivalente à ACL WRITE TRANSACTIONAL\$1ID do Apache Kafka. | `kafka-cluster:Connect` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:WriteData` | transactional-id | Sim |
Você pode usar o curinga asterisco (\$1) quantas vezes quiser em uma ação após o sinal de dois pontos. Veja os exemplos a seguir.
+ `kafka-cluster:*Topic` corresponde a `kafka-cluster:CreateTopic`, `kafka-cluster:DescribeTopic`, `kafka-cluster:AlterTopic` e `kafka-cluster:DeleteTopic`. Isso não inclui `kafka-cluster:DescribeTopicDynamicConfiguration` ou `kafka-cluster:AlterTopicDynamicConfiguration`.
+ `kafka-cluster:*` corresponde a todas as permissões.
## Recursos da política de autorização
A tabela a seguir mostra os quatro tipos de recurso que você pode usar em uma política de autorização ao usar o controle de acesso do IAM para o Amazon MSK. Você pode obter o Amazon Resource Name (ARN) do cluster no Console de gerenciamento da AWS ou usando a [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)API ou o comando [AWS CLI describe-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/describe-cluster.html). Em seguida, você pode usar o ARN do cluster para criar ID de tópico, grupo e transação. ARNs Para especificar um recurso em uma política de autorização, use o ARN desse recurso.
| Recurso | Formato ARN |
| --- | --- |
| Cluster | arn:aws:kafka: ::cluster//regionaccount-idcluster-namecluster-uuid |
| Tópico | ar:aws:kafka: ::topic///regionaccount-idcluster-namecluster-uuidtopic-name |
| Group (Grupo) | arn:aws:kafka: ::group///regionaccount-idcluster-namecluster-uuidgroup-name |
| ID transacional | arn:aws:kafka: ::transactional-id///regionaccount-idcluster-namecluster-uuidtransactional-id |
Você pode usar o curinga asterisco (\$1) quantas vezes quiser em qualquer lugar na parte do ARN que vem depois de `:cluster/`, `:topic/`, `:group/` e `:transactional-id/`. Veja a seguir alguns exemplos de como usar o curinga asterisco (\$1) para se referir a vários recursos:
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/*`: todos os tópicos em qualquer cluster nomeado MyTestCluster, independentemente do UUID do cluster.
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*_test`: todos os tópicos cujo nome termina com “\$1test” no cluster cujo nome é MyTestCluster e cujo UUID é abcd1234-0123-abcd-5678-1234abcd-1.
+ `arn:aws:kafka:us-east-1:0123456789012:transactional-id/MyTestCluster/*/5555abcd-1111-abcd-1234-abcd1234-1`: todas as transações cuja ID transacional é 5555abcd-1111-abcd-1234-abcd1234-1, em todas as encarnações de um cluster nomeado em sua conta. MyTestCluster Isso significa que, se você criar um cluster chamado MyTestCluster, excluí-lo e criar outro cluster com o mesmo nome, poderá usar esse ARN de recurso para representar a mesma ID de transação nos dois clusters. No entanto, o cluster excluído não estará acessível.
# Casos de uso comuns para a política de autorização de clientes
A primeira coluna na tabela a seguir mostra alguns casos de uso comuns. Para autorizar um cliente a executar um determinado caso de uso, inclua as ações necessárias para esse caso de uso na política de autorização do cliente e defina `Effect` como `Allow`.
Para obter informações sobre todas as ações que fazem parte do controle de acesso do IAM para o Amazon MSK, consulte [Semântica das ações e recursos da política de autorização do IAM](kafka-actions.md).
**nota**
As ações são negadas por padrão. Você deve permitir explicitamente todas as ações que deseja autorizar o cliente a executar.
****
| Caso de uso | Ações necessárias |
| --- | --- |
| Administrador | `kafka-cluster:*` |
| Criar um tópico | `kafka-cluster:Connect` `kafka-cluster:CreateTopic` |
| Produzir dados | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` |
| Consumir dados | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:DescribeGroup` `kafka-cluster:AlterGroup` `kafka-cluster:ReadData` |
| Produzir dados de modo idempotente | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:WriteDataIdempotently` |
| Produzir dados de modo transacional | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:AlterTransactionalId` |
| Descrever a configuração de um cluster | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` |
| Atualizar a configuração de um cluster | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` `kafka-cluster:AlterClusterDynamicConfiguration` |
| Descrever a configuração de um tópico | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` |
| Atualizar a configuração de um tópico | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` `kafka-cluster:AlterTopicDynamicConfiguration` |
| Alterar um tópico | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterTopic` |
# Autenticação mútua de cliente TLS para o Amazon MSK
Você pode habilitar a autenticação do cliente com TLS para conexões das aplicações aos agentes do Amazon MSK. Para usar a autenticação do cliente, é necessário ter um CA privada da AWS. Eles CA privada da AWS podem estar no Conta da AWS mesmo cluster ou em uma conta diferente. Para obter informações sobre CA privada da AWS s, consulte [Criando e gerenciando um CA privada da AWS](https://docs.aws.amazon.com/acm-pca/latest/userguide/create-CA.html).
O Amazon MSK não oferece suporte a listas de revogação de certificados (). CRLs Para controlar o acesso aos tópicos do cluster ou bloquear certificados comprometidos, use o Apache Kafka ACLs e grupos de segurança. AWS Para obter informações sobre como usar o Apache Kafka ACLs, consulte. [Apache Kafka ACLs](msk-acls.md)
**Topics**
+ [Criar um cluster do Amazon MSK compatível com a autenticação de cliente](msk-authentication-cluster.md)
+ [Configurar um cliente para usar a autenticação](msk-authentication-client.md)
+ [Produzir e consumir mensagens usando autenticação](msk-authentication-messages.md)
# Criar um cluster do Amazon MSK compatível com a autenticação de cliente
Este procedimento mostra como habilitar a autenticação do cliente usando um CA privada da AWS.
**nota**
É altamente recomendável usar o independente CA privada da AWS para cada cluster MSK ao usar o TLS mútuo para controlar o acesso. Isso garantirá que os certificados TLS assinados por sejam autenticados PCAs apenas com um único cluster MSK.
1. Crie um arquivo denominado `clientauthinfo.json` com os conteúdos a seguir. *Private-CA-ARN*Substitua pelo ARN do seu PCA.
```
{
"Tls": {
"CertificateAuthorityArnList": ["Private-CA-ARN"]
}
}
```
1. Crie um arquivo chamado `brokernodegroupinfo.json`, conforme descrito em [Crie um cluster Amazon MSK provisionado usando o AWS CLI](create-cluster-cli.md).
1. A autenticação de cliente exige que você também ative a criptografia em trânsito entre clientes e agentes. Crie um arquivo denominado `encryptioninfo.json` com os conteúdos a seguir. *KMS-Key-ARN*Substitua pelo ARN da sua chave KMS. É possível definir `ClientBroker` como `TLS` ou `TLS_PLAINTEXT`.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "KMS-Key-ARN"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Para obter mais informações sobre criptografia, consulte [Criptografia do Amazon MSK](msk-encryption.md).
1. Em uma máquina em que você tenha o AWS CLI instalado, execute o comando a seguir para criar um cluster com a autenticação e a criptografia em trânsito habilitadas. Salve o ARN do cluster fornecido na resposta.
```
aws kafka create-cluster --cluster-name "AuthenticationTest" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --client-authentication file://clientauthinfo.json --kafka-version "{YOUR KAFKA VERSION}" --number-of-broker-nodes 3
```
# Configurar um cliente para usar a autenticação
Este processo descreve como configurar uma instância do Amazon EC2 para ser usada como cliente para autenticação.
Este processo descreve como produzir e consumir mensagens usando a autenticação criando uma máquina cliente, criando um tópico e definindo as configurações de segurança necessárias.
1. Crie uma instância do Amazon EC2 para ser usada como uma máquina cliente. Para simplificar, crie essa instância na mesma VPC usada para o cluster. Consulte [Etapa 3: criar uma máquina cliente](create-client-machine.md) para obter um exemplo de como criar uma máquina de cliente.
1. Criar um tópico. Para obter um exemplo, consulte as instruções em [Etapa 4: criar um tópico no cluster do Amazon MSK](create-topic.md).
1. Em uma máquina em que você tem o AWS CLI instalado, execute o comando a seguir para obter os corretores de bootstrap do cluster. *Cluster-ARN*Substitua pelo ARN do seu cluster.
```
aws kafka get-bootstrap-brokers --cluster-arn Cluster-ARN
```
Salve a string associada ao `BootstrapBrokerStringTls` na resposta.
1. Na máquina de cliente, execute o comando a seguir para usar o armazenamento de confiança da JVM para criar o armazenamento de confiança do cliente. Se o caminho da JVM for diferente, ajuste o comando de acordo.
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts kafka.client.truststore.jks
```
1. Na máquina de cliente, execute o comando a seguir para criar uma chave privada para o cliente. Substitua *Distinguished-Name**Example-Alias*,*Your-Store-Pass*,, e *Your-Key-Pass* por cordas de sua escolha.
```
keytool -genkey -keystore kafka.client.keystore.jks -validity 300 -storepass Your-Store-Pass -keypass Your-Key-Pass -dname "CN=Distinguished-Name" -alias Example-Alias -storetype pkcs12 -keyalg rsa
```
1. Na máquina de cliente, execute o comando a seguir para criar uma solicitação de certificado com a chave privada criada na etapa anterior.
```
keytool -keystore kafka.client.keystore.jks -certreq -file client-cert-sign-request -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Abra o arquivo `client-cert-sign-request` e verifique se ele começa com `-----BEGIN CERTIFICATE REQUEST-----` e termina com `-----END CERTIFICATE REQUEST-----`. Se ele começar com `-----BEGIN NEW CERTIFICATE REQUEST-----`, exclua a palavra `NEW` (e o espaço único que vem após) do começo e do final do arquivo.
1. Em uma máquina em que você tenha o AWS CLI instalado, execute o comando a seguir para assinar sua solicitação de certificado. *Private-CA-ARN*Substitua pelo ARN do seu PCA. Será possível alterar o valor de validade se quiser. Aqui usamos 300 como exemplo.
```
aws acm-pca issue-certificate --certificate-authority-arn Private-CA-ARN --csr fileb://client-cert-sign-request --signing-algorithm "SHA256WITHRSA" --validity Value=300,Type="DAYS"
```
Salve o ARN do certificado fornecido na resposta.
**nota**
Para recuperar seu certificado de cliente, use o comando `acm-pca get-certificate` e especifique o ARN do certificado. Para obter mais informações, consulte [get-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/acm-pca/get-certificate.html) na *Referência de comandos da AWS CLI *.
1. Execute o comando a seguir para obter o certificado CA privada da AWS assinado para você. *Certificate-ARN*Substitua pelo ARN obtido da resposta ao comando anterior.
```
aws acm-pca get-certificate --certificate-authority-arn Private-CA-ARN --certificate-arn Certificate-ARN
```
1. Do resultado JSON obtido com a execução do comando anterior, copie as strings associadas a `Certificate` e `CertificateChain`. Cole essas duas sequências em um novo arquivo chamado signed-certificate-from-acm. Cole a string associada a `Certificate` primeiro, seguida pela string associada a `CertificateChain`. Substitua os caracteres `\n` por novas linhas. Veja a seguir a estrutura do arquivo depois que você colar o certificado e a cadeia de certificados nele.
```
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
```
1. Execute o comando a seguir na máquina cliente para adicionar esse certificado ao repositório de chaves para poder apresentá-lo ao falar com os agentes do MSK.
```
keytool -keystore kafka.client.keystore.jks -import -file signed-certificate-from-acm -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Crie um arquivo denominado `client.properties` com os conteúdos a seguir. Ajuste os locais do armazenamento de confiança e do repositório de chaves usando os caminhos onde salvou `kafka.client.truststore.jks`. Substitua os espaços reservados por sua versão do cliente Kafka. *\$1YOUR KAFKA VERSION\$1*
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.truststore.jks
ssl.keystore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.keystore.jks
ssl.keystore.password=Your-Store-Pass
ssl.key.password=Your-Key-Pass
```
# Produzir e consumir mensagens usando autenticação
Este processo descreve como produzir e consumir mensagens usando a autenticação.
1. Execute o comando a seguir para criar um tópico. O arquivo chamado `client.properties` é o que você criou no procedimento anterior.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBroker-String --replication-factor 3 --partitions 1 --topic ExampleTopic --command-config client.properties
```
1. Execute o comando a seguir para iniciar um produtor de console. O arquivo chamado `client.properties` é o que você criou no procedimento anterior.
```
/bin/kafka-console-producer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --producer.config client.properties
```
1. Em uma nova janela de comando na máquina de cliente, execute o comando a seguir para iniciar um consumidor de console.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --consumer.config client.properties
```
1. Digite mensagens na janela do produtor e observe-as aparecerem na janela do consumidor.
# Autenticação de credenciais de login com Secrets Manager AWS
Você pode controlar o acesso aos seus clusters do Amazon MSK usando credenciais de login que são armazenadas e protegidas usando o Secrets Manager. AWS Armazenar as credenciais de usuário no Secrets Manager reduz a sobrecarga da autenticação do cluster, como auditoria, atualização e rodízio de credenciais. O Secrets Manager também permite que você compartilhe credenciais de usuário entre clusters.
Depois que você associar um segredo a um cluster do MSK, o MSK sincronizará periodicamente os dados da credencial.
**Topics**
+ [Como a autenticação de credenciais de acesso funciona](msk-password-howitworks.md)
+ [Configurar a SASL/SCRAM autenticação para um cluster Amazon MSK](msk-password-tutorial.md)
+ [Trabalhar com usuários](msk-password-users.md)
+ [Limitações ao usar segredos do SCRAM](msk-password-limitations.md)
# Como a autenticação de credenciais de acesso funciona
A autenticação de credenciais de login para o Amazon MSK usa a autenticação SASL/SCRAM (Simple Authentication and Security Layer/Salted Challenge Response Mechanism). Para configurar a autenticação de credenciais de acesso para um cluster, você cria um recurso secreto no [AWS Secrets Manager](https://docs.aws.amazon.com//secretsmanager/?id=docs_gateway) e associa as credenciais de acesso a esse segredo.
O SASL/SCRAM está definido no [RFC 5802](https://tools.ietf.org/html/rfc5802). O SCRAM usa algoritmos de hash protegidos e não transmite credenciais em texto simples entre o cliente e o servidor.
**nota**
Quando você configura a SASL/SCRAM autenticação para seu cluster, o Amazon MSK ativa a criptografia TLS para todo o tráfego entre clientes e agentes.
# Configurar a SASL/SCRAM autenticação para um cluster Amazon MSK
Para configurar um segredo no AWS Secrets Manager, siga o tutorial [Criando e recuperando um segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html) no [Guia do usuário do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
Observe os seguintes requisitos ao criar um segredo para um cluster do Amazon MSK:
+ Escolha **Outros tipos de segredos (p. ex., chave de API)** para o tipo de segredo.
+ O nome do segredo deve começar com o prefixo **AmazonMSK\$1**.
+ Você deve usar uma AWS KMS chave personalizada existente ou criar uma nova AWS KMS chave personalizada para seu segredo. O Secrets Manager usa a AWS KMS chave padrão para um segredo por padrão.
**Importante**
Um segredo criado com a AWS KMS chave padrão não pode ser usado com um cluster Amazon MSK.
+ Seus dados de credencial de acesso devem estar no formato a seguir para que seja possível inserir pares de valor/chave usando a opção **Texto simples**.
```
{
"username": "alice",
"password": "alice-secret"
}
```
+ Registre o valor do ARN (nome do recurso da Amazon) do seu segredo.
+
**Importante**
Você não pode associar um segredo do Secrets Manager a um cluster que exceda os limites descritos em [Dimensione seu cluster adequadamente: número de partições por agente Standard](bestpractices.md#partitions-per-broker).
+ Se você usar o AWS CLI para criar o segredo, especifique um ID de chave ou ARN para o `kms-key-id` parâmetro. Não especifique um alias.
+ Para associar o segredo ao seu cluster, use o console Amazon MSK ou a [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)operação.
**Importante**
Quando você associa um segredo a um cluster, o Amazon MSK anexa uma política de recursos ao segredo, permitindo que seu cluster acesse e leia os valores secretos que você definiu. Você não deve modificar essa política de recursos. Isso pode impedir que seu cluster acesse seu segredo. Se você fizer alguma alteração na política de recursos de segredos e/ou na chave KMS usada para criptografia secreta, certifique-se de associar novamente os segredos ao seu cluster do MSK. Isso garantirá que seu cluster conseguirá continuar a acessar seu segredo.
O exemplo de entrada JSON a seguir para a operação `BatchAssociateScramSecret` associa um segredo a um cluster:
```
{
"clusterArn" : "arn:aws:kafka:us-west-2:0123456789019:cluster/SalesCluster/abcd1234-abcd-cafe-abab-9876543210ab-4",
"secretArnList": [
"arn:aws:secretsmanager:us-west-2:0123456789019:secret:AmazonMSK_MyClusterSecret"
]
}
```
# Como estabelecer conexão com o seu cluster usando credenciais de acesso
Após criar um segredo e associá-lo ao cluster, você poderá conectar o cliente ao cluster. O procedimento a seguir demonstra como conectar um cliente a um cluster que usa SASL/SCRAM autenticação. Também mostra como produzir e consumir a partir de um tópico de exemplo.
**Topics**
+ [Conectando um cliente ao cluster usando SASL/SCRAM autenticação](#w2aab9c13c29c17c13c11b9b7)
+ [Solução de problemas de conexão](#msk-password-tutorial-connect-troubleshooting)
## Conectando um cliente ao cluster usando SASL/SCRAM autenticação
1. Execute o comando a seguir em uma máquina que tenha sido AWS CLI instalada. *clusterARN*Substitua pelo ARN do seu cluster.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
No JSON resultante deste comando, salve o valor associado à string `BootstrapBrokerStringSaslScram`. Você usará esse valor em etapas subsequentes.
1. Em sua máquina cliente, crie um arquivo de configuração JAAS contendo as credenciais de usuário armazenadas em seu segredo. Por exemplo, para o usuário **alice**, crie um arquivo chamado `users_jaas.conf` com o conteúdo a seguir.
```
KafkaClient {
org.apache.kafka.common.security.scram.ScramLoginModule required
username="alice"
password="alice-secret";
};
```
1. Use o comando a seguir para exportar seu arquivo de configuração JAAS como um parâmetro de ambiente `KAFKA_OPTS`.
```
export KAFKA_OPTS=-Djava.security.auth.login.config=/users_jaas.conf
```
1. Crie um arquivo chamado `kafka.client.truststore.jks` em um diretório `/tmp`.
1. (Opcional) Use o comando a seguir para copiar o arquivo de armazenamento de chaves do JDK da sua pasta de `cacerts` do JVM para o arquivo `kafka.client.truststore.jks` que você criou na etapa anterior. *JDKFolder*Substitua pelo nome da pasta JDK na sua instância. Por exemplo, sua pasta do JDK pode ter o nome `java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64`.
```
cp /usr/lib/jvm/JDKFolder/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. No diretório `bin` da instalação do Apache Kafka, crie um arquivo de propriedades do cliente chamado `client_sasl.properties` com o conteúdo a seguir. Esse arquivo define o mecanismo e o protocolo SASL.
```
security.protocol=SASL_SSL
sasl.mechanism=SCRAM-SHA-512
```
1. Para criar um tópico de exemplo, execute o comando a seguir. *BootstrapBrokerStringSaslScram*Substitua pela string do bootstrap broker que você obteve na etapa 1 deste tópico.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBrokerStringSaslScram --command-config /client_sasl.properties --replication-factor 3 --partitions 1 --topic ExampleTopicName
```
1. Para produzir o tópico de exemplo que você criou, execute o seguinte comando em sua máquina cliente. *BootstrapBrokerStringSaslScram*Substitua pela string do bootstrap broker que você recuperou na etapa 1 deste tópico.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringSaslScram --topic ExampleTopicName --producer.config client_sasl.properties
```
1. Para consumir do tópico que você criou, execute o comando a seguir em sua máquina cliente. *BootstrapBrokerStringSaslScram*Substitua pela string do bootstrap broker que você obteve na etapa 1 deste tópico.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --from-beginning --consumer.config client_sasl.properties
```
## Solução de problemas de conexão
Ao executar comandos do cliente do Kafka, você pode encontrar erros de memória da pilha de Java, especialmente ao trabalhar com tópicos ou conjuntos de dados grandes. Esses erros ocorrem porque as ferramentas do Kafka são executadas como aplicações Java com configurações de memória padrão que podem ser insuficientes para sua workload.
Para resolver erros de `Out of Memory Java Heap`, você pode aumentar o tamanho da pilha de Java modificando a variável de ambiente `KAFKA_OPTS` para incluir configurações de memória.
O exemplo a seguir define o tamanho máximo da pilha como 1 GB (`-Xmx1G`). Você pode ajustar esse valor com base na memória e nos requisitos disponíveis do sistema.
```
export KAFKA_OPTS="-Djava.security.auth.login.config=/users_jaas.conf -Xmx1G"
```
Para consumir tópicos extensos, considere usar parâmetros baseados em tempo ou em deslocamento em vez de `--from-beginning` para limitar o uso de memória:
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --max-messages 1000 --consumer.config client_sasl.properties
```
# Trabalhar com usuários
**Criação de usuários**: você cria usuários como pares de valor/chave em seu segredo. Ao usar a opção **Texto simples** no console do Secrets Manager, você deve especificar os dados da credencial de login no formato a seguir.
```
{
"username": "alice",
"password": "alice-secret"
}
```
**Revogando o acesso do usuário:** para revogar as credenciais de um usuário para acessar um cluster, recomendamos que primeiro você remova ou force uma ACL no cluster e depois desassocie o segredo. Isso se dá pelo seguinte:
+ A remoção de um usuário não fecha as conexões existentes.
+ A propagação de alterações em seu segredo levam até 10 minutos.
Para obter informações sobre como usar uma ACL com o Amazon MSK, consulte [Apache Kafka ACLs](msk-acls.md).
Para clusters usando o ZooKeeper modo, recomendamos que você restrinja o acesso aos seus ZooKeeper nós para evitar que os usuários ACLs modifiquem. Para obter mais informações, consulte [Controle o acesso aos ZooKeeper nós do Apache em seu cluster Amazon MSK](zookeeper-security.md).
# Limitações ao usar segredos do SCRAM
Observe as seguintes limitações ao usar segredos SCRAM:
+ O Amazon MSK só é compatível com a autenticação SCRAM-SHA-512.
+ Um cluster do Amazon MSK pode ter até 1.000 usuários.
+ Você deve usar um AWS KMS key com seu segredo. Você não pode usar um segredo que use a chave de criptografia padrão do Secrets Manager com o Amazon MSK. Para obter informações sobre a criação de uma chave do KMS, consulte [Criação de chaves do KMS de criptografia simétrica](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk).
+ Não é possível usar uma chave assimétrica do KMS com o Secrets Manager.
+ Você pode associar até 10 segredos a um cluster por vez usando a [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)operação.
+ O nome dos segredos associados a um cluster do Amazon MSK deve ter o prefixo **AmazonMSK\$1**.
+ Os segredos associados a um cluster do Amazon MSK devem estar na mesma conta e AWS região da Amazon Web Services do cluster.
# Apache Kafka ACLs
O Apache Kafka tem um autorizador conectável e vem com uma implementação autorizadora. out-of-box O Amazon MSK habilita esse autorizador no arquivo `server.properties` dos agentes.
O Apache Kafka ACLs tem o formato “Principal P é [Permitida/Negada] Operação O do Host H em qualquer recurso R correspondente a RP”. ResourcePattern Se RP não corresponder a um recurso específico R, então R não tem nenhum associado e ACLs, portanto, ninguém além de superusuários tem permissão para acessar R. Para alterar esse comportamento do Apache Kafka, você define a propriedade como verdadeira. `allow.everyone.if.no.acl.found` O Amazon MSK a define como true por padrão. Isso significa que, com os clusters do Amazon MSK, se você não definir ACLs explicitamente um recurso, todos os principais poderão acessar esse recurso. Se você ACLs ativar um recurso, somente os diretores autorizados poderão acessá-lo. Se você quiser restringir o acesso a um tópico e autorizar um cliente usando a autenticação mútua TLS, adicione ACLs usando a CLI autorizadora do Apache Kafka. Para obter mais informações sobre adição, remoção e listagem ACLs, consulte Interface de [linha de comando de autorização do Kafka](https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Authorization+Command+Line+Interface).
Como o Amazon MSK configura os agentes como superusuários, eles podem acessar todos os tópicos. Isso ajuda os agentes a replicar mensagens da partição primária, quer a `allow.everyone.if.no.acl.found` propriedade esteja definida ou não para a configuração do cluster.
**Como adicionar ou remover o acesso de leitura e gravação a um tópico**
1. Adicione seus corretores à tabela da ACL para permitir que eles leiam todos os tópicos existentes ACLs . Para conceder acesso de leitura a um tópico para os seus agentes, execute o comando a seguir em uma máquina cliente capaz de se comunicar com o cluster do MSK.
*Distinguished-Name*Substitua pelo DNS de qualquer um dos corretores de bootstrap do seu cluster e, em seguida, substitua a string antes do primeiro ponto nesse nome distinto por um asterisco (). `*` Por exemplo, se um dos corretores de bootstrap do seu cluster tiver o DNS`b-6.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com`, *Distinguished-Name* substitua o comando a seguir por. `*.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com` Para ver informações sobre como obter os agentes de bootstrap, consulte [Obter os agentes de bootstrap para um cluster do Amazon MSK](msk-get-bootstrap-brokers.md).
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
1. Para conceder acesso de leitura a uma aplicação cliente, execute o comando a seguir na máquina de cliente. Se você usa a autenticação TLS mútua, use a mesma usada *Distinguished-Name* quando criou a chave privada.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
Para remover o acesso de leitura, é possível executar o mesmo comando, substituindo `--add` por `--remove`.
1. Para conceder acesso de gravação a um tópico, execute o comando a seguir na máquina de cliente. Se você usa a autenticação TLS mútua, use a mesma usada *Distinguished-Name* quando criou a chave privada.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Write --topic Topic-Name
```
Para remover o acesso de gravação, é possível executar o mesmo comando, substituindo `--add` por `--remove`.
# Alterar o grupo de segurança do cluster no Amazon MSK
Esta página explica como alterar o grupo de segurança de um cluster existente do MSK. Talvez seja necessário alterar o grupo de segurança de um cluster para fornecer acesso a um determinado conjunto de usuários ou limitar o acesso ao cluster. Para obter mais informações sobre grupos de segurança, consulte [Grupos de segurança para sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no Guia do usuário da Amazon VPC.
1. Use a [ListNodes](https://docs.amazonaws.cn/en_us/msk/1.0/apireference/clusters-clusterarn-nodes.html#ListNodes)API ou o comando [list-nodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/list-nodes.html) no AWS CLI para obter uma lista dos corretores em seu cluster. Os resultados dessa operação incluem as interfaces IDs de rede elástica (ENIs) associadas aos corretores.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Usando a lista suspensa no canto superior direito da tela, selecione a região na qual o cluster está implantado.
1. No painel esquerdo, em **Rede e Segurança**, escolha **Interfaces de rede**.
1. Selecione a primeira ENI que você obteve na primeira etapa. Escolha o menu **Ações** na parte superior da tela e escolha **Alterar grupos de segurança**. Atribua o novo grupo de segurança a essa ENI. Repita essa etapa para cada uma das ENIs que você obteve na primeira etapa.
**nota**
As alterações que você fizer no grupo de segurança de um cluster usando o console do Amazon EC2 não serão refletidas no console do MSK em **Configurações de rede**.
1. Configure as regras do novo grupo de segurança para garantir que seus clientes tenham acesso aos agentes. Para obter informações sobre como configurar regras de grupo de segurança, consulte [Adicionar, remover e atualizar regras](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) no guia do usuário da Amazon VPC.
**Importante**
Se você alterar o grupo de segurança associado aos agentes de um cluster e depois adicionar novos agentes a esse cluster, o Amazon MSK associará os novos agentes ao grupo de segurança original que estava associado ao cluster quando o cluster foi criado. No entanto, para que um cluster funcione corretamente, todos os seus agentes devem estar associados ao mesmo grupo de segurança. Portanto, se você adicionar novos corretores após alterar o grupo de segurança, deverá seguir novamente o procedimento anterior e atualizar o ENIs dos novos corretores.
# Controle o acesso aos ZooKeeper nós do Apache em seu cluster Amazon MSK
Por motivos de segurança, você pode limitar o acesso aos ZooKeeper nós do Apache que fazem parte do seu cluster Amazon MSK. Para limitar o acesso aos nós, é possível atribuir um grupo de segurança separado para eles. Depois, é possível decidir quem tem acesso a esse grupo de segurança.
**Importante**
Esta seção não se aplica a clusters em execução no KRaft modo. Consulte [KRaft modo](metadata-management.md#kraft-intro).
**Topics**
+ [Para colocar seus ZooKeeper nós Apache em um grupo de segurança separado](zookeeper-security-group.md)
+ [Usando a segurança TLS com o Apache ZooKeeper](zookeeper-security-tls.md)
# Para colocar seus ZooKeeper nós Apache em um grupo de segurança separado
Para limitar o acesso aos ZooKeeper nós do Apache, você pode atribuir um grupo de segurança separado a eles. Você pode escolher quem tem acesso a esse novo grupo de segurança definindo as regras dele.
1. Obtenha a string de ZooKeeper conexão do Apache para seu cluster. Para saber como, consulte [ZooKeeper modo](metadata-management.md#msk-get-connection-string). A string de conexão contém os nomes DNS dos seus nós do Apache ZooKeeper .
1. Use uma ferramenta como `host` ou `ping` para converter os nomes de DNS obtidos na etapa anterior para endereços IP. Salve esses endereços IP porque você precisará deles posteriormente neste procedimento.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. No painel de navegação, em **NETWORK & SECURITY (REDE E SEGURANÇA)**, selecione **Network Interfaces (Interfaces de rede)**.
1. No campo de pesquisa acima da tabela de interfaces de rede, digite o nome do cluster e digite return. Isso limita o número de interfaces de rede que aparecem na tabela às interfaces associadas ao cluster.
1. Marque a caixa de seleção no início da linha que corresponde à primeira interface de rede na lista.
1. No painel de detalhes na parte inferior da página, procure o ** IPv4 IP privado primário**. Se esse endereço IP corresponder a um dos endereços IP que você obteve na primeira etapa desse procedimento, isso significa que essa interface de rede está atribuída a um ZooKeeper nó Apache que faz parte do seu cluster. Caso contrário, desmarque a caixa de seleção ao lado dessa interface de rede e selecione a próxima interface de rede na lista. A ordem em que você seleciona as interfaces de rede não importa. Nas próximas etapas, você executará as mesmas operações em todas as interfaces de rede atribuídas aos ZooKeeper nós do Apache, uma por uma.
1. Ao selecionar uma interface de rede que corresponde a um ZooKeeper nó do Apache, escolha o menu **Ações** na parte superior da página e escolha **Alterar grupos de segurança**. Atribua um novo grupo de segurança a essa interface de rede. Para obter informações sobre como criar grupos de segurança, consulte [Criar um grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#CreatingSecurityGroups) na documentação da Amazon VPC.
1. Repita a etapa anterior para atribuir o mesmo novo grupo de segurança a todas as interfaces de rede associadas aos ZooKeeper nós Apache do seu cluster.
1. Agora é possível escolher quem tem acesso a esse novo grupo de segurança. Para obter informações sobre como configurar regras de grupo de segurança, consulte [Adicionar, remover e atualizar regras](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) na documentação da Amazon VPC.
# Usando a segurança TLS com o Apache ZooKeeper
Você pode usar a segurança TLS para criptografia em trânsito entre seus clientes e seus nós Apache ZooKeeper . Para implementar a segurança TLS com seus ZooKeeper nós Apache, faça o seguinte:
+ Os clusters devem usar o Apache Kafka versão 2.5.1 ou posterior para usar a segurança TLS com o Apache. ZooKeeper
+ Habilite a segurança TLS ao criar ou configurar seu cluster. Clusters criados com o Apache Kafka versão 2.5.1 ou posterior com TLS ativado usam automaticamente a segurança TLS com endpoints Apache. ZooKeeper Para obter mais informações sobre a configuração da segurança TLS, consulte [Conceitos básicos sobre criptografia do Amazon MSK](msk-working-with-encryption.md).
+ Recupere os ZooKeeper endpoints TLS Apache usando a operação. [DescribeCluster ](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)
+ Crie um arquivo de ZooKeeper configuração do Apache para uso com as [https://kafka.apache.org/documentation/#security_authz_cli](https://kafka.apache.org/documentation/#security_authz_cli)ferramentas `kafka-configs.sh` e ou com o ZooKeeper shell. Com cada ferramenta, você usa o `--zk-tls-config-file` parâmetro para especificar sua ZooKeeper configuração do Apache.
O exemplo a seguir mostra um arquivo de ZooKeeper configuração típico do Apache:
```
zookeeper.ssl.client.enable=true
zookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
zookeeper.ssl.keystore.location=kafka.jks
zookeeper.ssl.keystore.password=test1234
zookeeper.ssl.truststore.location=truststore.jks
zookeeper.ssl.truststore.password=test1234
```
+ Para outros comandos (como`kafka-topics`), você deve usar a variável de `KAFKA_OPTS` ambiente para configurar ZooKeeper os parâmetros do Apache. O exemplo a seguir mostra como configurar a variável de `KAFKA_OPTS` ambiente para passar ZooKeeper parâmetros do Apache para outros comandos:
```
export KAFKA_OPTS="
-Dzookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
-Dzookeeper.client.secure=true
-Dzookeeper.ssl.trustStore.location=/home/ec2-user/kafka.client.truststore.jks
-Dzookeeper.ssl.trustStore.password=changeit"
```
Após configurar a variável de ambiente `KAFKA_OPTS`, você pode usar os comandos da CLI normalmente. O exemplo a seguir cria um tópico do Apache Kafka usando a ZooKeeper configuração do Apache a partir da variável de ambiente: `KAFKA_OPTS`
```
/bin/kafka-topics.sh --create --zookeeper ZooKeeperTLSConnectString --replication-factor 3 --partitions 1 --topic AWSKafkaTutorialTopic
```
**nota**
Os nomes dos parâmetros que você usa no seu arquivo de ZooKeeper configuração do Apache e aqueles que você usa na sua variável de `KAFKA_OPTS` ambiente não são consistentes. Preste atenção nos nomes que você usa com quais parâmetros no arquivo de configuração e na variável de ambiente `KAFKA_OPTS`.
Para obter mais informações sobre como acessar seus ZooKeeper nós Apache com TLS, consulte [KIP-515: Habilitar o cliente ZK para usar a](https://cwiki.apache.org/confluence/display/KAFKA/KIP-515%3A+Enable+ZK+client+to+use+the+new+TLS+supported+authentication) nova autenticação compatível com TLS.
# Validação de conformidade do Amazon Managed Streaming for Apache Kafka
Auditores terceirizados avaliam a segurança e a conformidade do Amazon Managed Streaming for Apache Kafka como parte de programas de conformidade da AWS . Eles incluem PCI e HIPAA BAA.
Para obter uma lista de AWS serviços no escopo de programas de conformidade específicos, consulte [Amazon Services in Scope by Compliance Program](https://aws.amazon.com/compliance/services-in-scope/) . Para obter informações gerais, consulte Programas de [AWS conformidade Programas AWS](https://aws.amazon.com/compliance/programs/) de .
Você pode baixar relatórios de auditoria de terceiros usando AWS Artifact. Para obter mais informações, consulte [Baixar relatórios em AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
Sua responsabilidade de conformidade ao usar o Amazon MSK é determinada pela confidencialidade dos seus dados, pelos objetivos de conformidade da sua empresa e pelas leis e regulamentações aplicáveis. AWS fornece os seguintes recursos para ajudar na conformidade:
+ [Guias de início rápido de segurança e compatibilidade](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance): esses guias de implantação abordam as considerações de arquitetura e fornecem etapas para implantação de ambientes de linha de base focados em compatibilidade e segurança na AWS.
+ Documento técnico [sobre arquitetura para segurança e conformidade com a HIPAA — Este whitepaper](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/architecting-hipaa-security-and-compliance-on-aws.html) descreve como as empresas podem usar para criar aplicativos compatíveis com a HIPAA. AWS
+ AWS Recursos de [https://aws.amazon.com/compliance/resources/](https://aws.amazon.com/compliance/resources/) de conformidade — Essa coleção de pastas de trabalho e guias pode ser aplicada ao seu setor e local.
+ [Avaliação de recursos com regras](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html) no *Guia do AWS Config desenvolvedor* — O AWS Config serviço avalia o quão bem suas configurações de recursos estão em conformidade com as práticas internas, as diretrizes e os regulamentos do setor.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Esse AWS serviço fornece uma visão abrangente do seu estado de segurança interno, AWS que ajuda você a verificar sua conformidade com os padrões e as melhores práticas do setor de segurança.
# Resiliência no Amazon Managed Streaming for Apache Kafka
A infraestrutura AWS global é construída em torno de AWS regiões e zonas de disponibilidade. AWS As regiões fornecem várias zonas de disponibilidade fisicamente separadas e isoladas, conectadas a redes de baixa latência, alta taxa de transferência e alta redundância. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que automaticamente executam o failover entre as zonas sem interrupção. As zonas de disponibilidade são altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
Para obter mais informações sobre AWS regiões e zonas de disponibilidade, consulte [Infraestrutura AWS global](https://aws.amazon.com/about-aws/global-infrastructure/).
# Segurança de infraestrutura no Amazon Managed Streaming for Apache Kafka
Como um serviço gerenciado, o Amazon Managed Streaming for Apache Kafka é protegido AWS pelos procedimentos globais de segurança de rede descritos no whitepaper [Amazon Web Services:](https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf) Visão geral dos processos de segurança.
Você usa chamadas de API AWS publicadas para acessar o Amazon MSK pela rede. Os clientes devem oferecer suporte a Transport Layer Security (TLS) 1.0 ou posterior. Recomendamos TLS 1.2 ou posterior. Os clientes também devem ter compatibilidade com conjuntos de criptografia com perfect forward secrecy (PFS) como Ephemeral Diffie-Hellman (DHE) ou Ephemeral Elliptic Curve Diffie-Hellman (ECDHE). A maioria dos sistemas modernos como Java 7 e versões posteriores oferece compatibilidade com esses modos.
Além disso, as solicitações devem ser assinadas usando um ID da chave de acesso e uma chave de acesso secreta associada a uma entidade principal do IAM. Ou é possível usar o [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) (AWS STS) para gerar credenciais de segurança temporárias para assinar solicitações.