Elasticsearch 分片策略_elasticsearch 分片分配策略

分片

和数据库中的表空间类似，不过分片是为每个索引设置，一个索引可以有多个分片，分片分为主分片和副本分片，主分片和副本分片类似于数据库中的主库和备库。

• 主分片（shards）：可以有一个或多个，但至少会有一个，默认为1。多个主分片类似于分表，可以提高大量数据情况下的性能和吞吐量压力。
• 副本分片（replicas）：是针对主分片的副本，默认为1，也可以有多个。在主分片节点掉线或故障时，会升级为主分片来提供服务。副本分片可以提供查询等服务，提高查询效率和可用性。

注：主分片并不等于主节点，主分片可能存在于 ES 集群的非主节点上。这是由分片分配功能决定的。这个我们下面会说。

索引设置分片

在创建索引的时候，通过 settings 参数设置索引的分片数量，比如：我们创建一个 索引 students

PUT /students

{
    "settings":{
        "index":{
            "number_of_shards": 2, // 设置主分片数量(数量限制为1024每个索引，建议不要太多)
            "number_of_replicas": 1 // 每个主分片对应一个副本分片
        }
    },   
    "mappings": {
        "properties": {
            "age": { 
                "type": "integer"
            },  
            "birthday":  { 
                "type": "date",
                "format":"yyyy-MM-dd HH:mm:ss" 
            }, 
            "name":   { 
                "type": "keyword"  
            },
            "height": {
                "type": "float"
            },
            "id": {
                "type": "long"
            },
            "sex":{
                "type": "byte"
            },
            "remark":{
                "type":"text"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

分片的数量信息，在创建索引时设置，请不要修改。修改可能造成问题。虽然 number_of_replicas 是动态索引设置，但我还是建议不要去修改它。如确实需要修改，请重建索引。更多的索引设置请查看官网 索引设置

获取索引分片信息

GET /<target>/_shard_stores

GET /_shard_stores
1
2
3

路径参数 target：一个或多个索引的名称，多个用英文逗号隔开即可

查询参数 status
status
（可选，字符串）以逗号分隔的分片健康状态列表，用于限制请求。
有效值包括：

• green 分配了主分片和所有副本分片。
• yellow 一个或多个副本分片未分配。
• red 主分片未分配
• all 返回所有分片，无论运行状况如何。
  默认为yellow,red ，这意味着如果我们的集群正常，不使用status参数查询不出结果

示例

比如我们目前集群只有两个节点 192.168.1.10 和 192.168.1.11

GET /students/_shard_stores?status=green
1

{
    "indices": {
        "students": {
            "shards": { // 分片信息对象
                "0": { // 第 0 个分片
                    "stores": [
                        {
                            "oj5FEiVMRpuWV386zdwy3w": {
                                "name": "myNode1",
                                "ephemeral_id": "Au6ZYmTZQFOlGqIelj4ceQ",
                                "transport_address": "192.168.1.10:9300",
                                "external_id": "myNode1",
                                "attributes": {
                                    "ml.allocated_processors_double": "4.0",
                                    "xpack.installed": "true",
                                    "ml.machine_memory": "6087233536",
                                    "ml.allocated_processors": "4",
                                    "ml.max_jvm_size": "3045064704"
                                },
                                "roles": [
                                    "data",
                                    "data_cold",
                                    "data_content",
                                    "data_frozen",
                                    "data_hot",
                                    "data_warm",
                                    "ingest",
                                    "master",
                                    "ml",
                                    "remote_cluster_client",
                                    "transform"
                                ]
                            },
                            "allocation_id": "fhR4UEA6SS2OnBnlQ2f-Lw",
                            "allocation": "primary" // 表示其为主分片
                        },
                        {
                            "AST-4rnFRdagsd0juerSaw": {
                                "name": "myNode2",
                                "ephemeral_id": "1VlBaXYYRAeveu6BX_BpYw",
                                "transport_address": "192.168.1.11:9300",
                                "external_id": "myNode2",
                                "attributes": {
                                    "ml.allocated_processors_double": "4.0",
                                    "xpack.installed": "true",
                                    "ml.machine_memory": "6087098368",
                                    "ml.allocated_processors": "4",
                                    "ml.max_jvm_size": "3045064704"
                                },
                                "roles": [
                                    "data",
                                    "data_cold",
                                    "data_content",
                                    "data_frozen",
                                    "data_hot",
                                    "data_warm",
                                    "ingest",
                                    "master",
                                    "ml",
                                    "remote_cluster_client",
                                    "transform"
                                ]
                            },
                            "allocation_id": "LqDP66XYQkuBh204S9HNIQ",
                            "allocation": "replica" // 表示其为副本分片
                        }
                    ]
                },
                "1": { // 第 1 个分片
                    "stores": [
                        {
                            "AST-4rnFRdagsd0juerSaw": {
                                "name": "myNode2",
                                "ephemeral_id": "1VlBaXYYRAeveu6BX_BpYw",
                                "transport_address": "192.168.1.11:9300",
                                "external_id": "myNode2",
                                "attributes": {
                                    "ml.allocated_processors_double": "4.0",
                                    "xpack.installed": "true",
                                    "ml.machine_memory": "6087098368",
                                    "ml.allocated_processors": "4",
                                    "ml.max_jvm_size": "3045064704"
                                },
                                "roles": [
                                    "data",
                                    "data_cold",
                                    "data_content",
                                    "data_frozen",
                                    "data_hot",
                                    "data_warm",
                                    "ingest",
                                    "master",
                                    "ml",
                                    "remote_cluster_client",
                                    "transform"
                                ]
                            },
                            "allocation_id": "x9N8h80WQ5aJ0aLkXicGRQ",
                            "allocation": "primary"
                        },
                        {
                            "oj5FEiVMRpuWV386zdwy3w": {
                                "name": "myNode1",
                                "ephemeral_id": "Au6ZYmTZQFOlGqIelj4ceQ",
                                "transport_address": "192.168.1.10:9300",
                                "external_id": "myNode1",
                                "attributes": {
                                    "ml.allocated_processors_double": "4.0",
                                    "xpack.installed": "true",
                                    "ml.machine_memory": "6087233536",
                                    "ml.allocated_processors": "4",
                                    "ml.max_jvm_size": "3045064704"
                                },
                                "roles": [
                                    "data",
                                    "data_cold",
                                    "data_content",
                                    "data_frozen",
                                    "data_hot",
                                    "data_warm",
                                    "ingest",
                                    "master",
                                    "ml",
                                    "remote_cluster_client",
                                    "transform"
                                ]
                            },
                            "allocation_id": "NcS8BiuYQs2qip5DIhGEKA",
                            "allocation": "replica"
                        }
                    ]
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

可以看到结果我们有两个两两对应的主副分片，分别在集群的两个节点上，且均匀分布的。

查询结果中可能会出现 “store_exception”: … 信息，其表示打开分片索引或早期引擎故障时遇到的任何异常信息

分片分配

我们上面提到，分片是均匀分布在 ES 集群的，但这个不是绝对的。比如受节点所在服务器的内存、磁盘等各种情况的限制，各个节点之间可能存在性能差异等， ES 集群会通过一些策略对分片进行合理的分配。这些策略默认是理想情况下的均匀分配策略，在实际情况中，我们可以进行相应的策略配置使 ES 尽可能的按照我们提供的策略进行分片分配。

分片分配是将分片分配给节点的过程。在初始恢复、副本分配、重新平衡或添加或删除节点时发生。主节点的主要角色之一就是决定将哪些分片分配给哪个节点，以及何时在节点之间移动分片以重新平衡集群。

集群级分片分配

确定分片被分配到哪个节点，以及分片在集群之间的移动策略等的配置。我们这里不做扩展讲解，可以在官网 集群级分片分配 中进行详细查看。

索引级分片分配

索引级分片筛选

通过索引级分片筛选可以将索引按你设置的策略进行分片的分配（如 _name 按节点名称进分配、_host_ip 按主机 IP 分配节点）。

该配置通过 index.routing.allocation 来配置

例如：

PUT person/_settings
{
  "index.routing.allocation.include._ip": "192.168.2.*"
}
1
2
3
4

将 tset 索引分片分配到 包含 192.168.2.* ip的地址。

• require：表示必须满足所有条件
• exclude：条件之外
• include：必须至少满足其中一个条件

每个节点的分片总数

集群级分片分配器尝试将单个索引的分片分散到尽可能多的节点上。

• index.routing.allocation.total_shards_per_node
  将分配给单个索引的最大分片数（副本和主分片）。默认为无边界。

• cluster.routing.allocation.total_shards_per_node
  (动态)分配给每个节点的最大主分片和副本分片数。默认为-1（无限制）

例如：
当前有三个节点，设置的最大分片数都为 100
节点A：当前100个分片
节点B：当前59个分片
节点C：当前20个分片
当节点 C 故障时， ES 集群会将分片分配给节点 B，因为节点 A 已经达到了分片数量的限制。

索引恢复优先级

ES 会尽可能的按优先级顺序恢复未分配到分片，默认情况下，ES 按如下优先级顺序：

• index.priority设置（值大优先）
• 索引创建日期（日期越大越优先）
• 索引名称（先高后低）

我们可以，动态的通过 index.priority 设置优先级，UPDATE 修改索引设置

PUT person/_settings
{
  "index.priority": 1
}
1
2
3
4

节点掉线时延时分配

当某个节点丢失（离开集群）时，主节点

• 将副本分片替换该节点的主分片
• 重新分配丢失的副本分片
• 在其余的节点上重新平衡分片

这个过程会给集群增加负载，当节点丢失的时间很短，几分钟内就恢复了，那么此过程其实是可以避免的，我们可以通过 index.unassigned.node_left.delayed_timeout 来设置分配延迟时间，该配置默认为 1m （1分钟），可以在索引（或所有索引）上更新此设置：

PUT _all/_settings
{
  "settings": {
    "index.unassigned.node_left.delayed_timeout": "5m"
  }
}
1
2
3
4
5
6