关于elasticsearch的问题解决记录

最新推荐文章于 2024-08-09 10:29:04 发布
最新推荐文章于 2024-08-09 10:29:04 发布
阅读量5.4k 收藏 1
点赞数 5
分类专栏： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vampirehgg/article/details/70339831
版权

最近有这样一个需求，需要修改一个字段的mapping和要添加一个字段，新增字段和老的字段value要一样，也就是要复制一个字段的值到这个新增字段上来，保持两个内容一致，新增字段做不分词处理，用来精确匹配搜索。但elasticsearch的mapping是不能修改的，所以只好新建一个索引，重新定义mapping之后再导入数据。数据量比较大，有1500W+数据。
之前有人写过一个导入数据的程序。代码如下：

首先创建一个工厂类ClientFactory.class:

package com.dimonho.es.commons;

import java.lang.reflect.Constructor;

import org.apache.log4j.Logger;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;

/**
 * ES客户端工厂类
 */
public class ClientFactory{

    private static final Logger LOGGER = Logger.getLogger(ClientFactory.class);

    /**
     * ES请求地址
     */
    private String address;

    /**
     * ES集群名字
     */
    private String clusterName;

    private TransportClient client;

    public static final int DEFAULT_ES_PORT=9300;

    /**
     * 初始化方法，使用配置的参数来构建一个客户端
     */
    public void init(){
        LOGGER.info(String.format("初始化ES链接:%s(%s)",address,clusterName));
        Settings defaultSettings = ImmutableSettings.settingsBuilder().put("client.transport.sniff", false)
                .put("client.transport.ignore_cluster_name", true)
                 .put("index.similarity.default.type", "default")
                 .put("cluster.name",clusterName)
                .build();
        try {
            Class<?> clazz = Class.forName(TransportClient.class.getName());
            Constructor<?> constructor = clazz.getDeclaredConstructor(Settings.class);
            constructor.setAccessible(true);
            client = (TransportClient) constructor.newInstance(defaultSettings);
            String[] addrs = address.split(",");
            for(String str : addrs){
                String[] items = str.split(":");
                if(items.length==2){
                    client.addTransportAddress(new InetSocketTransportAddress(items[0], Integer.valueOf(items[1])));
                }else if(items.length ==1){
                    client.addTransportAddress(new InetSocketTransportAddress(items[0], DEFAULT_ES_PORT));
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 取得实例
     * @return
     */
    public  Client getTransportClient() {
        return client;
    }

    public Client getTransportClient(String clusterName,String ip,Integer port){
        return createClient(clusterName,ip,port);
    }

    /**
     * 创建一个客户端
     * @param clusterName
     * @param ip
     * @param port
     * @return
     */
    public Client createClient(String clusterName,String ip,Integer port){
        Settings settings = ImmutableSettings.settingsBuilder().put("client.transport.sniff", false)
                .put("client.transport.ignore_cluster_name", true)
                .put("index.similarity.default.type", "default")
                .put("cluster.name",clusterName)
                .build();
        return createClient(settings,ip,port);
    }

    public Client createClient(Settings settings,String ip,Integer port){
        TransportClient client =  new TransportClient(settings);
        client.addTransportAddress(new InetSocketTransportAddress(ip,port));
        return client;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getClusterName() {
        return clusterName;
    }

    public void setClusterName(String clusterName) {
        this.clusterName = clusterName;
    }

}

封装一些查询方法类ScanQuery.class：

package com.dimonho.es.commons;

import java.util.Iterator;

import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHit;

public class ScanQuery {

    public class BulkInterator implements Iterator<SearchHit>{

        private SearchHit[] hits;

        private String scrollId ;

        /**当前scroll的数据量*/
        private int count =0;

        /**当前scroll的指针*/
        private int index =0 ;

        /**查询总共的数据量*/
        private long total  = 0 ;

        /**统计的数据总量*/
        private long counter = 0;

        private TimeValue time;

        private Client client;

        public BulkInterator(Client client ,String scrollId,long total,TimeValue time){
            this.client = client;
            this.scrollId =scrollId;
            this.total = total;
            this.time = time;
        }

        @Override
        public boolean hasNext() {
            if(count == index){
                SearchResponse searchResponse = client.prepareSearchScroll(scrollId)
                        .setScroll(time)
                        .execute().actionGet();
                count = searchResponse.getHits().hits().length;
                if(count >0){//还有数据
                    hits = searchResponse.getHits().hits();
                    index =0 ;
                    return true;
                }
            }else if(index < count){
                return true;
            }
            return false;
        }

        @Override
        public SearchHit next() {
            counter++;
            return hits[index++];
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

        public long getTotal() {
            return total;
        }

        public long getCounter() {
            return counter;
        }

    }

    public Iterator<SearchHit> query(Client client,String indexName){
        return query(client,indexName,null,null,null);
    }

    public Iterator<SearchHit> query(Client client,String indexName,String[] types){
        return query(client,indexName,types,null,null);
    }

    public Iterator<SearchHit> query(Client client,String indexName,String[] types,QueryBuilder queryBuilder,FilterBuilder filterBuilder){
        return query(client,indexName,types,queryBuilder,filterBuilder,TimeValue.timeValueSeconds(1),TimeValue.timeValueMinutes(8));
    }

    public Iterator<SearchHit> query(Client client,String indexName,String[] types,QueryBuilder queryBuilder,FilterBuilder filterBuilder,TimeValue scanTime,TimeValue scollTime ){
        SearchResponse searchResponse  = null;
        SearchRequestBuilder builder  =  client.prepareSearch(indexName ).setSize(100);
        if(queryBuilder!=null){
            builder.setQuery(queryBuilder);
        }
        if(filterBuilder != null){
            builder.setPostFilter(filterBuilder);
        }
        if(types != null && types.length > 0){
            builder.setTypes(types);
        }
        builder.setSearchType(SearchType.SCAN)
               .setScroll(scanTime);
        searchResponse = builder.execute().actionGet();
        return new BulkInterator(client,searchResponse.getScrollId(),searchResponse.getHits().getTotalHits(),scollTime);
    }
}

批量插入处理工具类BulkUtils.class

package com.dimonho.es.utils;

import java.util.List;
import java.util.Map;

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.action.index.IndexRequestBuilder;
import org.elasticsearch.client.Client;

/**
 * 批量插入处理类
 *
 */
public class BulkUtils {

    public static abstract class AbstractBulkListener implements BulkProcessor.Listener{

        protected int total;

        @Override
        public void beforeBulk(long executionId, BulkRequest request) {
        }

        @Override
        public void afterBulk(long executionId, BulkRequest request, BulkResponse response) {
            total += request.requests().size();
        }

        @Override
        public void afterBulk(long executionId, BulkRequest request, Throwable failure) {

        }

        public int getTotal() {
            return total;
        }

        public void setTotal(int total) {
            this.total = total;
        }

    }

    public static BulkProcessor buildBulk(Client client,int requestSize,AbstractBulkListener listener){
        return BulkProcessor.builder(client, listener).setConcurrentRequests(requestSize).build();
    }

    public static void insert(Client client,BulkProcessor processor,String indexName,String type,Map<String,Object> source){
        IndexRequestBuilder indexRequestBuilder = client
                .prepareIndex(indexName,type).setOpType(IndexRequest.OpType.INDEX);
        if (source!=null && null != source.get("_id")) {
            String id = (String)source.remove("_id");
            indexRequestBuilder.setId(id);
        }
        indexRequestBuilder.setSource(source);
        indexRequestBuilder.setOpType(IndexRequest.OpType.CREATE);
        processor.add(indexRequestBuilder.request());
    }

    public static void insert(Client client,BulkProcessor processor,String indexName,String type,List<Map<String,Object>> sources){
        for(Map<String,Object> source : sources){
            insert(client,processor,indexName,type,source);
        }
    }
}

数据复制测试类BulkUtilsTest.class

package com.dimonho.es.commons;

import java.util.Date;
import java.util.Map;

import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.Client;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.dimonho.es.utils.BulkUtils;
import com.dimonho.es.utils.BulkUtils.AbstractBulkListener;
import com.dimonho.es.commons.ScanQuery.BulkInterator;

/**
 * 批量插入测试
 */
public class BulkUtilsTest {

    //目标索引
    private String targetIndex = "wos_source";

    //源索引
    private String sourceIndex = "wos_source";

    private Client sourceClient;

    private Client targetClient;

    @Before
    public void before(){
        ClientFactory clientFactory = new ClientFactory();
        sourceClient= clientFactory.getTransportClient("our_es", "192.168.1.75", 9300);
        targetClient = clientFactory.getTransportClient("our_es", "www.dimonho.com", 9300);

    }

    @After
    public void after(){
        //IndexUtils.deleteIndex(targetClient, targetIndex);
    }

    @Test
    public void testBulkInsert(){

        ScanQuery query = new ScanQuery();
        BulkInterator ite = (BulkInterator)query.query(sourceClient, sourceIndex,new String[]{"periodical"},null,null);
        System.out.println("共查询到数据:"+ite.getTotal()+"条");
        BulkProcessor processor = BulkUtils.buildBulk(targetClient, 2000, new AbstractBulkListener(){

            @Override
            public void afterBulk(long executionId, BulkRequest request, BulkResponse response) {
                total += request.requests().size();
                String dateStr = (new Date()).toString();
                System.out.println("  |-已导入[" + total + "]条数据! - " + dateStr + " - index:["
                        + targetIndex + "] - type:[periodical]");
                if(response.hasFailures()){
                    for(BulkItemResponse item : response.getItems()){
                        if(item.isFailed()){
                            System.out.println("失败信息:[periodical],id:["+item.getId()+"]"+item.getFailureMessage());
                        }
                    }
                }
            }

            @Override
            public void afterBulk(long executionId, BulkRequest request, Throwable failure) {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append("\r\n").append(">>>>>>>>>>>>>>>><<<<<<<<<<<<<<<");
                stringBuilder.append("\r\nbulk操作异常,异常信息: ").append("\r\n")
                        .append(failure.getMessage()).append("\r\n")
                        .append(failure.getLocalizedMessage()).append("\r\n")
                        .append(failure.getCause());
                stringBuilder.append("\r\n请求数：").append(request.numberOfActions());
                stringBuilder.append("\r\n").append(">>>>>>>>>>>>>>>><<<<<<<<<<<<<<<")
                        .append("\r\n");
                System.out.println(stringBuilder.toString());
                System.out.println("处理出错:"+failure);
            }


        });
        Map<String,Object> result = null;
        while(ite.hasNext()){
            result = ite.next().getSource();
            //复制jornal字段的值到新加的字段jornalName
            result.put("jornalName", result.get("jornal"));
            BulkUtils.insert(sourceClient, processor, targetIndex, "periodical", result);
            if(ite.getCounter()%2000 == 0L){
                System.out.println(ite.getCounter());
            }
            if(ite.getCounter() == ite.getTotal()){
                break;
            }
        }
    }

}

但是当用junit执行testBulkInsert()方法进行数据复制的时候。。。
no node available

回到ES服务器去查看日志：
超时

因为是远程复制，源和目标index不在同一个局域网，有时候网络不佳，客户端和服务端连接超时的现象会报“no node avaliable”的错误。于是我把超时时间设置的长一点，从之前的20S改成了60S，依然报错，只不过这次是GC错误，我想应该是多线程一边不停的往BulkRequest中添加数据，一边execute的又比较慢，导致BulkRequest中积压的数据越来越多，最后JVM内存不够用了。

最终只好自己重新写了一个，代码如下：

package com.dimonho.es.commons;

import java.util.Map;

import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.junit.Before;
import org.junit.Test;

/**
 * 数据迁移测试
 *
 */
public class MoveDataTest {

    private String sourceClusterName = "our_es";

    private String targetClusterName = "our_es";
    //源索引
    private String sourceIndex = "wos_source";
    //目标索引
    private String targetIndex = "wos_source";

    private String sourceType = "periodical";

    private String targetType = "periodical";

    private Client sourceClient;

    private Client targetClient;

    private static int errcount = 0;

    @Before
    public void before(){
        ClientFactory clientFactory = new ClientFactory();
        sourceClient = clientFactory.getTransportClient(sourceClusterName, "192.168.1.75", 9300);
        targetClient = clientFactory.getTransportClient(targetClusterName, "www.dimonho.com", 9300);

    }

    @Test
    public void bulkMove(){
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        SearchResponse sourceDatas = sourceClient.prepareSearch(sourceIndex)
                .setTypes(sourceType)
                .setQuery(queryBuilder)
                .setSize(2000)
                .setScroll(TimeValue.timeValueSeconds(2))
                .setSearchType(SearchType.SCAN)
                .execute()
                .actionGet();
        long sumCount = sourceDatas.getHits().getTotalHits();
        System.out.println("========共查询出"+sumCount+"条数据===========");

        String scrollId = sourceDatas.getScrollId();
        System.out.println("scrollId:"+scrollId);
        BulkRequestBuilder bulkRequest = getBulkRequestBuilder();

        while(true){
            SearchResponse scrollResponse = sourceClient.prepareSearchScroll(scrollId)
                    .setScroll(TimeValue.timeValueMinutes(8)).execute().actionGet();
            SearchHit[] hits = scrollResponse.getHits().hits();
            int count = hits.length;
            sumCount -= count;
            if(count == 0){
                break;
            }
            for(SearchHit hit:hits){
                Map<String,Object> source = hit.getSource();
                source.put("journalName", hit.getSource().get("journal"));
                IndexRequestBuilder indexRequesBuider = getIindexRequesBuider();
                if (source!=null && null != source.get("_id")) {
                    String id = (String)source.remove("_id");

                    indexRequesBuider.setId(id);
                }
                indexRequesBuider.setOpType(IndexRequest.OpType.CREATE);
                bulkRequest.add(indexRequesBuider.setSource(source));
            }
            insert(bulkRequest);

            bulkRequest = getBulkRequestBuilder();
            System.out.println("还剩"+sumCount+"条数据待导入。。。。。。。。。。。。。。。");

        }

    }

    private void insert(BulkRequestBuilder bulkRequest) {
        try{
            //如果中途失败，bulkRequest可能还有值未完全插入，需要检测是否有值再重新执行插入。
            if (bulkRequest.request().requests().size() != 0){
                //BulkResponse接收失败信息
                BulkResponse bulkResponse = bulkRequest.execute().actionGet();
                if(bulkResponse.hasFailures()){
                    int succes = 0;
                    for(BulkItemResponse item : bulkResponse.getItems()){
                        if(item.isFailed()){
                            errcount++;
                        }else{
                            succes++;
                        }
                    }
                    System.out.println();
                    System.out.println("失败"+errcount+"条\n"+bulkRequest.request().requests().size()+"》》成功:"+succes+"条");
                }
            }
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("连接目标服务器失败！重新连接。。。。");
            try {
                Thread.sleep(10000);
                insert(bulkRequest);//防止出现链接超时现象，自动重新运行。
            } catch (InterruptedException e1) {
                e1.printStackTrace();
                insert(bulkRequest);//防止出现链接超时现象，自动重新运行。
            }

        }
    }

    public IndexRequestBuilder getIindexRequesBuider(){
        try{
            return targetClient.prepareIndex(targetIndex, targetType);
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("获取IindexRequesBuider实例失败，重新获取。。。。。");
            try {
                Thread.sleep(10000);
                return getIindexRequesBuider();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
                return getIindexRequesBuider();
            }

        }
    }

    public BulkRequestBuilder getBulkRequestBuilder(){
        try {
            return targetClient.prepareBulk();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("获取BulkRequestBuilder实例失败，重新获取。。。。。");
            try {
                Thread.sleep(10000);
                return getBulkRequestBuilder();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
                return getBulkRequestBuilder();
            }
        }
    }
}

这样虽然比多线程慢了一点，不过如果连接超时它会自动再去尝试连接，可以无人值守放在那运行一晚上了。

DimonHo
关注
专栏目录
Elasticsearch案例分析（一）：Bulk异常导致Elasticsearch内存泄漏
桃花惜春风
09-15 7305
这周三线上股票板块的Elasticsearch集群发生了很严重的内存泄漏，本身数据量不大的一个集群，占用内存却非常的高，甚至内存占用已经超过了数据总量。最终是通过临时重启解决问题。 虽然重启释放掉了内存空间，但问题原因没找到，就意味着还有可能发生。由于这是一个新搭建不久的集群，也是本人迷之自信，直接上6.3.0。就我目前对Elasticsearch的了解和解决方案，各种招数都试了，还是没...
[Elasticsearch] ES更新问题踩坑记录
m0_67306446的博客
05-10 616
drop table if exists tmp.test_create_table; create table if not exists tmp.test_create_table( id int, name string ) stored as parquet; 问题排查 查看ES数据 发现ES创建表的状态没有正常更新 yn 还是0 查看日志 查看日志, 截取部分关键信息: ReceiverController] [4eb1c8fd7b 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视
MySQL 与 Elasticsearch 数据不对称问题解决办法
09-09
主要介绍了MySQL 与 Elasticsearch 数据不对称问题解决办法的相关资料,对于 elasticsearch 增量写入，但经常jdbc源一端的数据库可能会做数据库删除或者更新操作，这里提供解决办法，需要的朋友可以参考下
Elasticsearch报错：java.lang.NoSuchMethodError：org.elasticsearch.action.bulk.BulkRequest.pipeline（）Ljav
qq_42727102的博客
01-12 2864
1.今天在使用Elasticsearch时，报错：java.lang.NoSuchMethodError：org.elasticsearch.action.bulk.BulkRequest.pipeline（）Ljava / lang / String; 2.最后找出原因是：依赖包版本不一致导致的 3.用下面的依赖即可： <dependency> <gro...
【开源社区】Elasticsearch（ES）中空值字段 null_value 及通过exists查找非空文档
最新发布
Elastic开源社区
08-09 1154
字段，而此时源数据和搜索词都会被分词，如果给出了 null_value，ES 就不知道应不应该给这个 null_value 的值分词了，null_value 替换的原本就是索引数据，如果分词可能会影响搜索结果的准确性，使用户得到意想不到的结果，但是如果部分词又违背了 text 类型的设计理念和规则，因此选择了不支持。：在全文检索中，空值本来就会被作为停用词处理，在分词过程中就会被“干掉”，即便我们使用 term 做精准查询，不会被分词，空值也不会被创建索引，因此无法匹配到任何结果，这一点不同于关系数据库。
Elasticsearch教程 ，Elasticsearch count 查询，Elasticsearch 查询是否存在
z69183787的专栏
08-22 6580
https://www.sojson.com/blog/206.html   一、Elasticsearch Count查询 当我们使用  Elasticsearch  的时候，如果只想知道符合条件的结果集，应该怎么查询？ 更多教程点击：  Elasticsearch教程  。 1.1 Elasticsearch count Java API 查询   Client client...
bulk Java提交数据,Elasticsearch 之（47） Java API 基于bulk实现多4S店销售数据批量上传...
weixin_34357232的博客
03-18 175
PUT /car_shop/sales/1{"brand": "宝马","name": "宝马320","price": 320000,"produce_date": "2017-01-01","sale_price": 300000,"sale_date": "2017-01-21"}PUT /car_shop/sales/2{"brand": "宝马","name": "宝马320","pri...
ElasticSearch高级操作
凉茶铺的博客
04-22 1188
介绍了ElasticSearch的高级操作（使用java代码操作）
java.lang.ClassNotFoundException: org.elasticsearch.common.transport.InetSocketTransportAddress
热门推荐
大痴小乙的博客
08-09 1万+
在做Elasticsearch 版本升级的时候，报出了 java.lang.ClassNotFoundException: org.elasticsearch.common.transport.InetSocketTransportAddress 这个错误，在此记录一下解决方法 开发环境 IntelliJ IDEA 2018.1.6 maven3.3.3 SpringBoot 2.0.4...
Java批量写入Elasticsearch
fivehundredyearsago的博客
06-11 5446
Elasticsearch 批量写入
elasticsearch进阶（二）错误问题汇总
03-01
以下三条记录源于5台机器导入近3亿条文档1.集群压力大，某台机器失去“心跳”后，其他机器好像总找不回它，导致数据无法继续传输查看日志，是说9300拒绝连接，想不明白，怎么会拒绝连接？很显然与防火墙无关，果然，...
elasticsearch5.5.1客户端所需jar包，解决必须用maven工程问题
08-19
elasticsearch5.5.1客户端所需jar包，可用于普通java工程使用elasticsearch客户端，解决必须用maven工程问题
elasticsearch-6.8.18.rar(elasticsearch-6.8.18.zip)
08-21
8. 日志记录：`logs`目录用于存放Elasticsearch运行时的日志文件，这对于排查问题和监控系统状态非常有用。 9. 库文件：`lib`目录下是Elasticsearch运行所需的Java库，包括Lucene和其他依赖项。 10. 模块化设计：`...
elasticsearch-analysis-dynamic-synonym-7.2.0
12-19
Elasticsearch（ES）是一款功能强大的全文搜索引擎，广泛应用于数据检索、数据分析等领域。为了提高搜索的准确性和便利性，Elasticsearch提供了丰富的分析插件，其中"elasticsearch-analysis-dynamic-synonym-7.2.0...
org.elasticsearch.common.transport.InetSocketTransportAddress;找不到
二进制的博客
09-21 1万+
第一次接触 elasticsearch ，需要学习的东西还有很多啊！ 使用版本 6.4.1 在创建客户端的时候提示 InetSocketTransportAddress 类找不到 TransportClient client = null; try { client = new PreBuiltTransportClient(Settings.EMPTY)...
Elasticsearch学习心得及常见问题
逾越的博客
01-12 5387
目录1.Elasticsearch和elasticsearch-headr跨域问题2.Elasticsearch的插件ik分词器3.ElasticSearch的核心概念1.分片2.倒排索引(重点，数据库可能会问)3.基本Rest命令说明4.Spring boot集成ElasticSearch 1.Elasticsearch和elasticsearch-headr跨域问题 首先保证两者启动成功 然后需要在elasticsearch的config中找到elasticsearch的配置文件 添加两
ElasticSearch 报错集锦及解决方法
Muxiu
05-29 2060
在笔者看来，无非就是要把解压后的 elasticsearch 放到，创建好的 用户目录下，所以就不会出现可能的权限问题，所以就不会老是报找不到包，其实是权限不够，当然这里笔者为了省事，直接将其放到一个普通用户目录下，当然这个固定好的专门为 elasticsearch 创建的一个用户。修改/etc/security/limits.conf文件。/etc/sysctl.conf文件末尾添加。输入如下命令，让配置立即生效。
flink写es报分片不足
weixin_42094092的博客
07-21 588
flink写es报分片不足: ERROR org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkBase [] - Failed Elasticsearch item request: ElasticsearchException[Elasticsearch exception [type=illegal_argument_exception, reason=Validation Failed: 1: this action
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值