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á.
# Usar clusters do MSK Serverless
Este tutorial mostra um exemplo de como você pode criar um cluster do MSK Serverless, criar uma máquina cliente capaz de acessá-lo e usar o cliente para criar tópicos no cluster e gravar dados nesses tópicos. Este exercício não representa todas as opções que você pode escolher ao criar um cluster com a tecnologia sem servidor. Em diferentes partes deste exercício, escolhemos as opções padrão para facilitar. Isso não significa que são as únicas opções que funcionam para configurar um cluster com a tecnologia sem servidor. Você também pode usar a API AWS CLI ou a Amazon MSK. Para obter mais informações, consulte a [Referência 2.0 da API do Amazon MSK](https://docs.aws.amazon.com/MSK/2.0/APIReference/what-is-msk.html).
**Topics**
+ [Criar um cluster do Amazon MSK Serverless](create-serverless-cluster.md)
+ [Criar um perfil do IAM para tópicos do cluster do MSK Serverless](create-iam-role.md)
+ [Criar uma máquina cliente para acessar o cluster do MSK Serverless](create-serverless-cluster-client.md)
+ [Criar um tópico do Apache Kafka](msk-serverless-create-topic.md)
+ [Produzir e consumir dados no MSK Sem Servidor](msk-serverless-produce-consume.md)
+ [Excluir recursos que você criou para o MSK Serverless](delete-resources.md)
# Criar um cluster do Amazon MSK Serverless
Nesta etapa, você executará duas tarefas. Primeiro, você cria um cluster do MSK Serverless com as configurações padrão. Em seguida, você reúne informações sobre o cluster. Essas são as informações que você precisará em etapas posteriores ao criar um cliente capaz de enviar dados para o cluster.
**Para criar um cluster com a tecnologia sem servidor**
1. Faça login no Console de gerenciamento da AWS e abra o console Amazon MSK em [https://console.aws.amazon.com/msk/casa](https://console.aws.amazon.com/msk/home).
1. Selecione **Criar cluster**.
1. Em **Método de criação**, deixe a opção **Criação rápida** selecionada. A opção **Criação rápida** permite criar um cluster com a tecnologia sem servidor com as configurações padrão.
1. Em **Nome do cluster**, insira um nome descritivo, como **msk-serverless-tutorial-cluster**.
1. Em **Propriedades gerais do cluster**, escolha **Tecnologia sem servidor** como o **Tipo de cluster**. Use os valores padrão para nos itens restantes das **Propriedades gerais do cluster**.
1. Observe a tabela em **Todas as configurações do cluster**. Essa tabela lista os valores padrão para configurações importantes, como rede e disponibilidade, e indica se você pode alterar cada configuração depois de criar o cluster. Para alterar uma configuração antes de criar o cluster, você deve escolher a opção **Criação personalizada** em **Método de criação**.
**nota**
Você pode conectar clientes de até cinco diferentes VPCs com clusters MSK Serverless. Para ajudar as aplicações clientes a migrarem para outra zona de disponibilidade no caso de uma interrupção, você deve especificar pelo menos duas sub-redes em cada VPC.
1. Selecione **Criar cluster**.
**Para reunir informações sobre o cluster**
1. Na seção **Resumo do cluster**, escolha **Exibir informações do cliente**. Esse botão permanece esmaecido até que o Amazon MSK conclua a criação do cluster. Pode ser necessário esperar alguns minutos até o botão ficar ativo para poder usá-lo.
1. Copie a string sob o rótulo **Endpoint**. Essa é a string do seu servidor bootstrap.
1. Escolha a guia **Properties (Propriedades)**.
1. Na seção **Configurações de rede**, copie as sub-redes e o grupo IDs de segurança e salve-as, pois você precisará dessas informações posteriormente para criar uma máquina cliente.
1. Escolha qualquer uma das sub-redes. Isso abrirá o console da Amazon VPC. Localize o ID da Amazon VPC associada à sub-rede. Salve esse ID da Amazon VPC para uso posterior.
**Próxima etapa**
[Criar um perfil do IAM para tópicos do cluster do MSK Serverless](create-iam-role.md)
# Criar um perfil do IAM para tópicos do cluster do MSK Serverless
Nesta etapa, você executará duas tarefas. A primeira tarefa será a criação de uma política do IAM que conceda acesso para criar tópicos no cluster e enviar dados para esses tópicos. A segunda tarefa será a criação de um perfil do IAM e a associação dessa política a ele. Em uma etapa posterior, criaremos uma máquina cliente que vai assumir esse perfil e usá-lo para criar um tópico no cluster e enviar dados para esse tópico.
**Para criar uma política do IAM que permita criar tópicos e gravar neles**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Políticas**.
1. Escolha **Create Policy**.
1. Escolha a guia **JSON** e substitua o JSON na janela do editor com o JSON a seguir.
No exemplo a seguir, substitua o seguinte:
+ *region*com o código de Região da AWS onde você criou seu cluster.
+ Exemplo de ID da conta*123456789012*, com seu Conta da AWS ID.
+ *msk-serverless-tutorial-cluster*/*c07c74ea-5146-4a03-add1-9baa787a5b14-s3*e *msk-serverless-tutorial-cluster* com seu ID de cluster sem servidor e nome do tópico.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:DescribeCluster"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:cluster/msk-serverless-tutorial-cluster/c07c74ea-5146-4a03-add1-9baa787a5b14-s3"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:CreateTopic",
"kafka-cluster:WriteData",
"kafka-cluster:DescribeTopic"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/msk-serverless-tutorial-cluster/*"
]
}
]
}
```
------
Para obter instruções sobre como gravar políticas seguras, consulte [Controle de acesso do IAM](iam-access-control.md).
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. Em nome da política, insira um nome descritivo, como **msk-serverless-tutorial-policy**.
1. Selecione **Criar política**.
**Para criar um perfil do IAM e associar a política a ele**
1. No painel de navegação, escolha **Perfis**.
1. Selecione **Criar perfil**.
1. Em **Casos de uso comuns**, selecione **EC2** e então **Próximo: permissões**.
1. Na caixa de pesquisa, insira o nome da política que você criou anteriormente para este tutorial. Em seguida, marque a caixa à esquerda da política.
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. Em nome do perfil, insira um nome descritivo, como **msk-serverless-tutorial-role**.
1. Selecione **Criar perfil**.
**Próxima etapa**
[Criar uma máquina cliente para acessar o cluster do MSK Serverless](create-serverless-cluster-client.md)
# Criar uma máquina cliente para acessar o cluster do MSK Serverless
Nesta etapa, você executará duas tarefas. A primeira tarefa é criar uma instância do Amazon EC2 para usar como uma máquina cliente do Apache Kafka. A segunda tarefa é instalar as ferramentas Java e Apache Kafka na máquina.
**Como criar uma máquina cliente**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Escolha **Iniciar instância**.
1. Insira um **Nome** descritivo para sua máquina cliente, como **msk-serverless-tutorial-client**.
1. Deixe a opção **AMI do Amazon Linux 2 (HVM) – Kernel 5.10, tipo de volume SSD** selecionada para **Tipo de imagem de máquina da Amazon (AMI)**.
1. Deixe o tipo de instância **t2.micro** selecionado.
1. Na seção **Par de chaves**, escolha **Criar um novo par de chaves**. Insira **MSKServerlessKeyPair** para **Nome do par de chaves**. Em seguida, escolha **Baixar o par de chaves**. Se preferir, use um par de chaves existente.
1. Em **Configurações de rede**, escolha **Editar**.
1. Em **VPC**, insira o ID da nuvem privada virtual (VPC) para o seu cluster com a tecnologia sem servidor. Trata-se da VPC baseada no serviço da Amazon VPC, cujo ID você salvou após a criação do cluster.
1. Em **Sub-rede**, escolha a sub-rede cujo ID você salvou depois de criar o cluster.
1. Em **Firewall (grupos de segurança)**, selecione o grupo de segurança associado ao cluster. Esse valor funcionará se esse grupo de segurança tiver uma regra de entrada que permita tráfego do grupo de segurança para ele. Com essa regra, os membros do mesmo grupo de segurança podem se comunicar entre eles. Para obter mais informações, consulte [Regras de grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SecurityGroupRules) no Guia do desenvolvedor da Amazon VPC.
1. Expanda a seção **Detalhes avançados** e escolha o perfil do IAM que você criou na [Criar um perfil do IAM para tópicos do cluster do MSK Serverless](create-iam-role.md).
1. Escolha **Executar**.
1. No painel de navegação à esquerda, selecione **Instâncias**. Em seguida, escolha a caixa de seleção na linha que representa sua instância recém-criada do Amazon EC2. Deste ponto em diante, chamamos essa instância de *máquina cliente*.
1. Escolha **Conectar** e siga as instruções para se conectar à máquina cliente.
**Para configurar as ferramentas do cliente Apache Kafka na máquina cliente**
1. Para instalar o Java, execute o seguinte comando na máquina cliente:
```
sudo yum -y install java-11
```
1. Para obter as ferramentas do Apache Kafka necessárias para criar tópicos e enviar dados, execute os seguintes comandos:
```
wget https://archive.apache.org/dist/kafka/2.8.1/kafka_2.12-2.8.1.tgz
```
```
tar -xzf kafka_2.12-2.8.1.tgz
```
**nota**
Depois de extrair o arquivo do Kafka, certifique-se de que os scripts no diretório `bin` tenham as permissões de execução adequadas. Para fazer isso, execute o comando a seguir.
```
chmod +x kafka_2.12-2.8.1/bin/*.sh
```
1. Acesse o diretório `kafka_2.12-2.8.1/libs` e execute o seguinte comando para baixar o arquivo JAR do IAM do Amazon MSK. O JAR do IAM do Amazon MSK permite que a máquina cliente acesse o cluster.
```
wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
```
Usando esse comando, você também pode [baixar versões diferentes ou mais recentes](https://github.com/aws/aws-msk-iam-auth/releases) do arquivo JAR do IAM do Amazon MSK.
1. Acesse o diretório `kafka_2.12-2.8.1/bin`. Copie e cole as seguintes configurações de propriedade em um novo arquivo. Nomeie e salve o arquivo como `client.properties`.
```
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
```
**Próxima etapa**
[Criar um tópico do Apache Kafka](msk-serverless-create-topic.md)
# Criar um tópico do Apache Kafka
Nesta etapa, você usa a máquina cliente criada anteriormente para criar um tópico no cluster com tecnologia sem servidor.
**Topics**
+ [Configuração de seu ambiente para criar tópicos](#msk-serverless-create-topic-prerequisites)
+ [Criar um tópico e gravar dados nele](#msk-serverless-create-topic-procedure)
## Configuração de seu ambiente para criar tópicos
+ Antes de criar um tópico, certifique-se de ter baixado o arquivo JAR do AWS MSK IAM para o diretório de instalação do Kafka. `libs/` Se você ainda não fez isso, execute o comando a seguir no diretório `libs/` do Kafka.
```
wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
```
Esse arquivo JAR é necessário para a autenticação do IAM em seu cluster sem servidor do MSK.
+ Ao executar comandos do Kafka, talvez seja necessário garantir que eles `classpath` incluam o arquivo JAR do AWS MSK IAM. Para isso, execute um dos seguintes procedimentos:
+ Configure a variável de ambiente `CLASSPATH` para incluir suas bibliotecas do Kafka, conforme mostrado no exemplo a seguir.
```
export CLASSPATH=/libs/*:/libs/aws-msk-iam-auth-2.3.0-all.jar
```
+ Execute comandos do Kafka usando o comando completo do Java com `classpath`explícito, como mostrado no exemplo a seguir.
```
java -cp "/libs/*:/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.TopicCommand --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
```
## Criar um tópico e gravar dados nele
1. No `export` comando a seguir, *my-endpoint* substitua pela string bootstrap-server que você salvou depois de criar o cluster. Em seguida, acesse o diretório `kafka_2.12-2.8.1/bin` na máquina cliente e execute o comando `export`.
```
export BS=my-endpoint
```
1. Execute o comando a seguir para criar um tópico chamado `msk-serverless-tutorial`.
```
/bin/kafka-topics.sh --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
```
**Próxima etapa**
[Produzir e consumir dados no MSK Sem Servidor](msk-serverless-produce-consume.md)
# Produzir e consumir dados no MSK Sem Servidor
Nesta etapa, você produz e consome dados usando o tópico que criou na etapa anterior.
**Como produzir e consumir mensagens**
1. Execute o comando a seguir para criar um produtor de console.
```
/bin/kafka-console-producer.sh --broker-list $BS --producer.config client.properties --topic msk-serverless-tutorial
```
1. Insira a mensagem que desejar e pressione **Enter**. Repita esta etapa duas ou três vezes. Sempre que você inserir uma linha e pressionar **Enter**, essa linha será enviada para o cluster como uma mensagem separada.
1. Mantenha a conexão com a máquina cliente aberta e abra uma segunda conexão separada com esse computador em uma nova janela.
1. Use sua segunda conexão com a máquina cliente para criar um consumidor no console executando o comando a seguir. *my-endpoint*Substitua pela string do servidor bootstrap que você salvou depois de criar o cluster.
```
/bin/kafka-console-consumer.sh --bootstrap-server my-endpoint --consumer.config client.properties --topic msk-serverless-tutorial --from-beginning
```
Você começará a ver as mensagens inseridas anteriormente quando usou o comando do produtor do console.
1. Insira mais mensagens na janela do produtor e observe-as aparecerem na janela do consumidor.
Se encontrar problemas no `classpath` enquanto executa esses comandos, verifique se eles estão sendo executados no diretório correto. Além disso, certifique-se de que o JAR do AWS MSK IAM esteja no `libs` diretório. Como alternativa, você pode executar comandos do Kafka usando o comando Java completo com `classpath` explícito, como mostrado no exemplo a seguir.
```
java -cp "kafka_2.12-2.8.1/libs/*:kafka_2.12-2.8.1/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.ConsoleProducer —broker-list $BS —producer.config client.properties —topic msk-serverless-tutorial
```
**Próxima etapa**
[Excluir recursos que você criou para o MSK Serverless](delete-resources.md)
# Excluir recursos que você criou para o MSK Serverless
Nesta etapa, você excluirá os recursos que criou neste tutorial.
**Para excluir o cluster**
1. Abra o console Amazon MSK em [https://console.aws.amazon.com/msk/casa](https://console.aws.amazon.com/msk/home).
1. Na lista de clusters, escolha o cluster que criou para este tutorial.
1. Em **Ações**, escolha **Excluir cluster**.
1. Insira `delete` no campo e escolha **Excluir**.
**Para interromper a máquina cliente**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na lista de instâncias do Amazon EC2, escolha a máquina cliente que você criou para este tutorial.
1. Escolha **Estado da instância** e **Encerrar instância**.
1. Escolha **Encerrar**.
**Para excluir a política e o perfil do IAM**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Perfis**.
1. Na caixa de pesquisa, insira o nome do perfil do IAM que você criou para este tutorial.
1. Escolha o perfil. Escolha **Excluir perfil** e confirme a exclusão.
1. No painel de navegação, escolha **Políticas**.
1. Na caixa de pesquisa, insira o nome da política que você criou para este tutorial.
1. Escolha a política para abrir a respectiva página de resumo. Na página **Resumo** da política, escolha **Editar política**.
1. Escolha **Excluir**.