web-dev-qa-db-fra.com

Kafka Streams avec botte de printemps

Salut les gars, je veux travailler avec le traitement en temps réel de Kafka Streams dans mon projet de démarrage printanier. J'ai donc besoin de la configuration de Kafka Streams ou je veux utiliser KStreams ou KTable, mais je n'ai pas pu trouver d'exemple sur Internet. 

J'ai fait producteur et consommateur maintenant je veux diffuser en temps réel. 

spring-bootapache-kafkaapache-kafka-streamsspring-kafka
1
Alpcan Yıldız

Permettez-moi de commencer par dire que si vous êtes nouveau dans les flux Kafka, l'ajout de Spring-Boot ajoute un autre niveau de complexité et que les flux Kafka ont une grande courbe d'apprentissage en l'état. Voici les bases pour vous aider à démarrer: Pom:

 <!-- https://mvnrepository.com/artifact/org.springframework.kafka/spring-kafka -->
    <dependency>
      <groupId>org.springframework.kafka</groupId>
      <artifactId>spring-kafka</artifactId>
      <version>2.1.10.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.Apache.kafka/kafka-clients -->
    <dependency>
      <groupId>org.Apache.kafka</groupId>
      <artifactId>kafka-clients</artifactId>
      <version>${kafka.version}</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.Apache.kafka/kafka -->
    <dependency>
      <groupId>org.Apache.kafka</groupId>
      <artifactId>kafka_2.12</artifactId>
      <version>${kafka.version}</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.Apache.kafka/kafka-streams -->
    <dependency>
      <groupId>org.Apache.kafka</groupId>
      <artifactId>kafka-streams</artifactId>
      <version>${kafka.version}</version>
    </dependency>


    <!--&lt;!&ndash; https://mvnrepository.com/artifact/org.Apache.kafka/kafka-streams &ndash;&gt;-->
    <dependency>
      <groupId>org.Apache.kafka</groupId>
      <artifactId>connect-api</artifactId>
      <version>${kafka.version}</version>
    </dependency>

Maintenant l'objet de configuration. Le code ci-dessous suppose que vous créez deux applications en flux, et gardez à l'esprit que chaque application représente sa propre topologie de traitement:

import org.Apache.kafka.clients.consumer.ConsumerConfig;
import org.Apache.kafka.common.serialization.Serdes;
import org.Apache.kafka.streams.StreamsConfig;
import org.Apache.kafka.streams.processor.FailOnInvalidTimestamp;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaStreamsDefaultConfiguration;
import org.springframework.kafka.core.StreamsBuilderFactoryBean;

import Java.util.HashMap;
import Java.util.Map;

@Configuration
public class KafkaStreamConfig {

  @Value("${delivery-stats.stream.threads:1}")
  private int threads;

  @Value("${delivery-stats.kafka.replication-factor:1}")
  private int replicationFactor;

  @Value("${messaging.kafka-dp.brokers.url:localhost:9092}")
  private String brokersUrl;


  @Bean(name = KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME)
  public StreamsConfig kStreamsConfigs() {
    Map<String, Object> config = new HashMap<>();
    config.put(StreamsConfig.APPLICATION_ID_CONFIG, "default");
    setDefaults(config);
    return new StreamsConfig(config);
  }


  public void setDefaults(Map<String, Object> config) {
    config.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, brokersUrl);
    config.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
    config.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
    config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
    config.put(StreamsConfig.DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_CONFIG, FailOnInvalidTimestamp.class);
  }

  @Bean("app1StreamBuilder")
  public StreamsBuilderFactoryBean app1StreamBuilderFactoryBean() {
    Map<String, Object> config = new HashMap<>();
    setDefaults(config);
    config.put(StreamsConfig.PROCESSING_GUARANTEE_CONFIG, StreamsConfig.EXACTLY_ONCE);
    config.put(StreamsConfig.APPLICATION_ID_CONFIG, "app1");
    config.put(StreamsConfig.COMMIT_INTERVAL_MS_CONFIG, 30000);
    config.put(StreamsConfig.NUM_STREAM_THREADS_CONFIG, threads);
    config.put(StreamsConfig.REPLICATION_FACTOR_CONFIG, replicationFactor);
    return new StreamsBuilderFactoryBean(config);

  }

  //
  @Bean("app2StreamBuilder")
  public StreamsBuilderFactoryBean app2StreamBuilderFactoryBean() {
    Map<String, Object> config = new HashMap<>();
    setDefaults(config);
    config.put(StreamsConfig.PROCESSING_GUARANTEE_CONFIG, StreamsConfig.EXACTLY_ONCE);
    config.put(StreamsConfig.APPLICATION_ID_CONFIG, "app2");
    config.put(StreamsConfig.COMMIT_INTERVAL_MS_CONFIG, 30000);
    config.put(StreamsConfig.NUM_STREAM_THREADS_CONFIG, threads);
    config.put(StreamsConfig.REPLICATION_FACTOR_CONFIG, replicationFactor);
    return new StreamsBuilderFactoryBean(config);
  }
}

Maintenant vient la partie amusante, en utilisant le streamsBuilder pour construire votre application (app1 dans cet exemple).

import lombok.extern.slf4j.Slf4j;
import org.Apache.kafka.common.serialization.Serdes;
import org.Apache.kafka.streams.KeyValue;
import org.Apache.kafka.streams.StreamsBuilder;
import org.Apache.kafka.streams.kstream.Consumed;
import org.Apache.kafka.streams.kstream.KStream;
import org.Apache.kafka.streams.kstream.Produced;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class App1 {
  @SuppressWarnings("unchecked")
  @Bean("app1StreamTopology")
  public KStream<String, Long> startProcessing(@Qualifier("app1StreamBuilder") StreamsBuilder builder) {

    final KStream<String, Long> toSquare = builder.stream("toSquare", Consumed.with(Serdes.String(), Serdes.Long()));
    toSquare.map((key, value) -> { // do something with each msg, square the values in our case
      return KeyValue.pair(key, value * value);
    }).to("squared", Produced.with(Serdes.String(), Serdes.Long())); // send downstream to another topic

    return toSquare;
  }

}

J'espère que cela t'aides.

6
dmonkey

Ce n'est en fait pas une question spécifique. Si vous souhaitez effectuer un traitement de flux à l'aide de Spring et Kafka Framework, vous pouvez vérifier spring-kafka . Il existe de nombreux exemples, ici, il y a un d’eux . Vous serez en mesure de fournir des solutions à l’aide de l’API native Kafka ou de Spring-Kafka. Si vous souhaitez que cette application fasse partie d’un plus grand pipeline utilisant par exemple Spring Cloud DataFlow, je vous recommande vivement d’utiliser Spring- Kafka, sinon utilisez uniquement l’API native de Kafka. 

0
dbustosp

vous pouvez créer un nouveau projet de démarrage printanier à partir de zéro en utilisant https://start.spring.io/ , sélectionnez les versions/dépendances nécessaires en conséquence et générez/téléchargez le projet.

vous pouvez commencer à implémenter les méthodes kstream api ( https://kafka.Apache.org/10/javadoc/org/Apache/kafka/streams/kstream/KStream.html )

0
Santosh