

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á.

# Controle de acesso do IAM
<a name="iam-access-control"></a>

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
<a name="how-to-use-iam-access-control"></a>

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
<a name="create-iam-access-control-cluster-in-console"></a>

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
<a name="configure-clients-for-iam-access-control"></a>

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
<a name="configure-clients-for-iam-access-control-sasl-oauthbearer"></a>

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('<my Região da AWS>')
           return token
   
   tp = MSKTokenProvider()
   
   producer = KafkaProducer(
       bootstrap_servers='<myBootstrapString>',
       security_protocol='SASL_SSL',
       sasl_mechanism='OAUTHBEARER',
       sasl_oauth_token_provider=tp,
       client_id=socket.gethostname(),
   )
   
   topic = "<my-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
<a name="configure-clients-for-iam-access-control-msk-iam"></a>

1. Adicione o seguinte ao arquivo `client.properties`. *<PATH\$1TO\$1TRUST\$1STORE\$1FILE>*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=<PATH_TO_TRUST_STORE_FILE>` 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=<PATH_TO_TRUST_STORE_FILE>
   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:

   ```
   <dependency>
       <groupId>software.amazon.msk</groupId>
       <artifactId>aws-msk-iam-auth</artifactId>
       <version>1.0.0</version>
   </dependency>
   ```

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
<a name="create-iam-access-control-policies"></a>

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
<a name="get-bootstrap-brokers-for-iam"></a>

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
<a name="kafka-actions"></a>

**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 name="actions"></a>

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 name="msk-iam-resources"></a>

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 name="iam-access-control-use-cases"></a>

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`  | 