Elasticsearch-7.8.0 创建索引底层源码分析(1)

 1、前言

本专栏系列基于  elasticsearch-7.8.0  版本分析
陆续打算推出的博文列表如下:

1、创建索引底层源码分析
2、更新索引底层源码分析
3、删除索引底层源码分析
4、elasticsearch中的线程池实现
5、elasticsearch启动过程源码流程分析
6、high level rest client请求流程分析
7、elastic search数据副本模型、读写模型
8、lucene学习总结系列

  • 全文检索的基本原理
  • lucene的总体结构
  • lucene的索引文件格式
  • lucene的打分机制
  • lucene的搜索过程解析

2、Start

本文记录ElasticSearch-7.8.0创建索引源码执行流程,从源码角度看一下创建索引的底层实现和涉及到的服务,比如AllocationService、MasterService、IndexService等,以及这些服务的相关操作,若有不合理的地方,希望各位看官能够不吝赐教。

  • 场景1:创建索引,没有写入文档。
curl -X PUT "localhost:9200/cool3" -d '{
  "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 2
    }
}'

Elasticsearch-7.8.0 创建索引底层源码分析(1)_第1张图片

总体流程图

总述:客户端提交创建索引的基本信息(索引名称、分区数、副本数等),提交到服务端,服务端将CreateIndexRequest封装成CreateIndexClusterStateUpdateRequest。根据actionName获得具体响应的action,具体入口是

org.elasticsearch.action.admin.indices.create.TransportCreateIndexAction

拿到响应action后调用实例属性MetadataCreateIndexService#createIndex()进入到onlyCreateIndex(),该实例属性的作用是:负责提交创建索引请求的服务;所以创建索引大致可以分为以下几个主要流程:

1)master节点发起集群状态更新任务

        创建索引会改变 当前集群状态——ClusterState,集群状态只能在主节点上更新,所以onlyCreateIndex方法进来后,就会由ClusterService调起MasterService,并在master节点上发起:提交一批集群状态更新任务——MasterService#submitStateUpdateTasks;经过一系列调用,在master节点运行创建索引任务MasterService#runTasks,再进入到具体的创建索引逻辑,具体调用栈如下

1、MetadataCreateIndexService#onlyCreateIndex
    clusterService.submitStateUpdateTask({...}) // 发起提交集群状态更新任务
2、ClusterService#submitStateUpdateTask
    submitStateUpdateTask(source, updateTask, ...);
3、ClusterService#submitStateUpdateTask
    submitStateUpdateTasks(source, ...);
4、ClusterService#submitStateUpdateTask
    masterService.submitStateUpdateTasks(source, tasks, config, executor);
5、MasterService#submitStateUpdateTasks
    taskBatcher.submitTasks(safeTasks, config.timeout());
6、TaskBatcher#submitTasks
    threadExecutor.execute(firstTask, timeout, () -> onTimeoutInternal(tasks, timeout));
7、PrioritizedEsThreadPoolExecutor#execute
    execute(command); // 提交创建索引任务
8、EsThreadPoolExecutor#execute
    super.execute(command);
9、java.util.concurrent.ThreadPoolExecutor#execute
    java.util.concurrent.ThreadPoolExecutor.Worker#run
    runWorker(Worker w)
10、java.util.concurrent.ThreadPoolExecutor#runWorker
    task.run();
10、TaskBatcher.BatchedTask#run
    // 创建索引、更新集群的状态信息是在Runnable#run()中,也就是TaskBatcher.BatchedTask#run方法中,这个方法继承了java类的Runnable接口
    runIfNotProcessed(this);
11、TaskBatcher#runIfNotProcessed
    run(updateTask.batchingKey, toExecute, tasksSummary);  // 最终回到run方法
    // MasterService.Batcher#run实现了上面TaskBatcher#run
12、MasterService.Batcher#run
    runTasks(new TaskInputs(taskExecutor, updateTasks, tasksSummary));
13、MasterService#runTasks
    final TaskOutputs taskOutputs = calculateTaskOutputs(taskInputs, previousClusterState);
14、MasterService#calculateTaskOutputs // 输入创建索引任务,输出集群状态变化结果
    ClusterTasksResult clusterTasksResult = executeTasks(taskInputs, previousClusterState);
15、MasterService#executeTasks
    clusterTasksResult = taskInputs.executor.execute(previousClusterState, inputs);
16、ClusterStateTaskExecutor#execute
    ClusterState result = execute(currentState); // 抽象类ClusterStateUpdateTask实现了ClusterStateTaskExecutor接口
17、ClusterStateUpdateTask#execute // 该方法:根据当前状态更新群集状态。如果不应更改任何状态,则返回*相同实例*。
18、clusterService.submitStateUpdateTask({
        new AckedClusterStateUpdateTask(...) {
                @Override
                public ClusterState execute(ClusterState currentState) throws Exception {
                        return applyCreateIndexRequest(currentState, request, false);
                }
        }
})
// AckedClusterStateUpdateTask继承ClusterStateUpdateTask类且实现AckedClusterStateTaskListener接口
// 回到步骤1、形成闭环;进入创建索引具体流程:applyCreateIndexRequest,详见调用栈-2
......

调用栈-1

Elasticsearch-7.8.0 创建索引底层源码分析(1)_第2张图片

调用栈-1——类继承关系

2)匹配索引模板启动IndexService

        创建索引需要通过IndexModule初始化一个IndexService,IndexService主要包含创建、删除、关闭分片等操作,即维护一个索引的基本操作。下面是调用栈

1、MetadataCreateIndexService#onlyCreateIndex
    return applyCreateIndexRequest(currentState, request, false); // 进入创建索引逻辑
2、MetadataCreateIndexService#applyCreateIndexRequest
    return applyCreateIndexRequest(currentState, request, silent, null);
3、MetadataCreateIndexService#applyCreateIndexRequest
    validate(request, currentState); // 索引相关检验
    return applyCreateIndexRequestWithV1Templates(currentState, request, silent, v1Templates, metadataTransformer);
4、MetadataCreateIndexService#applyCreateIndexRequestWithV1Templates
    return applyCreateIndexWithTemporaryService(...)
5、MetadataCreateIndexService#applyCreateIndexWithTemporaryService
    return indicesService.withTempIndexService(...)
6、IndicesService#withTempIndexService // 
    final IndexService indexService = createIndexService(...) // 创建IndexService入口
7、IndicesService#createIndexService
    final IndexModule indexModule = new IndexModule(...) // 创建IndexModule
    ... // 为创建索引添加各种监听器
    return indexModule.newIndexService(...) // 新建IndexService
8、IndexModule#newIndexService
    final IndexService indexService = new IndexService(...)
9、IndicesService#withTempIndexService // 回到步骤6、创建IndexService入口,形成闭环
        return indexServiceConsumer.apply(indexService);
10、MetadataCreateIndexService#applyCreateIndexWithTemporaryService
    return clusterStateCreateIndex(currentState, request.blocks(), indexMetadata, allocationService::reroute, metadataTransformer); // 步骤6,进入具体创建索引操作
11、AllocationService#reroute
        reroute(allocation); --> shardsAllocator.allocate(allocation);
12、BalancedShardsAllocator#allocate
        balancer.allocateUnassigned(); // 分配未分配的分片
        balancer.moveShards(); // 重新定位无法再留在节点上的分片
        balancer.balance(); // 重新分配分片,以便分片在集群中平衡
13、回到调用栈-1的步骤13、,形成闭环

调用栈-2

3)创建索引

        将索引创建到集群状态中即生成新的cluster state,下面是创建成功后的日志

[es-source-node] [cool3] creating index, cause [api], templates [], shards [3]/[2], mappings []

下面是创建索引的具体实现

static ClusterState clusterStateCreateIndex(ClusterState currentState, Set clusterBlocks, IndexMetadata indexMetadata,
                                                BiFunction rerouteRoutingTable,
                                                BiConsumer metadataTransformer) {
    Metadata.Builder builder = Metadata.builder(currentState.metadata())
        .put(indexMetadata, false);
    if (metadataTransformer != null) {
        metadataTransformer.accept(builder, indexMetadata);
    }
    Metadata newMetadata = builder.build();

    String indexName = indexMetadata.getIndex().getName();
    ClusterBlocks.Builder blocks = createClusterBlocksBuilder(currentState, indexName, clusterBlocks);
    blocks.updateBlocks(indexMetadata);

    ClusterState updatedState = ClusterState.builder(currentState).blocks(blocks).metadata(newMetadata).build();

    RoutingTable.Builder routingTableBuilder = RoutingTable.builder(updatedState.routingTable())
        .addAsNew(updatedState.metadata().index(indexName));
    updatedState = ClusterState.builder(updatedState).routingTable(routingTableBuilder.build()).build();
    //  如果index状态open,执行allocationService.reroute 将分片分配到其他节点
    return rerouteRoutingTable.apply(updatedState, "index [" + indexName + "] created");
}

这里详细说下cluster state:cluster state是全局性信息,包含了整个群集中所有分片的元信息(规则, 位置, 大小等信息),并保持每个每节的信息同步;下面的说明4、中,需要关注如何实现发布整体还是发布差异到具体的节点上,后续再分析

1、表示集群的当前状态。
2、除了{@link RoutingNodes}结构之外,cluster state对象是不可变的,该结构是根据{@link RoutingTable}的需求构建的。
3、集群状态只能在主节点上更新。所有更新都在单个线程上执行,并由{@link ClusterService}控制。在每次更新之后,{@link Discovery#publish}方法将集群状态的新版本发布给集群中的所有其他节点。实际的发布机制被委托给{@link Discovery#publish}方法,并取决于发现的类型。
4、集群状态实现{@link Diffable}接口,以支持发布集群状态差异的部分,而不是每次更改时的整个状态。如果某个节点处于集群状态的早期版本中,则发布机制只应将差异发送给该节点。如果某个节点在集群状态的早期版本中不存在,比如新加入的节点,则此节点不太可能具有早期集群状态版本,这时候就应发送完整版本。为了确保差异应用于集群状态的正确版本,每个集群状态版本更新都会生成{@link#stateUUID},唯一地标识该版本的状态。该uuid由{@link ClusterStateDiff#apply}方法验证,以确保应用了正确的差异。如果UUID不匹配,{@link ClusterStateDiff#apply}方法抛出{@link CompatibleClusterStateVersionException},这会导致发布机制将集群状态的完整版本发送到引发此异常的节点。

上面创建完索引后,也就会生成一个新的cluster state,集群状态 cluster state包含更新的路由。接着就会回调到AllocationService#reroute,执行分片分配。

4)AllocationService负责分片路由,将创建成功后的索引分配到分片上

        分片分配的核心逻辑是根据分片规则&分片权重(index、cluster)进行位置判断,然后进行数据移动、移动结束初始化启动、最后调整clusterstate完成分配。

        AllocationService这个服务负责管理集群的节点分配,包括选择节点用于shard allocation——分片分配,管理新加入集群的新节点和分片的重新路由,他的触发条件有:

  • 新增或删除 index 索引
  • node 节点的新增或删除
  • 执行 reroute 命令
  • 修改 replica 副本数量
  • 集群重启

此时我们的场景就是 新建索引 ;分片路由的具体实现逻辑入口如下:AllocationService#reroute

/**
 * 在存活的节点中重新路由  路由表
 * 如果返回了相同的ClusterState实例,则不会进行任何更改。
 */
public ClusterState reroute(ClusterState clusterState, String reason) {
    // 1、检查复制副本是否具有需要调整的自动扩展功能。如果需要更改,则返回更新的群集状态;如果不需要更改,则返回相同的群集状态。
    ClusterState fixedClusterState = adaptAutoExpandReplicas(clusterState);

    // 2、创建一个{@link RoutingNodes}。这是一个开销很大的操作,因此只能调用一次!
    RoutingNodes routingNodes = getMutableRoutingNodes(fixedClusterState);
    
    // 3、洗牌未分配的节点
    routingNodes.unassigned().shuffle();
    /**
     * Elasticsearch 主要通过两个基础组件来完成分片分配这个过程的: allocator 和 deciders;
     *  allocator 寻找最优的节点来分配分片;
     *      allocator 负责找出拥有分片数量最少的节点列表, 按分片数量递增排序, 分片数量较少的会被优先选择; 对于新建索引, allocator 的目标是以更为均衡的方式把新索引的分片分配到集群的节点中;
     *  deciders 负责判断并决定是否要进行分配;
     *      deciders 依次遍历 allocator 给出的节点列表, 判断是否要把分片分配给该节点, 比如是否满足分配过滤规则, 分片是否将超出节点磁盘容量阈值等等;
     */

    RoutingAllocation allocation = new RoutingAllocation(allocationDeciders, routingNodes, fixedClusterState,
        clusterInfoService.getClusterInfo(), currentNanoTime());
    // 关注这个方法
    reroute(allocation);

    if (fixedClusterState == clusterState && allocation.routingNodesChanged() == false) {
        return clusterState;
    }
    return buildResultAndLogHealthChange(clusterState, allocation, reason);
}

shard allocation, 是一个将分片分配到节点的过程;可能发生该操作的过程包括:

  • 初始恢复(initial recovery)
  • 副本分配(replica allocation)
  • 重新平衡(rebalance)
  • 节点的新增和删除

分片的分配操作, 是由 master 节点来决定什么时候移动分片, 以及移动到哪个节点上, 以达到集群的均衡,详见——官方文档

哪些分片应该分配到哪些节点上?哪个分片作为主分片, 哪个作为副本分片?
Elasticsearch 主要通过两个基础组件来完成分片分配这个过程的: allocator 和 deciders;

  • allocator 寻找最优的节点来分配分片
  • deciders 负责判断并决定是否要进行分配

① 对于新建的索引:

  • allocator的目标是以更为均衡的方式把新索引的分片分配到集群的节点中;deciders依次遍历allocator给出的节点列表, 判断是否要把分片分配给该节点, 比如是否满足分配过滤规则, 分片是否将超出节点磁盘容量阈值等等;

② 已有的索引

  • allocator 对于主分片, 只允许把主分片指定在已经拥有该分片完整数据的节点上; 对于副本分片, 则是先判断其他节点上是否已有该分片的数据的拷贝, 如果有这样的节点, allocator 则优先把分片分配到这其中一个节点上;

执行真正reroute逻辑,如果有节点没有分配shard,则执行gatewayAllocator.allocateUnassigned。关于gatewayAllocator的分配主要分为primaryShardAllocator和replicaShardAllocator:

primaryShardAllocator.allocateUnassigned(allocation);
replicaShardAllocator.processExistingRecoveries(allocation);
replicaShardAllocator.allocateUnassigned(allocation);

执行数据分片分配BalancedShardsAllocator.allocate(allocation)。该类基于WeightFunction重新分配集群节点node持有shard的分配关系。allocate方法主要分三步:

final Balancer balancer = new Balancer(logger, allocation, weightFunction, threshold);
balancer.allocateUnassigned();
balancer.moveShards();
balancer.balance();

①:allocateUnassigned,根据WeightFunction算法和所有AllocationDecider把所有给定的shard分配一个最小化匹配的node
②:moveShards,根据第一步的结果对需要移动的节点进行移动,移动过程中为RELOCATING,移动过去初始化INITIALIZING
③:负载均衡,rebalance其实是从负载高的node向负载低的做转移。

5)分发集群状态:publish()

        分片分配结束后,再由主节点调用相关服务将集群状态cluster state分发到集群的其他节点上,完成集群状态同步;主节点将集群状态分发到集群中的其他节点上,具体调用栈详见该入口方法,在调用栈-1的步骤13、后的代码中

try {
    ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(summary, newClusterState, previousClusterState);
    // new cluster state, notify all listeners
    final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
    if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
        String nodesDeltaSummary = nodesDelta.shortSummary();
        if (nodesDeltaSummary.length() > 0) {
            logger.info("{}, term: {}, version: {}, delta: {}",
                summary, newClusterState.term(), newClusterState.version(), nodesDeltaSummary);
        }
    }

    logger.debug("publishing cluster state version [{}]", newClusterState.version());
    publish(clusterChangedEvent, taskOutputs, publicationStartTime);
} catch (Exception e) {
    handleException(summary, publicationStartTime, newClusterState, e);
}

6)监听器监听创建结果

        等待集群中Active shards恢复到指定数目或者超时返回,将结果返回客户端

* Creates an index in the cluster state and waits for the specified number of shard copies to
* become active (as specified in {@link CreateIndexClusterStateUpdateRequest#waitForActiveShards()})
* before sending the response on the listener.

默认情况下:只要Primary Shard是Active的,也就是wait_for_active_shards指定的分片数量(默认为1),就可以创建索引。这里有两个获取结果的方式,即isAcknowledged()和shardsAcknowledged(),如果cluster state创建成功,isAcknowledged()会返回true(然后等待shardsAcknowledged,如果超时,shardsAcknowledged返回false),否则返回false(不会等待已经started的分片,isShardsAcknowledged也会返回false)。如果Active shards未达到指定的数目,则创建索引请求会阻塞,直到集群中Active shards恢复到指定数目或者超时返回。可参考:ActiveShardsObserver#waitForActiveShards(...)方法

clusterService.submitStateUpdateTask(
"create-index [" + request.index() + "], cause [" + request.cause() + "]",
new AckedClusterStateUpdateTask(Priority.URGENT, request, listener) {
    @Override
    protected ClusterStateUpdateResponse newResponse(boolean acknowledged) {
        // 2、clusterState更新返回
        return new ClusterStateUpdateResponse(acknowledged);
    }

    @Override
    public ClusterState execute(ClusterState currentState) throws Exception {
        // 1、适配创建索引请求
        return applyCreateIndexRequest(currentState, request, false);
    }

    @Override
    public void onFailure(String source, Exception e) {
        if (e instanceof ResourceAlreadyExistsException) {
            logger.trace(() -> new ParameterizedMessage("[{}] failed to create", request.index()), e);
        } else {
            logger.debug(() -> new ParameterizedMessage("[{}] failed to create", request.index()), e);
        }
        super.onFailure(source, e);
    }
});


onlyCreateIndex(request, ActionListener.wrap(response -> {
        // 检查isAcknowledged
    if (response.isAcknowledged()) {
        activeShardsObserver.waitForActiveShards(new String[]{request.index()}, request.waitForActiveShards(), request.ackTimeout(),
            shardsAcknowledged -> {
                // 检查shardsAcknowledged;
                if (shardsAcknowledged == false) {
                    logger.debug("[{}] index created, but the operation timed out while waiting for " +
                                     "enough shards to be started.", request.index());
                }
                listener.onResponse(new CreateIndexClusterStateUpdateResponse(response.isAcknowledged(), shardsAcknowledged));
            }, listener::onFailure);
    } else {
        listener.onResponse(new CreateIndexClusterStateUpdateResponse(false, false));
    }
}, listener::onFailure));

索引创建成功后,客户端响应结果如下,至此,索引创建流程结束。

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "cool3"
}

7)针对创建索引调用栈中的实现细节做一些解释说明

创建索引过程中,如果索引名不规范、或者创建配置不合理,都会在创建过程中进行校验,并且返回对应的报错信息

比如 调用栈-2 中的 索引相关校验

/**
 * Validate the name for an index or alias against some static rules.
 */
public static void validateIndexOrAliasName(String index, BiFunction exceptionCtor) {
    if (!Strings.validFileName(index)) {
         // ('\\', '/', '*', '?', '"', '<', '>', '|', ' ', ','))
        throw exceptionCtor.apply(index, "must not contain the following characters " + Strings.INVALID_FILENAME_CHARS);
    }
    if (index.contains("#")) {
        throw exceptionCtor.apply(index, "must not contain '#'");
    }
    if (index.contains(":")) {
        throw exceptionCtor.apply(index, "must not contain ':'");
    }
    if (index.charAt(0) == '_' || index.charAt(0) == '-' || index.charAt(0) == '+') {
        throw exceptionCtor.apply(index, "must not start with '_', '-', or '+'");
    }
    int byteCount = 0;
    try {
        byteCount = index.getBytes("UTF-8").length;
    } catch (UnsupportedEncodingException e) {
        // UTF-8 should always be supported, but rethrow this if it is not for some reason
        throw new ElasticsearchException("Unable to determine length of index name", e);
    }
    if (byteCount > MAX_INDEX_NAME_BYTES) {
        throw exceptionCtor.apply(index, "index name is too long, (" + byteCount + " > " + MAX_INDEX_NAME_BYTES + ")");
    }
    if (index.equals(".") || index.equals("..")) {
        throw exceptionCtor.apply(index, "must not be '.' or '..'");
    }
}
  1. 校验索引名--validateIndexName(),
    1. )索引名必须小写 -- must be lowercase
    2. )路由表是否已经存在该索引;!抛出索引已经存在异常 -- index {} already exists
    3. )元数据表是否已经存在该索引;同上
    4. )别名是否存在;!抛出别名已经存在异常 -- already exists as alias
       
      /**
       * Validate the name for an index against some static rules and a cluster state.
       */
      public void validateIndexName(String index, ClusterState state) {
          validateIndexOrAliasName(index, InvalidIndexNameException::new);
          if (!index.toLowerCase(Locale.ROOT).equals(index)) {
              throw new InvalidIndexNameException(index, "must be lowercase");
          }
      
          // NOTE: dot-prefixed index names are validated after template application, not here
      
          if (state.routingTable().hasIndex(index)) {
              throw new ResourceAlreadyExistsException(state.routingTable().index(index).getIndex());
          }
          if (state.metadata().hasIndex(index)) {
              throw new ResourceAlreadyExistsException(state.metadata().index(index).getIndex());
          }
          if (state.metadata().hasAlias(index)) {
              throw new InvalidIndexNameException(index, "already exists as alias");
          }
      }
  2. 校验settings是否正常--validateIndexSettings()
    1. )index.data_path及path.shared_data的设置是否合理(验证配置的索引数据路径(如果有)是否是配置的共享数据路径(如果有)的子路径)
    2. )参数值(非ES自身参数,例如index.merge.enabled、index.uuid)是否有key、value
public void validateIndexSettings(String indexName, final Settings settings, final boolean forbidPrivateIndexSettings)
    throws IndexCreationException {
    List validationErrors = getIndexSettingsValidationErrors(settings, forbidPrivateIndexSettings);

    if (validationErrors.isEmpty() == false) {
        ValidationException validationException = new ValidationException();
        validationException.addValidationErrors(validationErrors);
        throw new IndexCreationException(indexName, validationException);
    }
}

3、Ending

        至此,整个索引创建逻辑大体上分析结束,可以通过流程图,对照调用栈做分析,相关部分,比如重新路由和状态同步,后续再详细补充,包括创建索引后,具体的数据路径生成原理。

详见Elasticsearch-7.8.0集群方式运行源码,并集成IK分词器 

你可能感兴趣的:(elasticsearch,elasticsearch,搜索引擎,分布式,源码,大数据)