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á.
# Etapa 4: criar um tópico no cluster do Amazon MSK
Nesta etapa de [Introdução ao uso do Amazon MSK](getting-started.md), você pode criar um tópico usando uma das duas abordagens: usar AWS ferramentas nativas com a CreateTopic API ou usar ferramentas do Apache Kafka em uma máquina AdminClient cliente.
**Atenção**
Ao usar AWS ferramentas com a CreateTopic API, verifique se o cluster atende aos requisitos. Para obter detalhes, consulte o [tópico Requisitos de uso APIs](https://docs.aws.amazon.com/msk/latest/developerguide/msk-topic-operations-information.html#topic-operations-requirements).
**Atenção**
Ao usar a AdminClient abordagem, os números de versão do Apache Kafka usados neste tutorial são apenas exemplos. Recomendamos usar a mesma versão do cliente que a versão do cluster do MSK. Uma versão mais antiga do cliente pode não ter determinados recursos e correções de erros críticos.
**Topics**
+ [Criando um tópico usando AWS ferramentas](#create-topic-aws-tools)
+ [Determinação da versão do cluster do MSK](#find-msk-cluster-version)
+ [Como criar um tópico na máquina cliente](#create-topic-client-machine)
## Criando um tópico usando AWS ferramentas
Você pode criar tópicos em seu cluster MSK usando AWS ferramentas como a AWS CLI ou AWS o AWS SDKs Management Console. Essa abordagem fornece uma maneira simplificada de gerenciar tópicos sem exigir acesso direto às ferramentas do cliente Kafka.
Para obter informações detalhadas sobre a criação de tópicos usando as AWS ferramentas, consulte o [guia do desenvolvedor CreateTopic da API](https://docs.aws.amazon.com/msk/latest/developerguide/msk-create-topic.html).
## Determinação da versão do cluster do MSK
1. Abra o console do Amazon MSK em [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Na barra de navegação, escolha a região na qual você criou seu cluster do MSK.
1. Escolha o cluster do MSK.
1. Anote a versão do Apache Kafka usada no cluster.
1. Substitua as ocorrências de números de versão do Amazon MSK neste tutorial pela versão obtida na Etapa 3.
## Como criar um tópico na máquina cliente
1. **Conecte-se à sua máquina cliente.**
1. 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, escolha **Instâncias**. Em seguida, marque a caixa de seleção ao lado do nome da máquina cliente que você criou em [Etapa 3: criar uma máquina cliente](create-client-machine.md).
1. Escolha **Actions (Ações)** e **Connect (Conectar-se)**. Siga as instruções no console para se conectar à sua máquina cliente.
1. **Instale o Java e configure a variável de ambiente da versão do Kafka.**
1. Instale o Java na máquina cliente executando o comando a seguir.
```
sudo yum -y install java-11
```
1. Armazene a [Versão do Kafka](#find-msk-cluster-version) do seu cluster do MSK na variável de ambiente, `KAFKA_VERSION`, conforme mostrado no comando a seguir. Você precisará dessas informações em toda a configuração.
```
export KAFKA_VERSION={KAFKA VERSION}
```
Por exemplo, se estiver usando a versão 3.6.0, execute o seguinte comando:
```
export KAFKA_VERSION=3.6.0
```
1. **Baixe e extraia o Apache Kafka.**
1. Execute o comando a seguir para fazer download do Apache Kafka.
```
wget https://archive.apache.org/dist/kafka/$KAFKA_VERSION/kafka_2.13-$KAFKA_VERSION.tgz
```
**nota**
A lista a seguir apresenta algumas informações alternativas de download do Kafka que você pode usar se houver algum problema.
Se houver problemas de conectividade ou quiser usar um site espelho, tente usar o seletor de espelhos do Apache, como mostrado no comando a seguir.
```
wget https://www.apache.org/dyn/closer.cgi?path=/kafka/$KAFKA_VERSION/kafka_2.13-$KAFKA_VERSION.tgz
```
Baixe uma versão apropriada diretamente do [site do Apache Kafka](https://kafka.apache.org/downloads).
1. Execute o comando a seguir no diretório onde você fez download do arquivo TAR na etapa anterior.
```
tar -xzf kafka_2.13-$KAFKA_VERSION.tgz
```
1. Armazene o caminho completo no diretório recém-criado dentro da variável de ambiente `KAFKA_ROOT`.
```
export KAFKA_ROOT=$(pwd)/kafka_2.13-$KAFKA_VERSION
```
1. **Configure a autenticação do seu cluster do MSK.**
1. [Encontre a versão mais recente](https://github.com/aws/aws-msk-iam-auth/releases/latest) da biblioteca de clientes IAM do Amazon MSK. Essa biblioteca permite que sua máquina cliente acesse o cluster do MSK usando a autenticação do IAM.
1. Usando os comandos a seguir, navegue até o diretório `$KAFKA_ROOT/libs` e baixe o arquivo JAR associado do IAM do Amazon MSK que você encontrou na etapa anterior. Certifique-se de *\$1LATEST VERSION\$1* substituir pelo número da versão real que você está baixando.
```
cd $KAFKA_ROOT/libs
```
```
wget https://github.com/aws/aws-msk-iam-auth/releases/latest/download/aws-msk-iam-auth-{LATEST VERSION}-all.jar
```
**nota**
Antes de executar qualquer comando do Kafka que interaja com seu cluster do MSK, talvez seja necessário adicionar o arquivo JAR do IAM do Amazon MSK ao seu classpath do Java. Defina a variável de ambiente `CLASSPATH` como mostrado no exemplo a seguir.
```
export CLASSPATH=$KAFKA_ROOT/libs/aws-msk-iam-auth-{LATEST VERSION}-all.jar
```
Isso define o `CLASSPATH` para a sessão inteira, disponibilizando o JAR para todos os comandos subsequentes do Kafka.
1. Acesse o diretório `$KAFKA_ROOT/config` para criar o arquivo de configuração do cliente.
```
cd $KAFKA_ROOT/config
```
1. Copie e cole as seguintes configurações de propriedade em um novo arquivo. 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
```
1. **(Opcional) Ajuste o tamanho da pilha de Java para as ferramentas do Kafka.**
Se houver algum problema relacionado à memória ou se estiver trabalhando com um número grande de tópicos ou partições, você poderá ajustar o tamanho da pilha do Java. Para fazer isso, defina a variável de ambiente `KAFKA_HEAP_OPTS` antes de executar os comandos do Kafka.
O exemplo a seguir define o tamanho máximo e inicial da pilha como 512 megabytes. Ajuste esses valores de acordo com seus requisitos específicos e os recursos de sistema disponíveis.
```
export KAFKA_HEAP_OPTS="-Xmx512M -Xms512M"
```
1. **Obtenha as informações de conexão do seu cluster.**
1. Abra o console do Amazon MSK em [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Aguarde até que o status do seu cluster esteja **Ativo**. Isso pode demorar vários minutos. Depois que o status ficar **Ativo**, escolha o nome do cluster. Isso levará você a uma página com o resumo do cluster.
1. Escolha **Exibir informações do cliente**.
1. Copie a string de conexão para o endpoint privado.
Você receberá três endpoints para cada um dos agentes. Armazene uma dessas cadeias de conexão na variável de ambiente `BOOTSTRAP_SERVER`, como mostrado no comando a seguir. **Substitua pelo valor real da cadeia de conexão.
```
export BOOTSTRAP_SERVER=
```
1. **Execute o comando a seguir para criar o tópico.**
```
$KAFKA_ROOT/bin/kafka-topics.sh --create --bootstrap-server $BOOTSTRAP_SERVER --command-config $KAFKA_ROOT/config/client.properties --replication-factor 3 --partitions 1 --topic MSKTutorialTopic
```
Se você receber `NoSuchFileException` para o arquivo `client.properties`, confira se esse arquivo consta no diretório de trabalho atual dentro do diretório bin do Kafka.
**nota**
Se preferir não definir a variável de ambiente `CLASSPATH` para a sessão inteira, como alternativa você poderá prefixar cada comando do Kafka com a variável `CLASSPATH`. Essa abordagem aplica o classpath somente a esse comando específico.
```
CLASSPATH=$KAFKA_ROOT/libs/aws-msk-iam-auth-{LATEST VERSION}-all.jar \
$KAFKA_ROOT/bin/kafka-topics.sh --create \
--bootstrap-server $BOOTSTRAP_SERVER \
--command-config $KAFKA_ROOT/config/client.properties \
--replication-factor 3 \
--partitions 1 \
--topic MSKTutorialTopic
```
1. **(Opcional) Verifique se o cluster foi criado com êxito.**
1. Se o comando tiver êxito, a seguinte mensagem será exibida: `Created topic MSKTutorialTopic.`
1. Liste todos os tópicos para confirmar que seu tópico existe.
```
$KAFKA_ROOT/bin/kafka-topics.sh --list --bootstrap-server $BOOTSTRAP_SERVER --command-config $KAFKA_ROOT/config/client.properties
```
Se o comando falhar ou se houver um erro, consulte [Solução de problemas para o cluster do Amazon MSK](troubleshooting.md) para saber mais sobre solução de problemas.
1. **(Opcional) Exclua as variáveis de ambiente que você usou neste tutorial.**
Se quiser manter as variáveis de ambiente para as próximas etapas deste tutorial, ignore esta etapa. Caso contrário, você pode cancelar a definição dessas variáveis, como mostrado no exemplo a seguir.
```
unset KAFKA_VERSION KAFKA_ROOT BOOTSTRAP_SERVER CLASSPATH KAFKA_HEAP_OPTS
```
**Próxima etapa**
[Etapa 5: produzir e consumir dados](produce-consume.md)