Quarkus - Using Apache Kafka Streams

This guide demonstrates how your Quarkus application can utilize the Apache Kafka Streams API to implement stream processing applications based on Apache Kafka.

Prerequisites

To complete this guide, you need:

• less than 30 minutes

• an IDE

• JDK 1.8+ installed with JAVA_HOME configured appropriately

• Apache Maven 3.5.3+

• Docker Compose to start an Apache Kafka development cluster

• GraalVM installed if you want to run in native mode.

It is recommended, that you have read the Kafka quickstart before.

group.min.session.timeout.ms=250

kafka-streams.consumer.session.timeout.ms=250kafka-streams.consumer.heartbeat.interval.ms=200

Architecture

In this guide, we are going to generate (random) temperature values in one component (named generator).These values are associated to given weather stations and are written in a Kafka topic (temperature-values).Another topic (weather-stations) contains just the master data about the weather stations themselves (id and name).

A second component (aggregator) reads from the two Kafka topics and processes them in a streaming pipeline:

• the two topics are joined on weather station id

• per weather station the min, max and average temperature is determined

• this aggregated data is written out to a third topic (temperatures-aggregated)

The data can be examined by inspecting the output topic.By exposing a Kafka Streams interactive query,the latest result for each weather station can alternatively be obtained via a simple REST query.

The overall architecture looks like so:

Solution

We recommend that you follow the instructions in the next sections and create the application step by step.However, you can go right to the completed example.

Clone the Git repository: git clone https://github.com/quarkusio/quarkus-quickstarts.git, or download an archive.

The solution is located in the kafka-streams-quickstart directory.

Creating the Producer Maven Project

First, we need a new project with the temperature value producer.Create a new project with the following command:

mkdir producer && cd producer && \
mvn io.quarkus:quarkus-maven-plugin:1.0.0.CR1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=kafka-streams-quickstart-producer \
    -Dextensions="kafka" \
    && cd ..

This command generates a Maven project, importing the Reactive Messaging and Kafka connector extensions.

The Temperature Value Producer

Create the producer/src/main/java/org/acme/quarkus/sample/generator/ValuesGenerator.java file,with the following content:

package org.acme.quarkus.sample.generator;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.enterprise.context.ApplicationScoped;
import org.eclipse.microprofile.reactive.messaging.Outgoing;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.reactivex.Flowable;
import io.smallrye.reactive.messaging.kafka.KafkaMessage;
/**
 * A bean producing random temperature data every second.
 * The values are written to a Kafka topic (temperature-values).
 * Another topic contains the name of weather stations (weather-stations).
 * The Kafka configuration is specified in the application configuration.
 */
@ApplicationScoped
public class ValuesGenerator {
    private static final Logger LOG = LoggerFactory.getLogger(ValuesGenerator.class);
    private Random random = new Random();
    private List<WeatherStation> stations = Collections.unmodifiableList(
            Arrays.asList(
                    new WeatherStation(1, "Hamburg", 13),
                    new WeatherStation(2, "Snowdonia", 5),
                    new WeatherStation(3, "Boston", 11),
                    new WeatherStation(4, "Tokio", 16),
                    new WeatherStation(5, "Cusco", 12),
                    new WeatherStation(6, "Svalbard", -7),
                    new WeatherStation(7, "Porthsmouth", 11),
                    new WeatherStation(8, "Oslo", 7),
                    new WeatherStation(9, "Marrakesh", 20)
            ));
    @Outgoing("temperature-values")                             (1)
    public Flowable<KafkaMessage<Integer, String>> generate() {
        return Flowable.interval(500, TimeUnit.MILLISECONDS)    (2)
                .onBackpressureDrop()
                .map(tick -> {
                    WeatherStation station = stations.get(random.nextInt(stations.size()));
                    double temperature = new BigDecimal(
                                random.nextGaussian() * 15 + station.averageTemperature
                            )
                            .setScale(1, RoundingMode.HALF_UP)
                            .doubleValue();
                    LOG.info("station: {}, temperature: {}", station.name, temperature);
                    return KafkaMessage.of(station.id, Instant.now() + ";" + temperature);
                });
    }
    @Outgoing("weather-stations")                               (3)
    public Flowable<KafkaMessage<Integer, String>> weatherStations() {
        List<KafkaMessage<Integer, String>> stationsAsJson = stations.stream()
            .map(s -> KafkaMessage.of(
                    s.id,
                    "{ \"id\" : " + s.id +
                    ", \"name\" : \"" + s.name + "\" }"))
            .collect(Collectors.toList());
        return Flowable.fromIterable(stationsAsJson);
    };
    private static class WeatherStation {
        int id;
        String name;
        int averageTemperature;
        public WeatherStation(int id, String name, int averageTemperature) {
            this.id = id;
            this.name = name;
            this.averageTemperature = averageTemperature;
        }
    }
}

The two methods each return a reactive stream whose items are sent to the streams named temperature-values and weather-stations, respectively.

Topic Configuration

The two channels are mapped to Kafka topics using the Quarkus configuration file application.properties.For that, add the following to the file producer/src/main/resources/application.properties:

# Configure the Kafka broker location
kafka.bootstrap.servers=localhost:9092
mp.messaging.outgoing.temperature-values.connector=smallrye-kafka
mp.messaging.outgoing.temperature-values.key.serializer=org.apache.kafka.common.serialization.IntegerSerializer
mp.messaging.outgoing.temperature-values.value.serializer=org.apache.kafka.common.serialization.StringSerializer
mp.messaging.outgoing.weather-stations.connector=smallrye-kafka
mp.messaging.outgoing.weather-stations.key.serializer=org.apache.kafka.common.serialization.IntegerSerializer
mp.messaging.outgoing.weather-stations.value.serializer=org.apache.kafka.common.serialization.StringSerializer

This configures the Kafka bootstrap server, the two topics and the corresponding (de-)serializers.More details about the different configuration options are available on the Producer configuration and Consumer configuration section from the Kafka documentation.

Creating the Aggregator Maven Project

With the producer application in place, it’s time to implement the actual aggregator application,which will run the Kafka Streams pipeline.Create another project like so:

mkdir aggregator && cd aggregator && \
mvn io.quarkus:quarkus-maven-plugin:1.0.0.CR1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=kafka-streams-quickstart-aggregator \
    -Dextensions="kafka-streams,resteasy-jsonb" \
    && cd ..

This creates the aggregator project with the Quarkus extension for Kafka Streams and with RESTEasy support for JSON-B.

The Pipeline Implementation

Let’s begin the implementation of the stream processing application by creatinga few value objects for representing temperature measurements, weather stations and for keeping track of aggregated values.

First, create the file aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/model/WeatherStation.java,representing a weather station, with the following content:

package org.acme.quarkus.sample.kafkastreams.model;
import io.quarkus.runtime.annotations.RegisterForReflection;
@RegisterForReflection (1)
public class WeatherStation {
    public int id;
    public String name;
}

Then the file aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/model/TemperatureMeasurement.java,representing temperature measurements for a given station:

package org.acme.quarkus.sample.kafkastreams.model;
import java.time.Instant;
public class TemperatureMeasurement {
    public int stationId;
    public String stationName;
    public Instant timestamp;
    public double value;
    public TemperatureMeasurement(int stationId, String stationName, Instant timestamp,
            double value) {
        this.stationId = stationId;
        this.stationName = stationName;
        this.timestamp = timestamp;
        this.value = value;
    }
}

And finally aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/model/Aggregation.java,which will be used to keep track of the aggregated values while the events are processed in the streaming pipeline:

package org.acme.quarkus.sample.kafkastreams.model;
import java.math.BigDecimal;
import java.math.RoundingMode;
import io.quarkus.runtime.annotations.RegisterForReflection;
public class Aggregation {
    public int stationId;
    public String stationName;
    public double min = Double.MAX_VALUE;
    public double max = Double.MIN_VALUE;
    public int count;
    public double sum;
    public double avg;
    public Aggregation updateFrom(TemperatureMeasurement measurement) {
        stationId = measurement.stationId;
        stationName = measurement.stationName;
        count++;
        sum += measurement.value;
        avg = BigDecimal.valueOf(sum / count)
                .setScale(1, RoundingMode.HALF_UP).doubleValue();
        min = Math.min(min, measurement.value);
        max = Math.max(max, measurement.value);
        return this;
    }
}

Next, let’s create the actual streaming query implementation itself in the aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/streams/TopologyProducer.java file.All we need to do for that is to declare a CDI producer method which returns the Kafka Streams Topology;the Quarkus extension will take care of configuring, starting and stopping the actual Kafka Streams engine.

package org.acme.quarkus.sample.kafkastreams.streams;
import java.time.Instant;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
import org.acme.quarkus.sample.kafkastreams.model.Aggregation;
import org.acme.quarkus.sample.kafkastreams.model.TemperatureMeasurement;
import org.acme.quarkus.sample.kafkastreams.model.WeatherStation;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.Topology;
import org.apache.kafka.streams.kstream.Consumed;
import org.apache.kafka.streams.kstream.GlobalKTable;
import org.apache.kafka.streams.kstream.Materialized;
import org.apache.kafka.streams.kstream.Produced;
import org.apache.kafka.streams.state.KeyValueBytesStoreSupplier;
import org.apache.kafka.streams.state.Stores;
import io.quarkus.kafka.client.serialization.JsonbSerde;
@ApplicationScoped
public class TopologyProducer {
    static final String WEATHER_STATIONS_STORE = "weather-stations-store";
    private static final String WEATHER_STATIONS_TOPIC = "weather-stations";
    private static final String TEMPERATURE_VALUES_TOPIC = "temperature-values";
    private static final String TEMPERATURES_AGGREGATED_TOPIC = "temperatures-aggregated";
    @Produces
    public Topology buildTopology() {
        StreamsBuilder builder = new StreamsBuilder();
        JsonbSerde<WeatherStation> weatherStationSerde = new JsonbSerde<>(
                WeatherStation.class);
        JsonbSerde<Aggregation> aggregationSerde = new JsonbSerde<>(Aggregation.class);
        KeyValueBytesStoreSupplier storeSupplier = Stores.persistentKeyValueStore(
                WEATHER_STATIONS_STORE);
        GlobalKTable<Integer, WeatherStation> stations = builder.globalTable( (1)
                WEATHER_STATIONS_TOPIC,
                Consumed.with(Serdes.Integer(), weatherStationSerde));
        builder.stream(                                                       (2)
                        TEMPERATURE_VALUES_TOPIC,
                        Consumed.with(Serdes.Integer(), Serdes.String())
                )
                .join(                                                        (3)
                        stations,
                        (stationId, timestampAndValue) -> stationId,
                        (timestampAndValue, station) -> {
                            String[] parts = timestampAndValue.split(";");
                            return new TemperatureMeasurement(station.id, station.name,
                                    Instant.parse(parts[0]), Double.valueOf(parts[1]));
                        }
                )
                .groupByKey()                                                 (4)
                .aggregate(                                                   (5)
                        Aggregation::new,
                        (stationId, value, aggregation) -> aggregation.updateFrom(value),
                        Materialized.<Integer, Aggregation> as(storeSupplier)
                            .withKeySerde(Serdes.Integer())
                            .withValueSerde(aggregationSerde)
                )
                .toStream()
                .to(                                                          (6)
                        TEMPERATURES_AGGREGATED_TOPIC,
                        Produced.with(Serdes.Integer(), aggregationSerde)
                );
        return builder.build();
    }
}

The Kafka Streams extension is configured via the Quarkus configuration file application.properties.Create the file aggregator/src/main/resources/application.properties with the following contents:

quarkus.kafka-streams.bootstrap-servers=localhost:9092
quarkus.kafka-streams.application-id=temperature-aggregator
quarkus.kafka-streams.application-server=${hostname}:8080
quarkus.kafka-streams.topics=weather-stations,temperature-values
# pass-through options
kafka-streams.cache.max.bytes.buffering=10240
kafka-streams.commit.interval.ms=1000
kafka-streams.metadata.max.age.ms=500
kafka-streams.auto.offset.reset=earliest
kafka-streams.metrics.recording.level=DEBUG

The options with the quarkus.kafka-streams prefix can be changed dynamically at application startup,e.g. via environment variables or system properties.bootstrap-servers, application-id and application-server are mapped to the Kafka Streams properties bootstrap.servers, application.id and application.server, respectively.topics is specific to Quarkus: the application will wait for all the given topics to exist before launching the Kafka Streams engine.This is to done to gracefully await the creation of topics that don’t yet exist at application startup time.

All the properties within the kafka-streams namespace are passed through as-is to the Kafka Streams engine.Changing their values requires a rebuild of the application.

Building and Running the Applications

We now can build the producer and aggregator applications:

mvn clean package -f producer/pom.xml
mvn clean package -f aggregator/pom.xml

Instead of running them directly on the host machine using the Quarkus dev mode,we’re going to package them into container images and launch them via Docker Compose.This is done in order to demonstrate scaling the aggregator aggregation to multiple nodes later on.

The Dockerfile created by Quarkus by default needs one adjustment for the aggregator application in order to run the Kafka Streams pipeline.To do so, edit the file aggregator/src/main/docker/Dockerfile.jvm and replace the line FROM fabric8/java-alpine-openjdk8-jre with FROM fabric8/java-centos-openjdk8-jdk.

Next create a Docker Compose file (docker-compose.yaml) for spinning up the two applications as well as Apache Kafka and ZooKeeper like so:

version: '3.5'
services:
  zookeeper:
    image: strimzi/kafka:0.11.3-kafka-2.1.0
    command: [
      "sh", "-c",
      "bin/zookeeper-server-start.sh config/zookeeper.properties"
    ]
    ports:
      - "2181:2181"
    environment:
      LOG_DIR: /tmp/logs
    networks:
      - kafkastreams-network
  kafka:
    image: strimzi/kafka:0.11.3-kafka-2.1.0
    command: [
      "sh", "-c",
      "bin/kafka-server-start.sh config/server.properties --override listeners=$${KAFKA_LISTENERS} --override advertised.listeners=$${KAFKA_ADVERTISED_LISTENERS} --override zookeeper.connect=$${KAFKA_ZOOKEEPER_CONNECT} --override num.partitions=$${KAFKA_NUM_PARTITIONS}"
    ]
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      LOG_DIR: "/tmp/logs"
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_NUM_PARTITIONS: 3
    networks:
      - kafkastreams-network
  producer:
    image: quarkus-quickstarts/kafka-streams-producer:1.0
    build:
      context: producer
      dockerfile: src/main/docker/Dockerfile.${QUARKUS_MODE:-jvm}
    environment:
      KAFKA_BOOTSTRAP_SERVERS: kafka:9092
    networks:
      - kafkastreams-network
  aggregator:
    image: quarkus-quickstarts/kafka-streams-aggregator:1.0
    build:
      context: aggregator
      dockerfile: src/main/docker/Dockerfile.${QUARKUS_MODE:-jvm}
    environment:
      QUARKUS_KAFKA_STREAMS_BOOTSTRAP_SERVERS: kafka:9092
    networks:
      - kafkastreams-network
networks:
  kafkastreams-network:
    name: ks

To launch all the containers, building the producer and aggregator container images,run docker-compose up —build.

You should see log statements from the producer application about messages being sent to the "temperature-values" topic.

Now run an instance of the debezium/tooling image, attaching to the same network all the other containers run in.This image provides several useful tools such as kafkacat and httpie:

docker run --tty --rm -i --network ks debezium/tooling:1.0

Within the tooling container, run kafkacat to examine the results of the streaming pipeline:

kafkacat -b kafka:9092 -C -o beginning -q -t temperatures-aggregated
{"avg":34.7,"count":4,"max":49.4,"min":16.8,"stationId":9,"stationName":"Marrakesh","sum":138.8}
{"avg":15.7,"count":1,"max":15.7,"min":15.7,"stationId":2,"stationName":"Snowdonia","sum":15.7}
{"avg":12.8,"count":7,"max":25.5,"min":-13.8,"stationId":7,"stationName":"Porthsmouth","sum":89.7}
...

You should see new values arrive as the producer continues to emit temperature measurements,each value on the outbound topic showing the mininum, maxium and average temperature values of the represented weather station.

Interactive Queries

Subscribing to the temperatures-aggregated topic is a great way to react to any new temperature values.It’s a bit wasteful though if you’re just interested in the latest aggregated value for a given weather station.This is where Kafka Streams interactive queries shine:they let you directly query the underlying state store of the pipeline for the value associated to a given key.By exposing a simple REST endpoint which queries the state store,the latest aggregation result can be retrieved without having to subscribe to any Kafka topic.

Let’s begin by creating a new class InteractiveQueries in the file aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/streams/InteractiveQueries.java:

one more method to the KafkaStreamsPipeline class which obtains the current state for a given key:

package org.acme.quarkus.sample.kafkastreams.streams;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import org.acme.quarkus.sample.kafkastreams.model.Aggregation;
import org.acme.quarkus.sample.kafkastreams.model.WeatherStationData;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.errors.InvalidStateStoreException;
import org.apache.kafka.streams.state.QueryableStoreTypes;
import org.apache.kafka.streams.state.ReadOnlyKeyValueStore;
@ApplicationScoped
public class InteractiveQueries {
    @Inject
    KafkaStreams streams;
    public GetWeatherStationDataResult getWeatherStationData(int id) {
        Aggregation result = getWeatherStationStore().get(id);
        if (result != null) {
            return GetWeatherStationDataResult.found(WeatherStationData.from(result)); (1)
        }
        else {
            return GetWeatherStationDataResult.notFound();                             (2)
        }
    }
    private ReadOnlyKeyValueStore<Integer, Aggregation> getWeatherStationStore() {
        while (true) {
            try {
                return streams.store(TopologyProducer.WEATHER_STATIONS_STORE, QueryableStoreTypes.keyValueStore());
            } catch (InvalidStateStoreException e) {
                // ignore, store not ready yet
            }
        }
    }
}

Also create the method’s return type in the file aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/streams/GetWeatherStationDataResult.java:

package org.acme.quarkus.sample.kafkastreams.streams;
import java.util.Optional;
import java.util.OptionalInt;
import org.acme.quarkus.sample.kafkastreams.model.WeatherStationData;
public class GetWeatherStationDataResult {
    private static GetWeatherStationDataResult NOT_FOUND =
            new GetWeatherStationDataResult(null);
    private final WeatherStationData result;
    private GetWeatherStationDataResult(WeatherStationData result) {
        this.result = result;
    }
    public static GetWeatherStationDataResult found(WeatherStationData data) {
        return new GetWeatherStationDataResult(data);
    }
    public static GetWeatherStationDataResult notFound() {
        return NOT_FOUND;
    }
    public Optional<WeatherStationData> getResult() {
        return Optional.ofNullable(result);
    }
}

Also create aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/model/WeatherStationData.java,which represents the actual aggregation result for a weather station:

package org.acme.quarkus.sample.kafkastreams.model;
import io.quarkus.runtime.annotations.RegisterForReflection;
@RegisterForReflection
public class WeatherStationData {
    public int stationId;
    public String stationName;
    public double min = Double.MAX_VALUE;
    public double max = Double.MIN_VALUE;
    public int count;
    public double avg;
    private WeatherStationData(int stationId, String stationName, double min, double max,
            int count, double avg) {
        this.stationId = stationId;
        this.stationName = stationName;
        this.min = min;
        this.max = max;
        this.count = count;
        this.avg = avg;
    }
    public static WeatherStationData from(Aggregation aggregation) {
        return new WeatherStationData(
                aggregation.stationId,
                aggregation.stationName,
                aggregation.min,
                aggregation.max,
                aggregation.count,
                aggregation.avg);
    }
}

We now can add a simple REST endpoint (aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/rest/WeatherStationEndpoint.java),which invokes getWeatherStationData() and returns the data to the client:

package org.acme.quarkus.sample.kafkastreams.rest;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.acme.quarkus.sample.kafkastreams.streams.GetWeatherStationDataResult;
import org.acme.quarkus.sample.kafkastreams.streams.KafkaStreamsPipeline;
@ApplicationScoped
@Path("/weather-stations")
public class WeatherStationEndpoint {
    @Inject
    InteractiveQueries interactiveQueries;
    @GET
    @Path("/data/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response getWeatherStationData(@PathParam("id") int id) {
        GetWeatherStationDataResult result = interactiveQueries.getWeatherStationData(id);
        if (result.getResult().isPresent()) {  (1)
            return Response.ok(result.getResult().get()).build();
        }
        else {
            return Response.status(Status.NOT_FOUND.getStatusCode(),
                    "No data found for weather station " + id).build();
        }
    }
}

With this code in place, it’s time to rebuild the application and the aggregator service in Docker Compose:

mvn clean package -f aggregator/pom.xml
docker-compose stop aggregator
docker-compose up --build -d

This will rebuild the aggregator container and restart its service.Once that’s done, you can invoke the service’s REST API to obtain the temperature data for one of the existing stations.To do so, you can use httpie in the tooling container launched before:

http aggregator:8080/weather-stations/data/1
HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 85
Content-Type: application/json
Date: Tue, 18 Jun 2019 19:29:16 GMT
{
    "avg": 12.9,
    "count": 146,
    "max": 41.0,
    "min": -25.6,
    "stationId": 1,
    "stationName": "Hamburg"
}

Scaling Out

A very interesting trait of Kafka Streams applications is that they can be scaled out,i.e. the load and state can be distributed amongst multiple application instances running the same pipeline.Each node will then contain a subset of the aggregation results,but Kafka Streams provides you with an API to obtain the information which node is hosting a given key.The application can then either fetch the data directly from the other instance, or simply point the client to the location of that other node.

Launching multiple instances of the aggregator application will make look the overall architecture like so:

The InteractiveQueries class must be adjusted slightly for this distributed architecture:

public GetWeatherStationDataResult getWeatherStationData(int id) {
    StreamsMetadata metadata = streams.metadataForKey(                  (1)
            TopologyProducer.WEATHER_STATIONS_STORE,
            id,
            Serdes.Integer().serializer()
    );
    if (metadata == null || metadata == StreamsMetadata.NOT_AVAILABLE) {
        LOG.warn("Found no metadata for key {}", id);
        return GetWeatherStationDataResult.notFound();
    }
    else if (metadata.host().equals(host)) {                            (2)
        LOG.info("Found data for key {} locally", id);
        Aggregation result = getWeatherStationStore().get(id);
        if (result != null) {
            return GetWeatherStationDataResult.found(WeatherStationData.from(result));
        }
        else {
            return GetWeatherStationDataResult.notFound();
        }
    }
    else {                                                              (3)
        LOG.info(
            "Found data for key {} on remote host {}:{}",
            id,
            metadata.host(),
            metadata.port()
        );
        return GetWeatherStationDataResult.foundRemotely(metadata.host(), metadata.port());
    }
}
public List<PipelineMetadata> getMetaData() {                           (4)
    return streams.allMetadataForStore(TopologyProducer.WEATHER_STATIONS_STORE)
            .stream()
            .map(m -> new PipelineMetadata(
                    m.hostInfo().host() + ":" + m.hostInfo().port(),
                    m.topicPartitions()
                        .stream()
                        .map(TopicPartition::toString)
                        .collect(Collectors.toSet()))
            )
            .collect(Collectors.toList());
}

The GetWeatherStationDataResult type must be adjusted accordingly:

package org.acme.quarkus.sample.kafkastreams.streams;
import java.util.Optional;
import java.util.OptionalInt;
import org.acme.quarkus.sample.kafkastreams.model.WeatherStationData;
public class GetWeatherStationDataResult {
    private static GetWeatherStationDataResult NOT_FOUND =
            new GetWeatherStationDataResult(null, null, null);
    private final WeatherStationData result;
    private final String host;
    private final Integer port;
    private GetWeatherStationDataResult(WeatherStationData result, String host,
            Integer port) {
        this.result = result;
        this.host = host;
        this.port = port;
    }
    public static GetWeatherStationDataResult found(WeatherStationData data) {
        return new GetWeatherStationDataResult(data, null, null);
    }
    public static GetWeatherStationDataResult foundRemotely(String host, int port) {
        return new GetWeatherStationDataResult(null, host, port);
    }
    public static GetWeatherStationDataResult notFound() {
        return NOT_FOUND;
    }
    public Optional<WeatherStationData> getResult() {
        return Optional.ofNullable(result);
    }
    public Optional<String> getHost() {
        return Optional.ofNullable(host);
    }
    public OptionalInt getPort() {
        return port != null ? OptionalInt.of(port) : OptionalInt.empty();
    }
}

Also the return type for getMetaData() must be defined(aggregator/src/main/java/org/acme/quarkus/sample/kafkastreams/streams/PipelineMetadata.java):

package org.acme.quarkus.sample.kafkastreams.streams;
import java.util.Set;
public class PipelineMetadata {
    public String host;
    public Set<String> partitions;
    public PipelineMetadata(String host, Set<String> partitions) {
        this.host = host;
        this.partitions = partitions;
    }
}

Lastly, the REST endpoint class must be updated:

package org.acme.quarkus.sample.kafkastreams.rest;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.acme.quarkus.sample.kafkastreams.streams.GetWeatherStationDataResult;
import org.acme.quarkus.sample.kafkastreams.streams.KafkaStreamsPipeline;
import org.acme.quarkus.sample.kafkastreams.streams.PipelineMetadata;
@ApplicationScoped
@Path("/weather-stations")
public class WeatherStationEndpoint {
    @Inject
    InteractiveQueries interactiveQueries;
    @GET
    @Path("/data/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response getWeatherStationData(@PathParam("id") int id) {
        GetWeatherStationDataResult result = interactiveQueries.getWeatherStationData(id);
        if (result.getResult().isPresent()) {                     (1)
            return Response.ok(result.getResult().get()).build();
        }
        else if (result.getHost().isPresent()) {                  (2)
            URI otherUri = getOtherUri(result.getHost().get(), result.getPort().getAsInt(),
                    id);
            return Response.seeOther(otherUri).build();
        }
        else {                                                    (3)
            return Response.status(Status.NOT_FOUND.getStatusCode(),
                    "No data found for weather station " + id).build();
        }
    }
    @GET
    @Path("/meta-data")
    @Produces(MediaType.APPLICATION_JSON)
    public List<PipelineMetadata> getMetaData() {                 (4)
        return interactiveQueries.getMetaData();
    }
    private URI getOtherUri(String host, int port, int id) {
        try {
            return new URI("http://" + host + ":" + port + "/weather-stations/data/" + id);
        }
        catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }
}

Now stop the aggregator service again and rebuild it.Then let’s spin up three instances of it:

mvn clean package -f aggregator/pom.xml
docker-compose stop aggregator
docker-compose up --build -d --scale aggregator=3

When invoking the REST API on any of the three instances, it might either bethat the aggregation for the requested weather station id is stored locally on the node receiving the query,or it could be stored on one of the other two nodes.

As the load balancer of Docker Compose will distribute requests to the aggregator service in a round-robin fashion,we’ll invoke the actual nodes directly.The application exposes information about all the host names via REST:

http aggregator:8080/weather-stations/meta-data
HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 202
Content-Type: application/json
Date: Tue, 18 Jun 2019 20:00:23 GMT
[
    {
        "host": "2af13fe516a9:8080",
        "partitions": [
            "temperature-values-2"
        ]
    },
    {
        "host": "32cc8309611b:8080",
        "partitions": [
            "temperature-values-1"
        ]
    },
    {
        "host": "1eb39af8d587:8080",
        "partitions": [
            "temperature-values-0"
        ]
    }
]

Retrieve the data from one of the three hosts shown in the response(your actual host names will differ):

http 2af13fe516a9:8080/weather-stations/data/1

If that node holds the data for key "1", you’ll get a response like this:

HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 74
Content-Type: application/json
Date: Tue, 11 Jun 2019 19:16:31 GMT
{
  "avg": 11.9,
  "count": 259,
  "max": 50.0,
  "min": -30.1,
  "stationId": 1,
  "stationName": "Hamburg"
}

Otherwise, the service will send a redirect:

HTTP/1.1 303 See Other
Connection: keep-alive
Content-Length: 0
Date: Tue, 18 Jun 2019 20:01:03 GMT
Location: http://1eb39af8d587:8080/weather-stations/data/1

You can also have httpie automatically follow the redirect by passing the —follow option:

http --follow 2af13fe516a9:8080/weather-stations/data/1

Running Natively

The Quarkus extension for Kafka Streams enables the execution of stream processing applicationsnatively via GraalVM without further configuration.

To run both the producer and aggregator applications in native mode,the Maven builds can be executed using the native profile:

mvn clean package -f producer/pom.xml -Pnative -Dnative-image.container-runtime=docker
mvn clean package -f aggregator/pom.xml -Pnative -Dnative-image.container-runtime=docker

Now create an environment variable named QUARKUS_MODE and with value set to "native":

export QUARKUS_MODE=native

This is used by the Docker Compose file to use the correct Dockerfile when building the producer and aggregator images.The Kafka Streams application can work with less than 50 MB RSS in native mode.To do so, add the Xmx option to the program invocation in aggregator/src/main/docker/Dockerfile.native:

CMD ["./application", "-Dquarkus.http.host=0.0.0.0", "-Xmx32m"]

Now start Docker Compose as described above(don’t forget to rebuild the container images).

Going Further

This guide has shown how you can build stream processing applications using Quarkus and the Kafka Streams APIs,both in JVM and native modes.For running your KStreams application in production, you could also add health checks and metrics for the data pipeline.Refer to the Quarkus guides on metrics and health checks to learn more.

Configuration Reference

Configuration property fixed at build time - ️ Configuration property overridable at runtime