Flink DataStream Connectors 之 Elasticsearch 连接器

京河小蚁

已于 2022-06-19 23:20:05 修改

阅读量1.6k

点赞数

分类专栏： flink 文章标签： elasticsearch flink

于 2022-06-19 23:18:29 首次发布

本文链接：https://blog.csdn.net/u010772882/article/details/125363121

版权

flink 专栏收录该内容

86 篇文章 32 订阅

订阅专栏

文章目录

Elasticsearch Sink 官方案例
提供一个自定义 RichSinkFunction的es sink案例
- 代码地址

此连接器提供可以向 Elasticsearch 索引请求文档操作的 sinks。要使用此连接器，请根据 Elasticsearch 的安装版本将以下依赖之一添加到你的项目中：

在这里插入图片描述
请注意，流连接器目前不是二进制发行版的一部分。有关如何将程序和用于集群执行的库一起打包，参考此文档。

Elasticsearch Sink 官方案例

Elasticsearch 7:


package com.happy.connectors.elasticsearch;

import org.apache.flink.connector.base.DeliveryGuarantee;
import org.apache.flink.connector.elasticsearch.sink.Elasticsearch7SinkBuilder;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Requests;

import java.util.HashMap;
import java.util.Map;

/**
 * @author happy
 * @since 2022/6/19
 */
public class FlinkBuiltInES7Sink {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        String ip = "localhost";
        if (args.length == 1) {
            ip = args[0];
        }
        DataStreamSource<String> source = env.socketTextStream(ip, 9999);
        source.sinkTo(new Elasticsearch7SinkBuilder<String>()
                .setBulkFlushMaxActions(1)
                .setBulkFlushInterval(30000L)
                .setBulkFlushMaxSizeMb(5)
                .setConnectionPassword("pwd")
                .setConnectionUsername("username")
                .setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
                .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
                .setEmitter((element, context, indexer) ->
                        indexer.add(createIndexRequest(element)))
                .build()
        );

        env.execute();
    }

    private static IndexRequest createIndexRequest(String element) {
        Map<String, Object> json = new HashMap<>();
        json.put("data", element);

        return Requests.indexRequest()
                .index("my-index")
                .id(element)
                .source(json);
    }
}

需要注意的是，该示例仅演示了对每个传入的元素执行单个索引请求。通常，ElasticsearchSinkFunction 可用于执行多个不同类型的请求（例如 DeleteRequest、 UpdateRequest 等）。

在内部，Flink Elasticsearch Sink 的每个并行实例使用一个 BulkProcessor 向集群发送操作请求。这会在元素批量发送到集群之前进行缓存。 BulkProcessor 一次执行一个批量请求，即不会存在两个并行刷新缓存的操作。

Elasticsearch Sinks 和容错

通过启用 Flink checkpoint，Flink Elasticsearch Sink 保证至少一次将操作请求发送到 Elasticsearch 集群。这是通过在进行 checkpoint 时等待 BulkProcessor 中所有挂起的操作请求来实现。这有效地保证了在触发 checkpoint 之前所有的请求被 Elasticsearch 成功确认，然后继续处理发送到 sink 的记录。

关于 checkpoint 和容错的更多详细信息，请参见容错文档。

要使用具有容错特性的 Elasticsearch Sinks，需要在执行环境中启用作业拓扑的 checkpoint：

Elasticsearch 7:

final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.enableCheckpointing(5000); // 每 5000 毫秒执行一次 checkpoint

Elasticsearch7SinkBuilder sinkBuilder = new Elasticsearch7SinkBuilder<String>()
// 该配置上面案例中已经加了
    .setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
    .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
    .setEmitter(
    (element, context, indexer) -> 
    indexer.add(createIndexRequest(element)));

处理失败的 Elasticsearch 请求

Elasticsearch 操作请求可能由于多种原因而失败，包括节点队列容量暂时已满或者要被索引的文档格式错误。 Flink Elasticsearch Sink 允许用户通过通过指定一个退避策略来重试请求。

Elasticsearch 7:

DataStream<String> input = ...;

input.sinkTo(
    new Elasticsearch7SinkBuilder<String>()
        .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
        .setEmitter(
        (element, context, indexer) ->
        indexer.add(createIndexRequest(element)))
        // 这里启用了一个指数退避重试策略，初始延迟为 1000 毫秒且最大重试次数为 5
        .setBulkFlushBackoffStrategy(FlushBackoffType.EXPONENTIAL, 5, 1000)
        .build());

上面的示例 sink 重新添加由于资源受限（例如：队列容量已满）而失败的请求。对于其它类型的故障，例如文档格式错误，sink 将会失败。如若未设置 BulkFlushBackoffStrategy (或者 FlushBackoffType.NONE)，那么任何类型的错误都会导致 sink 失败。

重要提示：在失败时将请求重新添加回内部 BulkProcessor 会导致更长的 checkpoint，因为在进行 checkpoint 时，sink 还需要等待重新添加的请求被刷新。例如，当使用 FlushBackoffType.EXPONENTIAL 时， checkpoint 会进行等待，直到 Elasticsearch 节点队列有足够的容量来处理所有挂起的请求，或者达到最大重试次数。

配置内部批量处理器

通过使用以下在 Elasticsearch6SinkBuilder 中提供的方法，可以进一步配置内部的 BulkProcessor 关于其如何刷新缓存操作请求的行为：

setBulkFlushMaxActions(int numMaxActions)：刷新前最大缓存的操作数。
setBulkFlushMaxSizeMb(int maxSizeMb)：刷新前最大缓存的数据量（以兆字节为单位）。
setBulkFlushInterval(long intervalMillis)：刷新的时间间隔（不论缓存操作的数量或大小如何）。

还支持配置如何对暂时性请求错误进行重试：

setBulkFlushBackoffStrategy(FlushBackoffType flushBackoffType, int maxRetries, long delayMillis)：退避延迟的类型，CONSTANT 或者 EXPONENTIAL，退避重试次数，退避重试的时间间隔。对于常量延迟来说，此值是每次重试间的间隔。对于指数延迟来说，此值是延迟的初始值。

可以在此文档找到 Elasticsearch 的更多信息。

提供一个自定义 RichSinkFunction的es sink案例

代码地址

https://github.com/DeveloperZJQ/learning-flink/blob/master/flink-learning-connectors/src/main/java/com/happy/connectors/elasticsearch/ESHighRestBulkProcessorWriter.java

pom依赖

        <dependency>
            <groupId>io.searchbox</groupId>
            <artifactId>jest</artifactId>
            <version>6.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>5.6.3</version>
        </dependency>

代码

package com.happy.connectors.elasticsearch;

import lombok.extern.slf4j.Slf4j;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.threadpool.ThreadPool;

import java.util.Properties;

/**
 * @author happy
 * @since 2020-11-12
 */
@Slf4j
public class ESHighRestBulkProcessorWriter extends RichSinkFunction<String> {
    private Properties para;
    private static RestHighLevelClient restHighLevelClient = null;
    private static BulkProcessor bulkProcessor = null;

    @Override
    public void open(Configuration parameters) throws Exception {
        initESClient();
        initBulkProcessor();
    }

    @Override
    public void invoke(String value, Context context) throws Exception {
        String indexName = "test001";
        String type = "banji";
        String id = "123213213";
        bulkProcessor.add(new IndexRequest(indexName,type,id).source(value));
    }

    @Override
    public void close() throws Exception {
        super.close();
        if (bulkProcessor!=null){
            bulkProcessor.close();
        }
    }

    void initESClient() {
        BasicCredentialsProvider basicCredentialsProvider = new BasicCredentialsProvider();
        basicCredentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("es.cluster.name", "pwd"));

        String[] esHost = "192.168.1.11,192.168.1.12,192.168.1.13".split(",");
        HttpHost[] httpHosts = new HttpHost[esHost.length];

        for (int i = 0; i < esHost.length; i++) {
            httpHosts[i] = new HttpHost(esHost[i], 9200, "http");
        }

        restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(httpHosts)
                .setRequestConfigCallback(builder -> {
                    builder.setConnectionRequestTimeout(10000);
                    builder.setConnectTimeout(10000);
                    builder.setSocketTimeout(10000);
                    return builder;
                })
                .setHttpClientConfigCallback(httpAsyncClientBuilder -> {
                    httpAsyncClientBuilder.disableAuthCaching();
                    httpAsyncClientBuilder.setMaxConnPerRoute(3);
                    httpAsyncClientBuilder.setMaxConnTotal(100);
                    return httpAsyncClientBuilder.setDefaultCredentialsProvider(basicCredentialsProvider);
                }).build()
        );
    }


    /**
     * 初始化BulkProcessor
     */
    void initBulkProcessor() {
        Settings settings = Settings.EMPTY;
        ThreadPool threadPool = new ThreadPool(settings);
        BulkProcessor.Listener listener = new BulkProcessor.Listener() {
            @Override
            public void beforeBulk(long l, BulkRequest bulkRequest) {
                int numberOfActions = bulkRequest.numberOfActions();
                log.info("Executing bulk [{}] with {} requests", l, numberOfActions);
            }

            @Override
            public void afterBulk(long l, BulkRequest bulkRequest, BulkResponse bulkResponse) {
                if (bulkResponse.hasFailures()) {
                    log.warn("Bulk [{}] executed with failure", l);
                } else {
                    log.info("Bulk [{}] completed in {} milliseconds", l, bulkResponse.getTook().getMillis());
                }
            }

            @Override
            public void afterBulk(long l, BulkRequest bulkRequest, Throwable throwable) {
                log.error("Failed to executed bulk", throwable);
            }
        };
    }
}

京河小蚁

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
Flink DataStream Connectors 之 Elasticsearch 连接器

此连接器提供可以向 Elasticsearch 索引请求文档操作的 sinks。要使用此连接器，请根据 Elasticsearch 的安装版本将以下依赖之一添加到你的项目中：请注意，流连接器目前不是二进制发行版的一部分。有关如何将程序和用于集群执行的库一起打包，参考此文档。需要注意的是，该示例仅演示了对每个传入的元素执行单个索引请求。通常，ElasticsearchSinkFunction 可用于执行多个不同类型的请求（例如 DeleteRequest、 UpdateRequest 等）。在内部，
复制链接

扫一扫