Flink tubería de kafka a Redis

Xingbin:

Estoy usando flink para leer desde y escribir a kafka Redis.

Para la prueba, sólo quiero leer los 10 primeros mensajes de kafka. Así que utilizo un contador y tratar de detener el consumidor cuando elcounter = 10

    AtomicInteger counter = new AtomicInteger(0);

    FlinkKafkaConsumer08<String> kafkaConsumer =
            new FlinkKafkaConsumer08<>("my topic",
                    new SimpleStringSchema() {
                        @Override
                        public boolean isEndOfStream(String nextElement) {
                            // It should only read 10 kafka message
                            return counter.getAndIncrement() > 9;
                        }
                    },
                    properties);

pero me sale el mensaje de 30 Redis:

llen rtp:example
(integer) 30

Cuando cambio a la condición counter.getAndIncrement() > 8, escribe mensajes a 27 Redis. Siempre triple.

código completo:

public class FlinkEntry {

    private final static JedisCluster JEDIS_CLUSTER;

    static {
        Set<HostAndPort> hostAndPorts = new HashSet<>();
        hostAndPorts.add(new HostAndPort("localhost", 7001));
        JEDIS_CLUSTER = new JedisCluster(hostAndPorts);
    }


    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();

        FlinkKafkaConsumer08<String> kafkaConsumer = createKafkaConsumer();
        DataStream<String> dataStream = environment.addSource(kafkaConsumer);

        SinkFunction<String> redisSink = createRedisSink();
        dataStream.addSink(redisSink);

        environment.execute();
    }

    private static FlinkKafkaConsumer08<String> createKafkaConsumer() {
        Properties properties = new Properties();
        //... set kafka property

        AtomicInteger counter = new AtomicInteger(0);

        FlinkKafkaConsumer08<String> kafkaConsumer =
                new FlinkKafkaConsumer08<>("my topic",
                        new SimpleStringSchema() {
                            @Override
                            public boolean isEndOfStream(String nextElement) {
                                // It should only read 10 kafka message
                                return counter.getAndIncrement() > 9;
                            }
                        },
                        properties);

        kafkaConsumer.setStartFromLatest();
        return kafkaConsumer;
    }

    private static SinkFunction<String> createRedisSink() {
        return new SinkFunction<String>() {
            @Override
            public void invoke(String value, Context context) {
                JEDIS_CLUSTER.lpush("rtp:example", value);
                JEDIS_CLUSTER.expire("rtp:example", 10 * 60);
            }
        };
    }

}

David Anderson:

Un enfoque para la comprensión de esto sería el encadenamiento de operador desactivar llamando

    env.disableOperatorChaining();

y luego ver algunas métricas - por ejemplo, numRecordsOut en la fuente, y numRecordsIn en el fregadero. También comprobaría el doble que todo el trabajo se está ejecutando con el conjunto de paralelismo a 1.

Tendrá que desactivar el encadenamiento porque de lo contrario todo el trabajo se derrumbará a una sola tarea, y no habrá ninguna métrica recogidos para la comunicación entre los dos operadores.