{"componentChunkName":"component---src-templates-blog-post-js","path":"/kafka-producer-avro/","result":{"data":{"markdownRemark":{"html":"

Vamos iniciar uma série de artigos sobre Kafka, a intenção será mostrar a criação de diversas aplicações que irão se comunicar de forma assíncrona utilizando o Apache Kafka.

\n

Trabalhar com assincronicidade não é uma tarefa simples e fácil, mas extremamente importante em grandes sistemas que precisam manipular grandes volumes de dados.

\n

Pensando nisso o LinkedIn desenvolveu uma ferramenta para comunicação de mensagens assíncronas, levando em consideração contextos onde o grande volume de dados seja algo impactante, posteriormente se tornando Open Source pela Apache o Kafka é uma ferramente robusta, rápida e escalável.

\n

Existem muitas ferramentas de mensageria disponíveis e não entraremos aqui no mérito de qual é melhor ou pior, vamos demonstrar que apesar de ser uma ferramenta com suas peculiaridades o Kafka pode ser configurado e utilizado de forma rápida, produtiva e sem grandes dores de cabeça para isso.\nNesse artigo criaremos um produtor de mensagens com Kafka, também iremos mostrar a vantagem de usarmos um validador para as nossas mensagens através de contratos com Schema Registry e utilizaremos Spring Boot.

\n

Também não vamos nos alongar muito nos conceitos sobre o que é o Kafka e suas específicidades caso tenha interesse sugerimos os seguintes artigos:

\n\n

Criando o ambiente

\n

Antes de mais nada vamos montar a nossa infra estrutura com o Kafka, mas nesse exemplo não iremos instalar o Kafka e todos os outros serviços dele pois além de ser custoso para a máquina que vai rodá-lo não é necessário com a abordagem que faremos. Ao invés disso usaremos Docker e Docker Compose para levantar o nosso ambiente.

\n

Utilizaremos a imagem disponibilizada pela Landoop que nos fornece todo o ambiente de desenvolvimento necessário para utilizarmos as funcionalidades do Kafka, além disso vamos utilizar em conjunto com Docker Compose para termos controle sobre as configurações de variáveis de ambiente, portas e rede.

\n

O nosso docker-compose.yml ficará assim:

\n
version: '2'\n\nservices:\n  # this is our kafka cluster.\n  kafka-cluster:\n    image: landoop/fast-data-dev:cp3.3.0\n    environment:\n      ADV_HOST: 127.0.0.1         # Change to 192.168.99.100 if using Docker Toolbox\n      RUNTESTS: 0                 # Disable Running tests so the cluster starts faster\n      FORWARDLOGS: 0              # Disable running 5 file source connectors that bring application logs into Kafka topics\n      SAMPLEDATA: 0               # Do not create sea_vessel_position_reports, nyc_yellow_taxi_trip_data, reddit_posts topics with sample Avro records.\n    ports:\n      - 2181:2181                 # Zookeeper\n      - 3030:3030                 # Landoop UI\n      - 8081-8083:8081-8083       # REST Proxy, Schema Registry, Kafka Connect ports\n      - 9581-9585:9581-9585       # JMX Ports\n      - 9092:9092                 # Kafka Broker
\n

Para rodar basta abrirmos o terminal onde está localizado o nosso arquivo docker-compose.yml e executar:

\n
docker-compose up -d
\n

Após fazer isso podemos acessar http://localhost:3030/ e conseguiremos abrir o dashboard que a Landoop disponibiliza e teremos algo parecido com isso:

\n

\n \n \n

\n

Schema Registry

\n

Antes de iniciarmos o projeto vamos entender o que é o Schema Registry e por que ele é importante.

\n

O Kafka envia e recebe mensagens porém não faz validação sobre o que está sendo enviado ou recebido até que a aplicação consumidora tente realizar a desserialização da mensagem e caso o contrato da aplicação consumidora não seja compatível ocorrerá um erro. Para evitar isso a Confluent criou o Schema Registry para fazer a validação de contratos e metadados das mensagens que são trafegadas.

\n

A grosso modo o Schema Registry valida se a mensagem que está sendo enviada por uma aplicação é compatível. Podemos usar vários formatos de arquivos para criar os nossos schemas como XML, CSV, JSON mas aqui usaremos Apache Avro que é um formato desenvolvido para criação de schemas com tipagem.

\n

O Schema Registry é um componente apartado do Kafka como na imagem abaixo:

\n

\n \n \n

\n

Avro

\n

Para começarmos a criar o nosso produtor de mensagens vamos aproveitar o projeto do artigo sobre Spring Security com JWT.

\n

Essa aplicação é usada para simular o envio de dados para receita federal, a princípio fazemos um POST com os dados de um contribuinte contendo o nome e o CPF.

\n

Vamos começar criando o nosso Avro, dentro da pasta resources/avro criamos o arquivo taxpayer-v1.avsc contendo o nosso schema:

\n
{\n     \"type\": \"record\",\n     \"namespace\": \"com.irs.register.avro.taxpayer\",\n     \"name\": \"TaxPayer\",\n     \"version\": \"1\",\n     \"fields\": [\n       { \"name\": \"name\", \"type\": \"string\", \"doc\": \"Name of TaxPayer\" },\n       { \"name\": \"document\", \"type\": \"string\", \"doc\": \"Document of TaxPayer\" },\n       { \"name\": \"situation\", \"type\": \"boolean\", \"default\": false, \"doc\": \"Legal situation of TaxPayer\" }\n     ]\n}
\n

O nosso Avro contém os metadados de type, namespace, name e version. Também adicionamos os campos da nossa entidade no array fields e nele conseguimos além do name colocar outros atributos como tipagem com o type e valores padrão com o campo default.

\n

Vamos adicionar as dependências no projeto:

\n
<dependency>\n    <groupId>org.apache.avro</groupId>\n    <artifactId>avro</artifactId>\n    <version>1.10.1</version>\n</dependency>\n\n<dependency>\n    <groupId>org.apache.kafka</groupId>\n    <artifactId>kafka-clients</artifactId>\n</dependency>\n\n<dependency>\n    <groupId>io.confluent</groupId>\n    <artifactId>kafka-avro-serializer</artifactId>\n    <version>5.3.0</version>\n</dependency>
\n

E também precisamos adicionar o plugin que irá interpretar o nosso Avro e vai gerar a classe Java correspondente.

\n
<build>\n    <plugins>\n        <plugin>\n            <groupId>org.springframework.boot</groupId>\n            <artifactId>spring-boot-maven-plugin</artifactId>\n        </plugin>\n\n        <plugin>\n            <groupId>org.springframework.boot</groupId>\n            <artifactId>spring-boot-maven-plugin</artifactId>\n        </plugin>\n        <!--for specific record -->\n        <plugin>\n            <groupId>org.apache.avro</groupId>\n            <artifactId>avro-maven-plugin</artifactId>\n            <version>1.10.1</version>\n            <executions>\n                <execution>\n                    <phase>generate-sources</phase>\n                    <goals>\n                        <goal>schema</goal>\n                        <goal>protocol</goal>\n                        <goal>idl-protocol</goal>\n                    </goals>\n                    <configuration>\n                        <sourceDirectory>${project.basedir}/src/main/resources/avro</sourceDirectory>\n                        <stringType>String</stringType>\n                        <createSetters>false</createSetters>\n                        <enableDecimalLogicalType>true</enableDecimalLogicalType>\n                        <fieldVisibility>private</fieldVisibility>\n                    </configuration>\n                </execution>\n            </executions>\n        </plugin>\n        <!--force discovery of generated classes -->\n        <plugin>\n            <groupId>org.codehaus.mojo</groupId>\n            <artifactId>build-helper-maven-plugin</artifactId>\n            <version>3.0.0</version>\n            <executions>\n                <execution>\n                    <id>add-source</id>\n                    <phase>generate-sources</phase>\n                    <goals>\n                        <goal>add-source</goal>\n                    </goals>\n                    <configuration>\n                        <sources>\n                            <source>target/generated-sources/avro</source>\n                        </sources>\n                    </configuration>\n                </execution>\n            </executions>\n        </plugin>\n    </plugins>\n</build>
\n

Com isso feito podemos rodar o comando mvn generate-sources e a nossa classe será gerada em target/generated-sources/avro/TaxPayer.java.

\n

Configurando o Kafka

\n

Precisamos configurar a nossa aplicação para se conectar com o Kafka. O Kafka contém uma série de configurações customizáveis e para deixar mais flexível vamos usar algumas delas via properties.

\n

Vamos criar a nossa classe de configuração dos nossos properties:

\n
@Configuration\n@ConfigurationProperties(\n    prefix = \"kafka\"\n)\n@Data\n@NoArgsConstructor\npublic class KafkaProperties {\n\t\n\tprivate List<String> bootstrapServers;\n\tprivate String acksConfig;\n\tprivate String retriesConfig;\n\tprivate Class<?> keySerializer = StringSerializer.class;\n\tprivate Class<?> valueSerializer = KafkaAvroSerializer.class;\n\tprivate String schemaRegistryUrl;\n\n}
\n

E no nosso arquivo application.yml:

\n
kafka:\n  bootstrapServers: 127.0.0.1:9092 \n  acksConfig: all\n  retriesConfig: 10\n  schemaRegistryUrl: \"http://127.0.0.1:8081\"
\n

Aqui temos as configurações para conectar no Kafka, no Schema Registry, como iremos fazer serialização e desserialização, também temos a configuração de Acks que é a confirmação do envio da mensagem, nesse caso queremos que todas as mensagens enviadas informem que foram enviadas positivamente e por fim temos a configuração de Retries que irá indicar o reenvio de mensagens que falharem. Existem muitas outras configurações que podemos adicionar mas por hora essas atendem muito bem a nossa aplicação.

\n

Com o nosso properties criado podemos fazer a configuração do Kafka injetando a classe KafkaProperties e configurando o nosso Bean do produtor do Kafka:

\n
@Configuration\npublic class MessagingConfigTaxPayer implements MessagingConfigPort<TaxPayer> {\n\t\n\t@Autowired\n\tprivate KafkaProperties kafkaProperties;\n\n\t@Bean(name = \"taxpayerProducer\")\n\t@Override\n\tpublic KafkaProducer<String, TaxPayer> configureProducer() {\n\n\t\tProperties properties = new Properties();\n\t\t\n        properties.put(BOOTSTRAP_SERVERS_CONFIG, kafkaProperties.getBootstrapServers());\n        properties.put(ACKS_CONFIG, kafkaProperties.getAcksConfig());\n        properties.put(RETRIES_CONFIG, kafkaProperties.getRetriesConfig());\n        properties.put(KEY_SERIALIZER_CLASS_CONFIG, kafkaProperties.getKeySerializer());\n        properties.put(VALUE_SERIALIZER_CLASS_CONFIG, kafkaProperties.getValueSerializer());\n        properties.put(SCHEMA_REGISTRY_URL_CONFIG, kafkaProperties.getSchemaRegistryUrl());\n\t\t\n\t\treturn new KafkaProducer<String, TaxPayer>(properties);\n\t\t\n\t}\n\n}
\n

Configurando o Produtor

\n

Agora vamos criar o nosso produtor que implementa a interface MessagingPort que possui três métodos:

\n\n

Esses três métodos fornecem o que precisamos para conseguir enviar uma mensagem pelo Kafka e no nosso exemplo será uma classe tipada para a nossa classe TaxPayer:

\n
@Service\n@Slf4j\npublic class TaxpayerService implements MessagingPort<TaxPayer> {\n\n\t@Autowired\n\t@Qualifier(\"taxpayerProducer\")\n\tprivate KafkaProducer<String, TaxPayer> producer;\n\n\t@Override\n\tpublic String topic() {\n\t\treturn \"taxpayer-avro\";\n\t}\n\t\t\n\t@Override\n\tpublic ProducerRecord<String, TaxPayer> createProducerRecord(TaxPayer taxPayer) {\n\n\t\treturn new ProducerRecord<String, TaxPayer>(this.topic(), taxPayer);\n\t\t\n\t}\n\n\t@Override\n\tpublic void send(CommonDTO taxpayerDTO) {\n\t\t\n\n\t\tTaxPayer taxPayer = TaxPayer.newBuilder().setName(((TaxpayerDTO) taxpayerDTO).getName())\n\t\t\t\t.setDocument(((TaxpayerDTO) taxpayerDTO).getDocument()).setSituation(false).build();\n\t\t\n\t\t\n\t\tproducer.send(this.createProducerRecord(taxPayer), (rm, ex) -> {\n\t\t\tif (ex == null) {\n\t\t\t\tlog.info(\"Data sent with success!!!\");\n\t\t\t} else {\n\t\t\t\tlog.error(\"Fail to send message\", ex);\n\t\t\t}\n\t\t});\n\n\t\tproducer.flush();\n\t\tproducer.close();\n\n\t}\n\n}
\n

Detalhando cada método.

\n

No método topic nós setamos o nome do tópico no Kafka.

\n

O método createProducerRecord recebe como parâmetro o nosso TaxPayer e devolve um ProducerRecord.

\n

O método send recebe um CommonDTO, que nada mais é do que uma interface de marcação para os DTOs da aplicação, nele podemos ver que usamos o Builder que a TaxPayer fornece, passando os dados que iremos receber no POST da API.

\n

Também é nesse método que fazemos o envio da mensagem para o Kafka, podemos ver que o método send do KafkaProducer recebe o nosso TaxPayer mas também executa uma função de callback onde fazemos uma simples verificação de sucesso ou erro e logamos o resultado. Após isso “atualizamos” a transação e fechamos.

\n

Controller

\n

Precisamos criar a porta de entrada da aplicação, o lugar que irá receber os dados e repassar para a nossa Service.

\n
@RestController\n@RequestMapping(\"/taxpayer\")\npublic class TaxpayerController {\n\t\n\t@Autowired\n\tprivate TaxpayerService taxpayerService;\n\t\n\t@PostMapping\n\tpublic ResponseEntity<TaxpayerDTO> postTaxpayer(@RequestBody TaxpayerDTO taxpayer){\n\t\t\n\t\ttaxpayerService.send(taxpayer);\n\t\t\n\t\treturn ResponseEntity.ok(taxpayer);\n\t}\n\n}
\n

Criamos o endpoint /taxpayer que recebe um TaxpayerDTO e chama a TaxpayerService que é a responsável por enviar a nossa mensagem.

\n

A nossa classe TaxpayerDTO:

\n
@Data\npublic class TaxpayerDTO implements CommonDTO{\n\t\n\tprivate String name;\n\t\n\tprivate String document;\n\n\t@Override\n\tpublic String getType() {\n\t\treturn \"TaxPayerDTO\";\n\t}\n\n}
\n

Executando

\n

Vamos executar a aplicação e enviar um POST para conferir o funcionamento, para enviar os dados foi utilizado o Gerador de Pessoas e também é necessário enviar o token JWT para autorização a esse recurso, para saber mais sobre isso consultar o artigo sobre Spring Security com JWT.

\n

\n \n \n

\n

E como estamos usando o dashboard da Landoop podemos acessar e ver que o nosso Schema foi criado e que o nosso tópico também foi criado e que ele possui os dados enviados.

\n

\n \n \n

\n

E aqui temos o nosso tópico criado e vemos a informação que foi enviada.

\n

Consumindo via Terminal

\n

Podemos produzir, consumir, criar e fazer todas as operações do Kafka via terminal, agora para fins de exemplo vamos consumir a mensagem que enviamos via terminal.

\n

Podemos fazer isso acessando o nosso Schema Registry via Docker:

\n
docker run -it --rm --net=host confluentinc/cp-schema-registry:3.3.1 bash
\n

E para consumir a mensagem usaremos o utilitário de linha de comando kafka-avro-console-consumer:

\n
kafka-avro-console-consumer --topic taxpayer-avro \\\n     --bootstrap-server localhost:9092 \\\n     --from-beginning \\\n     --property schema.registry.url=http://127.0.0.1:8081
\n

Que irá produzir o resultado:

\n
{\"name\":\"Luís Marcelo da Conceição\",\"document\":\"216.172.648-06\",\"situation\":false}
\n

Código fonte

\n

Segue o código completo no GitHub

","fields":{"slug":"/kafka-producer-avro/"},"frontmatter":{"date":"01 de janeiro de 2021","description":"Criando um produtor de mensagens com Kafka, Avro e Spring Boot","title":"Produzindo mensagens com Kafka e Schema Registry","tags":["Kafka","Spring Boot","Schema Registry","Java"],"author":"Guilherme Alves","image":{"id":"35fae678-8f16-5611-ae35-e08e57d32b5c","publicURL":"/static/7a31b5a7571996c80496f4e66ade7f25/kafka-java.png","childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAOCAYAAAAvxDzwAAAACXBIWXMAAAsSAAALEgHS3X78AAACUUlEQVQ4y5VTz68ZURT2N1j4D8RGiERsxMKGBUGIWIiFlbW3rQS7JizEsrvaNk1F00WbF9GfUiF9BKGvfiVeW4JQz4wxw9e5F4Okr01PcmbOnHvnu+c757uy2WyG7XaL+XyOVqtF4/V6DYZhqLMs+0ffr63332f7ZDzPUzCv1wudTod0Og1iBJjYbrfDg8Yz4kb+IiUjj0wmA5/Ph9FoBLVaLYGdvwnwuRPj2tfYcivsDgcTpxWOx2O4XC7o9XokEgmsViv4/X4YjUaUSiX6syAIF2Bs7QWY0lNs7ycSEwq4XC5polKpwGq10piAXl1doVAowGKxnKo80GNvnmP56hHW9RwFOTKQKFerVUpVoVAgGAzC6XTCbDbD4/EgHo+fKtwK+7j9BmzxCZjrxxf9oxWSwG63IxaL0aRKpaKD6Xa7yOVyF5uJ3U0WmN+LU/3Rwrz8DPxmg6GYY7nNqUKHw4FIJEITSqWSAnY6HWSz2fPjIYjU3te7+NQcoNYf4aY3xpLd4GOjh+/TXyfARqMBrVYLuVyOUChEB0QoEylFo9G9Qnjh0MsdXpfbyH+5xbtaB4sVS12ifBxKvV6HzWajcTKZRDgcRj6flwZF7OtwjP7PGYrNPl4WG/hQ72G94bFkOPDCXmKyjdiDyWQCt9sNjUaDVCpFFR8IBGAymVAulyXK3+4m+NwaoHI7FEEHIvU+3ta6aA5GtB3/FPZxEOeyONImOV6cPMcL0hqlTOQwnU5phQaDgWrwoau3O/jfTLZYLGhA7jPp434APDiOA2nH//pvd7/WeYM1qg4AAAAASUVORK5CYII=","aspectRatio":1.391304347826087,"src":"/static/7a31b5a7571996c80496f4e66ade7f25/9decb/kafka-java.png","srcSet":"/static/7a31b5a7571996c80496f4e66ade7f25/c67b7/kafka-java.png 320w,\n/static/7a31b5a7571996c80496f4e66ade7f25/d3930/kafka-java.png 640w,\n/static/7a31b5a7571996c80496f4e66ade7f25/9decb/kafka-java.png 641w","sizes":"(max-width: 641px) 100vw, 641px"}}}},"timeToRead":11}},"pageContext":{"slug":"/kafka-producer-avro/","previous":{"fields":{"slug":"/spring-security-jwt/"},"frontmatter":{"title":"Spring Security e JWT","date":"14 dez, 2020"}},"next":{"fields":{"slug":"/flyway-java/"},"frontmatter":{"title":"Versionando o banco de dados com Flyway","date":"11 jan, 2021"}}}},"staticQueryHashes":["63159454"]}