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

Introdução

\n

Na documentação do Kafka Streams temos a seguinte descrição: “Kafka Streams é uma biblioteca cliente para construir aplicações e microserviços onde a entrada e saída de dados são armazenados nos clusters do Kafka. Ele combina a simplicidade de escrever e subir aplicações Java e Scala no lado do cliente com os benefícios da tecnologia de clusters do lado do servidor do Kafka”

\n

Isso significa que o Kafka Streams é uma ferramenta para processamento de fluxo de dados (streams) em tempo real que é integrada ao ambiente do Kafka. Possibilitando o processamento, transformação e persistência de dados em novos tópicos.

\n

Nesse artigo será mostrado um exemplo onde uma aplicação conectada ao Kafka utiliza a biblioteca do Kafka Streams para executar o processamento dos dados.

\n

O Projeto

\n

Anteriormente em artigos passados foi mostrado como produzir mensagens com Kafka e como consumir mensagens com Kafka e agora vamos continuar com esse modelo onde o produtor irá enviar esses dados e tanto o consumidor simples quanto o nosso consumidor com Streams irá processar e para esse exemplo não iremos persistir em um novo tópico iremos apenas chamar um Processor que irá persistir em um banco de dados.\nA visão geral de como os projetos se comunicam com o Kafka seria algo assim:

\n

\n \n \n

\n

Iniciando o projeto

\n

O projeto foi criado no site Spring Initializr como um projeto Maven e para usarmos o Kafka Streams precisamos adicionar as dependências do Apache e também foi adicionado as dependências da Confluent para poder ser usado o suporte que existe para Schema Registry como Serialização e Deserialização (SerDe):

\n
<!-- https://mvnrepository.com/artifact/org.apache.avro/avro -->\n<dependency>\n    <groupId>org.apache.avro</groupId>\n    <artifactId>avro</artifactId>\n    <version>1.10.1</version>\n</dependency`\n\n<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-streams -->\n<dependency>\n    <groupId>org.apache.kafka</groupId>\n    <artifactId>kafka-streams</artifactId>\n</dependency>\n\n<!--dependencies needed for the kafka part -->\n<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->\n<dependency>\n    <groupId>org.apache.kafka</groupId>\n    <artifactId>kafka-clients</artifactId>\n</dependency>\n\n<!-- https://mvnrepository.com/artifact/io.confluent/kafka-avro-serializer -->\n<dependency>\n    <groupId>io.confluent</groupId>\n    <artifactId>kafka-avro-serializer</artifactId>\n    <version>5.3.0</version>\n</dependency>\n\n<dependency>\n    <groupId>io.confluent</groupId>\n    <artifactId>kafka-streams-avro-serde</artifactId>\n    <version>5.3.0</version>\n    <exclusions>\n        <exclusion>\n            <groupId>org.slf4j</groupId>\n            <artifactId>slf4j-log4j12</artifactId>\n        </exclusion>\n    </exclusions>\n</dependency>
\n

E também é necessário adicionar a tag que indica de onde deve ser baixado as dependências da Confluent:

\n
<repositories>\n    <repository>\n        <id>confluent</id>\n        <url>https://packages.confluent.io/maven/</url>\n    </repository>\n</repositories>
\n

Configurando Kafka Properties

\n

O Kafka é todo baseado em configurações que passamos via Properties como no exemplo:

\n
@Configuration\npublic class KafkaConfiguration implements MessageConfiguration {\n\n\t@Autowired\n\tprivate KafkaProperties kafkaProperties;\n\n\t@Override\n\tpublic Properties configureProperties() {\n\n\t\tProperties properties = new Properties();\n\n\t\tproperties.put(APPLICATION_ID_CONFIG, kafkaProperties.getApplicationId());\n\t\tproperties.put(GROUP_ID_CONFIG, kafkaProperties.getGroupId());\n\t\tproperties.put(BOOTSTRAP_SERVERS_CONFIG, kafkaProperties.getBootstrapServers());\n\t\tproperties.put(CLIENT_ID_CONFIG, kafkaProperties.getClientId());\n\n\t\tproperties.put(PROCESSING_GUARANTEE_CONFIG, kafkaProperties.getProcessingGuaranteeConfig());\n\t\tproperties.put(AUTO_OFFSET_RESET_CONFIG, kafkaProperties.getOffsetReset());\n\t\tproperties.put(DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_CONFIG, kafkaProperties.getTimeStampExtarctor());\n\n\t\tproperties.put(SCHEMA_REGISTRY_URL_CONFIG, kafkaProperties.getSchemaRegistryUrl());\n\t\tproperties.put(DEFAULT_KEY_SERDE_CLASS_CONFIG, kafkaProperties.getDefaultKeySerde());\n\t\tproperties.put(DEFAULT_VALUE_SERDE_CLASS_CONFIG, kafkaProperties.getDefaultValueSerde());\n\t\tproperties.put(SPECIFIC_AVRO_READER_CONFIG, kafkaProperties.isSpecficAvroReader());\n\n\t\treturn properties;\n\t}\n\n}
\n

Das configurações acima vale ressaltar as seguintes:

\n\n

Configurando o processamento

\n

Quando recebermos os nossos dados de Taxpayer há uma informação sobre a situation do contribuinte. Podemos usar isso e definir um processador específico para cada situação do contribuinte; caso seja true será processado pela classe TaxpayerProcessorSituationTrue e caso seja false pela TaxpayerProcessorSituationFalse. Para esse exemplo vamos processar cada contribuinte, de acordo com a sua situation e salvar em um banco de dados para cada tipo de situação do contribuinte.

\n

A API do Kafka Streams fornece uma interface chamada Processor para implementarmos um processador de dados e ainda temos uma abstração chamada AbstractProcessor que facilita ainda mais esse trabalho, então as classes ficam dessa forma para situation igual a true:

\n
@Component\n@Slf4j\npublic class TaxpayerProcessorSituationTrue extends AbstractProcessor<String, TaxPayer>{\n\t\n\t@Autowired\n\tprivate TaxpayerPort repository;\n\n\t@Override\n\tpublic void process(String key, TaxPayer value) {\n\t\tlog.info(\"Processing Taxpayer with situation :: \" + value.getSituation());\n\t\tComplaintTaxpayer complaintTaxpayer = ComplaintTaxpayer.createDefaultedTaxpayer(value);\n\t\trepository.save(complaintTaxpayer);\n\t\t\n\t}\n\n}
\n

E para situation igual a false:

\n
@Component\n@Slf4j\npublic class TaxpayerProcessorSituationFalse extends AbstractProcessor<String, TaxPayer> {\n\n\t@Autowired\n\tprivate TaxpayerPort repository;\n\n\t@Override\n\tpublic void process(String key, TaxPayer value) {\n\t\tlog.info(\"Processing Taxpayer with situation :: \" + value.getSituation());\n\t\tDefaultedTaxpayer defaultedTaxpayer = DefaultedTaxpayer.createDefaultedTaxpayer(value);\n\t\trepository.save(defaultedTaxpayer);\n\n\t}\n\n}
\n

Configurando o Stream

\n

Para configurar a Stream é necessário ser passado as Properties do cluster do Kafka, o nome do tópico e a configuração de SerDe:

\n
StreamsBuilder streamsBuilder = new StreamsBuilder();\n\nSerde<TaxPayer> taxpayerAvroSerde = new SpecificAvroSerde<>();\n\ntaxpayerAvroSerde.configure(getSerdeProperties(), false);\n\nKStream<String, TaxPayer> stream = streamsBuilder.stream(getTopic(), Consumed.with(Serdes.String(), taxpayerAvroSerde));
\n

Nesse trecho de código podemos ver que o Kafka possui um Builder para as nossas Streams, ela recebe o tópico e a combinação chave/valor da mensagem que será recebida. Como estamos trabalhando com Schema Registry definimos que o valor dessa mensagem será um Serde.

\n

Com o objeto KStream<String, TaxPayer> podemos fazer várias manipulações dos dados que irão chegar aqui para podermos filtrá-los e encaminhar para o Processor certo vamos usar o método branch que nos devolverá o um Array:

\n
KStream<String, TaxPayer>[] branch = stream.branch(\n\t\t\t\t(id, tax) -> tax.getSituation() == false,\n\t\t\t\t(id, tax) -> tax.getSituation() == true\n\t\t\t\t);
\n

No código acima usamos o método branch para fazer o nosso filtro por situation e podemos delegar para os Processors:

\n
branch[0].process(() -> processorFalse);\nbranch[1].process(() -> processorTrue);
\n

O exemplo completo dessa configuração:

\n
@Autowired\nprivate TaxpayerProcessorSituationTrue processorTrue;\n\n@Autowired\nprivate TaxpayerProcessorSituationFalse processorFalse;\n\nprivate KafkaStreams kafkaStreams;\n\n@Override\npublic String getTopic() {\n    return \"taxpayer-avro\";\n}\n\n@SuppressWarnings(\"unchecked\")\n@Override\npublic StreamsBuilder creataStream() {\n    \n    StreamsBuilder streamsBuilder = new StreamsBuilder();\n    \n    Serde<TaxPayer> taxpayerAvroSerde = new SpecificAvroSerde<>();\n    \n    taxpayerAvroSerde.configure(getSerdeProperties(), false);\n    \n    KStream<String, TaxPayer> stream = streamsBuilder.stream(getTopic(), Consumed.with(Serdes.String(), taxpayerAvroSerde));\n    \n    KStream<String, TaxPayer>[] branch = stream.branch(\n            (id, tax) -> tax.getSituation() == false,\n            (id, tax) -> tax.getSituation() == true\n            );\n    \n    branch[0].process(() -> processorFalse);\n    branch[1].process(() -> processorTrue);\n    \n    return streamsBuilder;\n}\n\nprivate Map<String, String> getSerdeProperties() {\n    return Collections.singletonMap(SCHEMA_REGISTRY_URL_CONFIG, (String)kakfaConfiguration.configureProperties().get(SCHEMA_REGISTRY_URL_CONFIG));\n}
\n

Configurando o start

\n

Com o Stream configurado é necessário fazer o start, onde será passado o Stream, as configurações do cluster Kafka, um handler de Exceptions e um hook para podermos lidar o shutdown da aplicação.

\n
@PostConstruct\n@Override\npublic void start() {\n    \n    StreamsBuilder streamsBuilder = this.creataStream();\n    \n    kafkaStreams = new KafkaStreams(streamsBuilder.build(), kakfaConfiguration.configureProperties());\n    kafkaStreams.setUncaughtExceptionHandler(this.getUncaughtExceptionHandler());\n    kafkaStreams.start();\n    \n    this.shutDown();\n}\n\n@Override\npublic void shutDown() {\n    Runtime.getRuntime().addShutdownHook(new Thread(kafkaStreams::close));\n}\n\nprivate UncaughtExceptionHandler getUncaughtExceptionHandler() {\n    return (thread, exception) -> exception.printStackTrace();\n}
\n

Produzindo em um novo tópico

\n

Um ponto muito utilizado quando se trabalha com Streams é o processamento, transformação e produção de novos fluxos de dados, então podemos simular o recebimento de uma mensagem de Taxpayer e transformamos o name pra lower case e enviamos para um novo tópico chamado name-lower-case-topic:

\n
KStream<String, String> nameLowerCase = stream.mapValues(taxpayer -> taxpayer.getName().toLowerCase());\nnameLowerCase.to(\"name-lower-case-topic\");
\n

Conclusão

\n

Aqui foi mostrado uma forma de usar Kafka Streams porém essa biblioteca é muito extensa e tem muitos recursos, para mais informações consultar as documentações do Apache Kafka Streams e da Confluent Kafka Streams

\n

Código fonte

\n

O código fonte desse projeto pode ser encontrado no GitHub

","fields":{"slug":"/kafka-streams/"},"frontmatter":{"date":"02 de fevereiro de 2021","description":"Processando fluxo de dados em tempo real","title":"Kafka Streams com Java","tags":["Kafka","Streams","Java"],"author":"Guilherme Alves","image":{"id":"6901e635-e638-5e1e-96b5-a4bbb835d5bd","publicURL":"/static/21d5b19bb315aedb69ca2c0d768e2808/stre.png","childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAOCAYAAAAvxDzwAAAACXBIWXMAAC4jAAAuIwF4pT92AAABS0lEQVQ4y7VTv6uCUBj1bzXBCgQHiyBoM3DQycnBpkJwqsWloWhoaJFsqiVQKKeIFsH0PLzwgT+Kx3uv98Hxer97PNxzPZfDh4srHnmeg0ZCuf8nwe+E6T3LMoY6h6sTqYhcFy5QrJV5NC/WOGoWFccxBoMBdrtdQ/z5fDJQ+b7PUN9QxfLj8QDP85hOp1BVFafTqXFGt9uNjZfLBfP5HLZt43g8vt5hEATo9/sMo9EI1+sVlmVhuVzC8zw4jgNRFGGaJuO6rovZbIbtdlsVJCubzQaKoqDb7cIwDCRJguFwCEmSoOs6ZFmGpmlotVoYj8fo9XpYLBbs2zRNm5YLgU6ng8lkgna7jcPhwCyez2d2rvv9nlkNw5D11us1c1H+YRXLURRBEASsVqsf5bCcgkZs7vd7hUCxoL9Mc+q9zOG7AP/mxvzP1ftkfQHnuiDrY8kdVQAAAABJRU5ErkJggg==","aspectRatio":1.4096916299559472,"src":"/static/21d5b19bb315aedb69ca2c0d768e2808/0823f/stre.png","srcSet":"/static/21d5b19bb315aedb69ca2c0d768e2808/c67b7/stre.png 320w,\n/static/21d5b19bb315aedb69ca2c0d768e2808/d3930/stre.png 640w,\n/static/21d5b19bb315aedb69ca2c0d768e2808/0823f/stre.png 1280w,\n/static/21d5b19bb315aedb69ca2c0d768e2808/17523/stre.png 1747w","sizes":"(max-width: 1280px) 100vw, 1280px"}}}},"timeToRead":8}},"pageContext":{"slug":"/kafka-streams/","previous":{"fields":{"slug":"/spring-validacao/"},"frontmatter":{"title":"Validando requisições com Spring Boot","date":"26 jan, 2021"}},"next":{"fields":{"slug":"/kafka-test/"},"frontmatter":{"title":"Testes no Kafka com JUnit","date":"11 fev, 2021"}}}},"staticQueryHashes":["63159454"]}