› › ›

重新索引 API

重新索引 API编辑

将文档从源索引复制到目标索引。

源索引可以是任何现有的索引、别名或数据流。目标索引必须与源索引不同。例如，您不能将数据流重新索引到自身。

重新索引需要为源索引中的所有文档启用 _source。

在调用 _reindex 之前，应根据需要配置目标索引。重新索引不会复制源索引或其关联模板的设置。

映射、分片数量、副本等必须提前配置。

resp = client.reindex(
    body={
        "source": {"index": "my-index-000001"},
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001'
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

先决条件编辑

如果启用了 Elasticsearch 安全功能，您必须具有以下安全权限
- 源数据流、索引或别名的 read 索引权限。
- 目标数据流、索引或索引别名的 write 索引权限。
- 要使用重新索引 API 请求自动创建数据流或索引，您必须对目标数据流、索引或别名具有 auto_configure、create_index 或 manage 索引权限。
- 如果从远程集群重新索引，source.remote.user 必须具有 monitor 集群权限和源数据流、索引或别名的 read 索引权限。
如果从远程集群重新索引，您必须在 elasticsearch.yml 的 reindex.remote.whitelist 设置中显式允许远程主机。请参阅从远程集群重新索引。
自动创建数据流需要与启用了数据流的索引模板匹配。请参阅 设置数据流。

描述编辑

从源索引中提取文档源，并将文档索引到目标索引中。您可以将所有文档复制到目标索引，或重新索引文档的子集。

与 _update_by_query 一样，_reindex 会获取源索引的快照，但其目标索引必须不同，因此不太可能出现版本冲突。可以像索引 API 一样配置 dest 元素来控制乐观并发控制。省略 version_type 或将其设置为 internal 会导致 Elasticsearch 将文档盲目地转储到目标索引中，覆盖任何碰巧具有相同 ID 的文档。

将 version_type 设置为 external 会导致 Elasticsearch 保留来自源索引的 version，创建任何缺失的文档，并更新目标索引中版本比源索引中版本旧的任何文档。

将 op_type 设置为 create 会导致 _reindex 仅在目标索引中创建缺失的文档。所有现有文档都会导致版本冲突。

由于数据流是追加式，因此任何对目标数据流的重新索引请求都必须具有 op_type 为 create。重新索引只能将新文档添加到目标数据流。它不能更新目标数据流中的现有文档。

默认情况下，版本冲突会中止 _reindex 过程。要继续重新索引（如果有冲突），请将 "conflicts" 请求体参数设置为 proceed。在这种情况下，响应将包含遇到的版本冲突计数。请注意，"conflicts" 参数不会影响其他错误类型的处理。此外，如果您选择计算版本冲突，则操作可能会尝试从源索引中重新索引比 max_docs 更多的文档，直到它成功地将 max_docs 个文档索引到目标索引中，或者它已遍历源查询中的所有文档。

异步运行重新索引编辑

如果请求包含 wait_for_completion=false，Elasticsearch 会执行一些预检，启动请求，并返回一个 task，您可以使用它来取消或获取任务的状态。Elasticsearch 会在 _tasks/<task_id> 处创建一个此任务的记录作为文档。

从多个源索引重新索引编辑

如果您有许多源索引需要重新索引，通常最好一次重新索引一个源索引，而不是使用通配符模式来获取多个源索引。这样，如果出现任何错误，您可以通过删除部分完成的源索引并重新开始来恢复过程。它还使并行化过程相当简单：将要重新索引的源索引列表拆分，并并行运行每个列表。

一次性 bash 脚本似乎非常适合此目的

for index in i1 i2 i3 i4 i5; do
  curl -HContent-Type:application/json -XPOST localhost:9200/_reindex?pretty -d'{
    "source": {
      "index": "'$index'"
    },
    "dest": {
      "index": "'$index'-reindexed"
    }
  }'
done

节流编辑

将 requests_per_second 设置为任何正小数（1.4、6、1000 等）以限制 _reindex 发出索引操作批次的速率。通过在每个批次中添加等待时间来限制请求。要禁用节流，请将 requests_per_second 设置为 -1。

节流是通过在批次之间等待来完成的，这样 _reindex 在内部使用的 scroll 可以获得一个超时时间，该超时时间考虑了填充时间。填充时间是批次大小除以 requests_per_second 与写入时间之差。默认情况下，批次大小为 1000，因此如果 requests_per_second 设置为 500

target_time = 1000 / 500 per second = 2 seconds
wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds

由于批次作为单个 _bulk 请求发出，因此较大的批次大小会导致 Elasticsearch 创建许多请求，然后等待一段时间才开始下一组请求。这是“突发式”而不是“平滑式”。

重新节流编辑

可以使用 _rethrottle API 更改正在运行的重新索引的 requests_per_second 值

$params = [
    'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
];
$response = $client->reindexRethrottle($params);

resp = client.reindex_rethrottle(
    task_id="r1A2WoRbTwKZ516z6NEs5A:36619",
    requests_per_second="-1",
)
print(resp)

response = client.reindex_rethrottle(
  task_id: 'r1A2WoRbTwKZ516z6NEs5A:36619',
  requests_per_second: -1
)
puts response

res, err := es.ReindexRethrottle(
	"r1A2WoRbTwKZ516z6NEs5A:36619",
	esapi.IntPtr(-1),
)
fmt.Println(res, err)

const response = await client.reindexRethrottle({
  task_id: 'r1A2WoRbTwKZ516z6NEs5A:36619',
  requests_per_second: '-1'
})
console.log(response)

POST _reindex/r1A2WoRbTwKZ516z6NEs5A:36619/_rethrottle?requests_per_second=-1

可以使用任务 API 找到任务 ID。

与在重新索引 API 上设置它时一样，requests_per_second 可以是 -1（禁用节流）或任何小数，例如 1.7 或 12（限制到该级别）。加速查询的重新节流会立即生效，但减速查询的重新节流会在完成当前批次后生效。这可以防止滚动超时。

切片编辑

重新索引支持切片滚动以并行化重新索引过程。这种并行化可以提高效率，并提供一种将请求分解成更小部分的便捷方法。

从远程集群重新索引不支持手动或自动切片。

手动切片编辑

通过为每个请求提供切片 ID 和切片总数来手动切片重新索引请求

resp = client.reindex(
    body={
        "source": {
            "index": "my-index-000001",
            "slice": {"id": 0, "max": 2},
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

resp = client.reindex(
    body={
        "source": {
            "index": "my-index-000001",
            "slice": {"id": 1, "max": 2},
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001',
      slice: {
        id: 0,
        max: 2
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001',
      slice: {
        id: 1,
        max: 2
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001",
    "slice": {
      "id": 0,
      "max": 2
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}
POST _reindex
{
  "source": {
    "index": "my-index-000001",
    "slice": {
      "id": 1,
      "max": 2
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

您可以通过以下方式验证它是否有效

resp = client.indices.refresh()
print(resp)

resp = client.search(
    index="my-new-index-000001",
    size="0",
    filter_path="hits.total",
)
print(resp)

response = client.indices.refresh
puts response

response = client.search(
  index: 'my-new-index-000001',
  size: 0,
  filter_path: 'hits.total'
)
puts response

GET _refresh
POST my-new-index-000001/_search?size=0&filter_path=hits.total

这将导致一个合理的 total，例如

{
  "hits": {
    "total" : {
        "value": 120,
        "relation": "eq"
    }
  }
}

自动切片编辑

您也可以让 _reindex 使用切片滚动在 _id 上自动并行化，使用 slices 指定要使用的切片数量

resp = client.reindex(
    slices="5",
    refresh=True,
    body={
        "source": {"index": "my-index-000001"},
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  slices: 5,
  refresh: true,
  body: {
    source: {
      index: 'my-index-000001'
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex?slices=5&refresh
{
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

您可以通过以下方式验证它是否有效

resp = client.search(
    index="my-new-index-000001",
    size="0",
    filter_path="hits.total",
)
print(resp)

response = client.search(
  index: 'my-new-index-000001',
  size: 0,
  filter_path: 'hits.total'
)
puts response

POST my-new-index-000001/_search?size=0&filter_path=hits.total

这将导致一个合理的 total，例如

{
  "hits": {
    "total" : {
        "value": 120,
        "relation": "eq"
    }
  }
}

将 slices 设置为 auto 将允许 Elasticsearch 选择要使用的切片数量。此设置将使用每个分片一个切片，最多达到一定限制。如果有多个源索引，它将根据具有最少分片数量的索引或支持索引来选择切片数量。

将 slices 添加到 _reindex 只是自动执行了上面部分中使用的手动过程，创建子请求，这意味着它有一些怪癖

您可以在任务 API 中看到这些请求。这些子请求是具有 slices 的请求的任务的“子”任务。
获取包含 slices 的请求的任务状态，只包含已完成切片的狀態。
这些子请求可以单独寻址，用于取消和重新限制等操作。
重新限制包含 slices 的请求将按比例重新限制未完成的子请求。
取消包含 slices 的请求将取消每个子请求。
由于 slices 的性质，每个子请求不会获得完全均匀的文档份额。所有文档都将被处理，但某些切片可能比其他切片更大。预计较大的切片将具有更均匀的分布。
包含 slices 的请求上的参数（如 requests_per_second 和 max_docs）将按比例分配给每个子请求。结合上面关于分布不均匀的观点，您应该得出结论，使用 slices 的 max_docs 可能不会导致正好 max_docs 个文档被重新索引。
每个子请求都会获得源数据的略微不同的快照，尽管这些快照都在大约相同的时间获取。

选择切片数量edit

如果自动切片，将 slices 设置为 auto 将为大多数索引选择一个合理的值。如果手动切片或以其他方式调整自动切片，请使用以下指南。

当 slices 的数量等于索引中的分片数量时，查询性能最高效。如果该数字很大（例如 500），请选择较小的数字，因为过多的 slices 会影响性能。将 slices 设置为高于分片数量通常不会提高效率，还会增加开销。

索引性能随着切片数量的增加而线性扩展到可用资源。

查询性能或索引性能在运行时占主导地位取决于被重新索引的文档和集群资源。

重新索引路由edit

默认情况下，如果 _reindex 看到具有路由的文档，则会保留该路由，除非它被脚本更改。您可以在 dest 请求上设置 routing 来更改此设置。

keep: 将每个匹配项发送的批量请求上的路由设置为匹配项上的路由。这是默认值。
discard: 将每个匹配项发送的批量请求上的路由设置为 null。
=<some text>: 将每个匹配项发送的批量请求上的路由设置为 = 后的所有文本。

例如，您可以使用以下请求将 source 中所有公司名称为 cat 的文档复制到 dest 中，并将路由设置为 cat。

$params = [
    'body' => [
        'source' => [
            'index' => 'source',
            'query' => [
                'match' => [
                    'company' => 'cat',
                ],
            ],
        ],
        'dest' => [
            'index' => 'dest',
            'routing' => '=cat',
        ],
    ],
];
$response = $client->reindex($params);

resp = client.reindex(
    body={
        "source": {
            "index": "source",
            "query": {"match": {"company": "cat"}},
        },
        "dest": {"index": "dest", "routing": "=cat"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'source',
      query: {
        match: {
          company: 'cat'
        }
      }
    },
    dest: {
      index: 'dest',
      routing: '=cat'
    }
  }
)
puts response

res, err := es.Reindex(
	strings.NewReader(`{
	  "source": {
	    "index": "source",
	    "query": {
	      "match": {
	        "company": "cat"
	      }
	    }
	  },
	  "dest": {
	    "index": "dest",
	    "routing": "=cat"
	  }
	}`))
fmt.Println(res, err)

const response = await client.reindex({
  body: {
    source: {
      index: 'source',
      query: {
        match: {
          company: 'cat'
        }
      }
    },
    dest: {
      index: 'dest',
      routing: '=cat'
    }
  }
})
console.log(response)

POST _reindex
{
  "source": {
    "index": "source",
    "query": {
      "match": {
        "company": "cat"
      }
    }
  },
  "dest": {
    "index": "dest",
    "routing": "=cat"
  }
}

默认情况下，_reindex 使用 1000 的滚动批次。您可以使用 source 元素中的 size 字段更改批次大小。

$params = [
    'body' => [
        'source' => [
            'index' => 'source',
            'size' => 100,
        ],
        'dest' => [
            'index' => 'dest',
            'routing' => '=cat',
        ],
    ],
];
$response = $client->reindex($params);

resp = client.reindex(
    body={
        "source": {"index": "source", "size": 100},
        "dest": {"index": "dest", "routing": "=cat"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'source',
      size: 100
    },
    dest: {
      index: 'dest',
      routing: '=cat'
    }
  }
)
puts response

res, err := es.Reindex(
	strings.NewReader(`{
	  "source": {
	    "index": "source",
	    "size": 100
	  },
	  "dest": {
	    "index": "dest",
	    "routing": "=cat"
	  }
	}`))
fmt.Println(res, err)

const response = await client.reindex({
  body: {
    source: {
      index: 'source',
      size: 100
    },
    dest: {
      index: 'dest',
      routing: '=cat'
    }
  }
})
console.log(response)

POST _reindex
{
  "source": {
    "index": "source",
    "size": 100
  },
  "dest": {
    "index": "dest",
    "routing": "=cat"
  }
}

使用摄取管道重新索引edit

重新索引还可以通过指定 pipeline 来使用摄取管道功能，如下所示。

$params = [
    'body' => [
        'source' => [
            'index' => 'source',
        ],
        'dest' => [
            'index' => 'dest',
            'pipeline' => 'some_ingest_pipeline',
        ],
    ],
];
$response = $client->reindex($params);

resp = client.reindex(
    body={
        "source": {"index": "source"},
        "dest": {"index": "dest", "pipeline": "some_ingest_pipeline"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'source'
    },
    dest: {
      index: 'dest',
      pipeline: 'some_ingest_pipeline'
    }
  }
)
puts response

res, err := es.Reindex(
	strings.NewReader(`{
	  "source": {
	    "index": "source"
	  },
	  "dest": {
	    "index": "dest",
	    "pipeline": "some_ingest_pipeline"
	  }
	}`))
fmt.Println(res, err)

const response = await client.reindex({
  body: {
    source: {
      index: 'source'
    },
    dest: {
      index: 'dest',
      pipeline: 'some_ingest_pipeline'
    }
  }
})
console.log(response)

POST _reindex
{
  "source": {
    "index": "source"
  },
  "dest": {
    "index": "dest",
    "pipeline": "some_ingest_pipeline"
  }
}

查询参数edit

refresh

(可选，布尔值) 如果为 true，则请求将刷新受影响的分片，以使此操作对搜索可见。默认为 false。

timeout

(可选，时间单位) 每个索引等待以下操作的周期。

默认为 1m（一分钟）。这保证 Elasticsearch 至少等待超时时间才会失败。实际等待时间可能更长，尤其是在发生多次等待时。

wait_for_active_shards

(可选，字符串) 在继续操作之前必须处于活动状态的分片副本数量。设置为 all 或任何正整数，直到索引中的分片总数 (number_of_replicas+1)。默认值：1，主分片。

请参阅活动分片。

wait_for_completion

(可选，布尔值) 如果为 true，则请求将阻塞，直到操作完成。默认为 true。

requests_per_second

(可选，整数) 此请求的节流，以每秒子请求数表示。默认为 -1（无节流）。

require_alias

(可选，布尔值) 如果为 true，则目标必须是索引别名。默认为 false。

scroll

(可选，时间单位) 指定应为滚动搜索维护索引一致视图的时间长度。

slices

(可选，整数) 此任务应划分的切片数量。默认为 1，表示任务不会被切分为子任务。

max_docs

(可选，整数) 要处理的文档的最大数量。默认为所有文档。当设置为小于或等于 scroll_size 的值时，将不会使用滚动来检索操作的结果。

请求正文edit

conflicts

(可选，枚举) 设置为 proceed 以继续重新索引，即使存在冲突。默认为 abort。

max_docs

(可选，整数) 要重新索引的文档的最大数量。如果 conflicts 等于 proceed，则重新索引可能会尝试从源中重新索引比 max_docs 更多的文档，直到它已成功将 max_docs 个文档索引到目标中，或者它已遍历源查询中的所有文档。

source

index

(必需，字符串) 您要从中复制数据的数据流、索引或别名的名称。还接受逗号分隔的列表，以从多个源重新索引。

query

(可选，查询对象) 使用查询 DSL 指定要重新索引的文档。

remote

host: (可选，字符串) 您要从中索引的 Elasticsearch 远程实例的 URL。从远程索引时必需。
username: (可选，字符串) 用于对远程主机进行身份验证的用户名。
password: (可选，字符串) 用于对远程主机进行身份验证的密码。
socket_timeout: (可选，时间单位) 远程套接字读取超时时间。默认为 30 秒。
connect_timeout: (可选，时间单位) 远程连接超时时间。默认为 30 秒。
headers: (可选，对象) 包含请求标头的对象。

size

{可选，整数) 每个批次要索引的文档数量。在从远程索引时使用，以确保批次适合堆内缓冲区，该缓冲区默认最大大小为 100 MB。

slice

id: (可选，整数) 手动切片的切片 ID。
max: (可选，整数) 切片的总数。

sort

(可选，列表) 要在索引之前排序的 <field>:<direction> 对的逗号分隔列表。与 max_docs 结合使用以控制重新索引的文档。

在 7.6 中已弃用。

重新索引中的排序已弃用。重新索引中的排序从未保证按顺序索引文档，并且会阻止重新索引的进一步开发，例如弹性和性能改进。如果与 max_docs 结合使用，请考虑使用查询过滤器。

_source

(可选，字符串) 如果为 true，则重新索引所有源字段。设置为列表以重新索引选定的字段。默认为 true。

dest

index: (必需，字符串) 您要复制到的数据流、索引或索引别名的名称。
version_type: (可选，枚举) 用于索引操作的版本控制。有效值：internal、external、external_gt、external_gte。有关更多信息，请参阅版本类型。
op_type: (可选，枚举) 设置为 create 以仅索引尚不存在的文档（如果不存在则放入）。有效值：index、create。默认为 index。

要重新索引到数据流目标，此参数必须为 create。
pipeline: (可选，字符串) 要使用的管道的名称。

script

source: (可选，字符串) 要运行的脚本，用于在重新索引时更新文档源或元数据。
lang: (可选，枚举) 脚本语言：painless、expression、mustache、java。有关更多信息，请参阅脚本。

响应正文edit

took: (整数) 整个操作花费的总毫秒数。
timed_out: {布尔值) 如果在重新索引期间执行的任何请求超时，则此标志将设置为 true。
total: (整数) 成功处理的文档数量。
updated: (整数) 成功更新的文档数量，即在重新索引更新之前已存在相同 ID 的文档。
created: (整数) 成功创建的文档数量。
deleted: (整数) 成功删除的文档数量。
batches: (整数) 重新索引拉取的滚动响应数量。
noops: (整数) 被忽略的文档数量，因为用于重新索引的脚本为 ctx.op 返回了 noop 值。
version_conflicts: (整数) 重新索引遇到的版本冲突数量。
retries: (整数) 重新索引尝试的重试次数。 bulk 是重试的批量操作数量，而 search 是重试的搜索操作数量。
throttled_millis: (整数) 请求为了符合 requests_per_second 而休眠的毫秒数。
requests_per_second: (整数) 在重新索引期间实际执行的每秒请求数。
throttled_until_millis: (整数) 此字段在 _reindex 响应中应始终等于零。它只有在使用任务 API 时才有意义，它指示下次（以自纪元以来的毫秒数表示）节流请求将再次执行，以符合 requests_per_second。
failures: (数组) 如果在过程中出现任何不可恢复的错误，则为错误数组。如果此数组不为空，则请求因这些错误而中止。重新索引是使用批次实现的，任何错误都会导致整个过程中止，但当前批次中的所有错误都会收集到数组中。您可以使用 conflicts 选项来防止重新索引在版本冲突时中止。

示例编辑

使用查询重新索引选定的文档编辑

您可以通过在 source 中添加查询来限制文档。例如，以下请求仅将 user.id 为 kimchy 的文档复制到 my-new-index-000001 中

resp = client.reindex(
    body={
        "source": {
            "index": "my-index-000001",
            "query": {"term": {"user.id": "kimchy"}},
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001',
      query: {
        term: {
          'user.id' => 'kimchy'
        }
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001",
    "query": {
      "term": {
        "user.id": "kimchy"
      }
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

使用 `max_docs` 重新索引选定的文档编辑

您可以通过设置 max_docs 来限制处理的文档数量。例如，此请求将 my-index-000001 中的单个文档复制到 my-new-index-000001 中

resp = client.reindex(
    body={
        "max_docs": 1,
        "source": {"index": "my-index-000001"},
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    max_docs: 1,
    source: {
      index: 'my-index-000001'
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "max_docs": 1,
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

从多个来源重新索引编辑

source 中的 index 属性可以是一个列表，允许您在一个请求中从多个来源复制。这将从 my-index-000001 和 my-index-000002 索引中复制文档

resp = client.reindex(
    body={
        "source": {"index": ["my-index-000001", "my-index-000002"]},
        "dest": {"index": "my-new-index-000002"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: [
        'my-index-000001',
        'my-index-000002'
      ]
    },
    dest: {
      index: 'my-new-index-000002'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": ["my-index-000001", "my-index-000002"]
  },
  "dest": {
    "index": "my-new-index-000002"
  }
}

重新索引 API 不会尝试处理 ID 冲突，因此最后一个写入的文档将“获胜”，但顺序通常不可预测，因此不建议依赖此行为。相反，请使用脚本确保 ID 唯一。

使用源过滤器重新索引选定的字段编辑

您可以使用源过滤来重新索引原始文档中的部分字段。例如，以下请求仅重新索引每个文档的 user.id 和 _doc 字段

resp = client.reindex(
    body={
        "source": {
            "index": "my-index-000001",
            "_source": ["user.id", "_doc"],
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001',
      _source: [
        'user.id',
        '_doc'
      ]
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001",
    "_source": ["user.id", "_doc"]
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

重新索引以更改字段的名称编辑

_reindex 可用于构建包含已重命名字段的索引副本。假设您创建了一个包含如下文档的索引

resp = client.index(
    index="my-index-000001",
    id="1",
    refresh=True,
    body={"text": "words words", "flag": "foo"},
)
print(resp)

response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
    text: 'words words',
    flag: 'foo'
  }
)
puts response

POST my-index-000001/_doc/1?refresh
{
  "text": "words words",
  "flag": "foo"
}

但您不喜欢 flag 这个名称，想用 tag 替换它。 _reindex 可以为您创建另一个索引

resp = client.reindex(
    body={
        "source": {"index": "my-index-000001"},
        "dest": {"index": "my-new-index-000001"},
        "script": {
            "source": 'ctx._source.tag = ctx._source.remove("flag")'
        },
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001'
    },
    dest: {
      index: 'my-new-index-000001'
    },
    script: {
      source: 'ctx._source.tag = ctx._source.remove("flag")'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001"
  },
  "script": {
    "source": "ctx._source.tag = ctx._source.remove(\"flag\")"
  }
}

现在您可以获取新文档

resp = client.get(
    index="my-new-index-000001",
    id="1",
)
print(resp)

response = client.get(
  index: 'my-new-index-000001',
  id: 1
)
puts response

GET my-new-index-000001/_doc/1

这将返回

{
  "found": true,
  "_id": "1",
  "_index": "my-new-index-000001",
  "_version": 1,
  "_seq_no": 44,
  "_primary_term": 1,
  "_source": {
    "text": "words words",
    "tag": "foo"
  }
}

重新索引每日索引编辑

您可以将 _reindex 与 Painless 结合使用，重新索引每日索引以将新模板应用于现有文档。

假设您有包含如下文档的索引

$params = [
    'index' => 'metricbeat-2016.05.30',
    'id' => '1',
    'body' => [
        'system.cpu.idle.pct' => 0.908,
    ],
];
$response = $client->index($params);
$params = [
    'index' => 'metricbeat-2016.05.31',
    'id' => '1',
    'body' => [
        'system.cpu.idle.pct' => 0.105,
    ],
];
$response = $client->index($params);

resp = client.index(
    index="metricbeat-2016.05.30",
    id="1",
    refresh=True,
    body={"system.cpu.idle.pct": 0.908},
)
print(resp)

resp = client.index(
    index="metricbeat-2016.05.31",
    id="1",
    refresh=True,
    body={"system.cpu.idle.pct": 0.105},
)
print(resp)

response = client.index(
  index: 'metricbeat-2016.05.30',
  id: 1,
  refresh: true,
  body: {
    'system.cpu.idle.pct' => 0.908
  }
)
puts response

response = client.index(
  index: 'metricbeat-2016.05.31',
  id: 1,
  refresh: true,
  body: {
    'system.cpu.idle.pct' => 0.105
  }
)
puts response

{
	res, err := es.Index(
		"metricbeat-2016.05.30",
		strings.NewReader(`{
	  "system.cpu.idle.pct": 0.908
	}`),
		es.Index.WithDocumentID("1"),
		es.Index.WithRefresh("true"),
		es.Index.WithPretty(),
	)
	fmt.Println(res, err)
}

{
	res, err := es.Index(
		"metricbeat-2016.05.31",
		strings.NewReader(`{
	  "system.cpu.idle.pct": 0.105
	}`),
		es.Index.WithDocumentID("1"),
		es.Index.WithRefresh("true"),
		es.Index.WithPretty(),
	)
	fmt.Println(res, err)
}

const response0 = await client.index({
  index: 'metricbeat-2016.05.30',
  id: '1',
  refresh: true,
  body: {
    'system.cpu.idle.pct': 0.908
  }
})
console.log(response0)

const response1 = await client.index({
  index: 'metricbeat-2016.05.31',
  id: '1',
  refresh: true,
  body: {
    'system.cpu.idle.pct': 0.105
  }
})
console.log(response1)

PUT metricbeat-2016.05.30/_doc/1?refresh
{"system.cpu.idle.pct": 0.908}
PUT metricbeat-2016.05.31/_doc/1?refresh
{"system.cpu.idle.pct": 0.105}

metricbeat-* 索引的新模板已加载到 Elasticsearch 中，但它仅适用于新创建的索引。Painless 可用于重新索引现有文档并应用新模板。

以下脚本从索引名称中提取日期，并创建一个以 -1 结尾的新索引。来自 metricbeat-2016.05.31 的所有数据将重新索引到 metricbeat-2016.05.31-1 中。

$params = [
    'body' => [
        'source' => [
            'index' => 'metricbeat-*',
        ],
        'dest' => [
            'index' => 'metricbeat',
        ],
        'script' => [
            'lang' => 'painless',
            'source' => 'ctx._index = \'metricbeat-\' + (ctx._index.substring(\'metricbeat-\'.length(), ctx._index.length())) + \'-1\'',
        ],
    ],
];
$response = $client->reindex($params);

resp = client.reindex(
    body={
        "source": {"index": "metricbeat-*"},
        "dest": {"index": "metricbeat"},
        "script": {
            "lang": "painless",
            "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'",
        },
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'metricbeat-*'
    },
    dest: {
      index: 'metricbeat'
    },
    script: {
      lang: 'painless',
      source: "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
    }
  }
)
puts response

res, err := es.Reindex(
	strings.NewReader(`{
	  "source": {
	    "index": "metricbeat-*"
	  },
	  "dest": {
	    "index": "metricbeat"
	  },
	  "script": {
	    "lang": "painless",
	    "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
	  }
	}`))
fmt.Println(res, err)

const response = await client.reindex({
  body: {
    source: {
      index: 'metricbeat-*'
    },
    dest: {
      index: 'metricbeat'
    },
    script: {
      lang: 'painless',
      source: "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
    }
  }
})
console.log(response)

POST _reindex
{
  "source": {
    "index": "metricbeat-*"
  },
  "dest": {
    "index": "metricbeat"
  },
  "script": {
    "lang": "painless",
    "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
  }
}

来自先前 metricbeat 索引的所有文档现在都可以在 *-1 索引中找到。

$params = [
    'index' => 'metricbeat-2016.05.30-1',
    'id' => '1',
];
$response = $client->get($params);
$params = [
    'index' => 'metricbeat-2016.05.31-1',
    'id' => '1',
];
$response = $client->get($params);

resp = client.get(
    index="metricbeat-2016.05.30-1",
    id="1",
)
print(resp)

resp = client.get(
    index="metricbeat-2016.05.31-1",
    id="1",
)
print(resp)

response = client.get(
  index: 'metricbeat-2016.05.30-1',
  id: 1
)
puts response

response = client.get(
  index: 'metricbeat-2016.05.31-1',
  id: 1
)
puts response

{
	res, err := es.Get("metricbeat-2016.05.30-1", "1", es.Get.WithPretty())
	fmt.Println(res, err)
}

{
	res, err := es.Get("metricbeat-2016.05.31-1", "1", es.Get.WithPretty())
	fmt.Println(res, err)
}

const response0 = await client.get({
  index: 'metricbeat-2016.05.30-1',
  id: '1'
})
console.log(response0)

const response1 = await client.get({
  index: 'metricbeat-2016.05.31-1',
  id: '1'
})
console.log(response1)

GET metricbeat-2016.05.30-1/_doc/1
GET metricbeat-2016.05.31-1/_doc/1

先前的方法也可以与更改字段名称结合使用，以仅将现有数据加载到新索引中，并在需要时重命名任何字段。

提取源的随机子集编辑

_reindex 可用于提取源的随机子集以进行测试

resp = client.reindex(
    body={
        "max_docs": 10,
        "source": {
            "index": "my-index-000001",
            "query": {
                "function_score": {"random_score": {}, "min_score": 0.9}
            },
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    max_docs: 10,
    source: {
      index: 'my-index-000001',
      query: {
        function_score: {
          random_score: {},
          min_score: 0.9
        }
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "max_docs": 10,
  "source": {
    "index": "my-index-000001",
    "query": {
      "function_score" : {
        "random_score" : {},
        "min_score" : 0.9    
      }
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

您可能需要根据从源提取的数据的相对数量调整 min_score。

在重新索引期间修改文档编辑

与 _update_by_query 一样，_reindex 支持修改文档的脚本。与 _update_by_query 不同，脚本可以修改文档的元数据。此示例将源文档的版本提升一级

resp = client.reindex(
    body={
        "source": {"index": "my-index-000001"},
        "dest": {
            "index": "my-new-index-000001",
            "version_type": "external",
        },
        "script": {
            "source": "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
            "lang": "painless",
        },
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      index: 'my-index-000001'
    },
    dest: {
      index: 'my-new-index-000001',
      version_type: 'external'
    },
    script: {
      source: "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
      lang: 'painless'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001",
    "version_type": "external"
  },
  "script": {
    "source": "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
    "lang": "painless"
  }
}

就像在 _update_by_query 中一样，您可以将 ctx.op 设置为更改在目标上执行的操作

noop: 如果您的脚本决定文档不必在目标中索引，则将 ctx.op 设置为 noop。此无操作将在响应主体中的 noop 计数器中报告。
delete: 如果您的脚本决定必须从目标中删除文档，则将 ctx.op 设置为 delete。删除将在响应主体中的 deleted 计数器中报告。

将 ctx.op 设置为任何其他内容都会返回错误，将 ctx 中的任何其他字段设置为任何其他内容也会返回错误。

想想可能性！但要小心；您可以更改

_id
_index
_version
_routing

将 _version 设置为 null 或从 ctx 映射中清除它就像在索引请求中不发送版本一样；它会导致文档在目标中被覆盖，无论目标上的版本或您在 _reindex 请求中使用的版本类型如何。

从远程重新索引编辑

重新索引支持从远程 Elasticsearch 集群重新索引

resp = client.reindex(
    body={
        "source": {
            "remote": {
                "host": "http://otherhost:9200",
                "username": "user",
                "password": "pass",
            },
            "index": "my-index-000001",
            "query": {"match": {"test": "data"}},
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      remote: {
        host: 'http://otherhost:9200',
        username: 'user',
        password: 'pass'
      },
      index: 'my-index-000001',
      query: {
        match: {
          test: 'data'
        }
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "remote": {
      "host": "http://otherhost:9200",
      "username": "user",
      "password": "pass"
    },
    "index": "my-index-000001",
    "query": {
      "match": {
        "test": "data"
      }
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

host 参数必须包含方案、主机、端口（例如 https://otherhost:9200）和可选路径（例如 https://otherhost:9200/proxy）。username 和 password 参数是可选的，当它们存在时，_reindex 将使用基本身份验证连接到远程 Elasticsearch 节点。使用基本身份验证时，请务必使用 https，否则密码将以明文形式发送。有一系列设置可用于配置 https 连接的行为。

使用 Elastic Cloud 时，也可以通过使用有效的 API 密钥对远程集群进行身份验证

resp = client.reindex(
    body={
        "source": {
            "remote": {
                "host": "http://otherhost:9200",
                "headers": {"Authorization": "ApiKey API_KEY_VALUE"},
            },
            "index": "my-index-000001",
            "query": {"match": {"test": "data"}},
        },
        "dest": {"index": "my-new-index-000001"},
    },
)
print(resp)

response = client.reindex(
  body: {
    source: {
      remote: {
        host: 'http://otherhost:9200',
        headers: {
          "Authorization": 'ApiKey API_KEY_VALUE'
        }
      },
      index: 'my-index-000001',
      query: {
        match: {
          test: 'data'
        }
      }
    },
    dest: {
      index: 'my-new-index-000001'
    }
  }
)
puts response

POST _reindex
{
  "source": {
    "remote": {
      "host": "http://otherhost:9200",
      "headers": {
        "Authorization": "ApiKey API_KEY_VALUE"
      }
    },
    "index": "my-index-000001",
    "query": {
      "match": {
        "test": "data"
      }
    }
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

远程主机必须在 elasticsearch.yml 中使用 reindex.remote.whitelist 属性显式允许。它可以设置为允许的远程 host 和 port 组合的逗号分隔列表。方案将被忽略，仅使用主机和端口。例如

reindex.remote.whitelist: [otherhost:9200, another:9200, 127.0.10.*:9200, localhost:*"]

允许的主机列表必须配置在将协调重新索引的任何节点上。

此功能应适用于您可能遇到的任何版本的 Elasticsearch 的远程集群。这应该允许您通过从旧版本集群重新索引来将 Elasticsearch 从任何版本升级到当前版本。

Elasticsearch 不支持跨主要版本的向前兼容性。例如，您无法从 7.x 集群重新索引到 6.x 集群。

要启用发送到旧版本 Elasticsearch 的查询，query 参数将直接发送到远程主机，无需验证或修改。

从远程集群重新索引不支持手动或自动切片。

从远程服务器重新索引使用一个堆内缓冲区，默认最大大小为 100mb。如果远程索引包含非常大的文档，您需要使用更小的批次大小。以下示例将批次大小设置为 10，这非常非常小。

POST _reindex
{
  "source": {
    "remote": {
      "host": "http://otherhost:9200",
      ...
    },
    "index": "source",
    "size": 10,
    "query": {
      "match": {
        "test": "data"
      }
    }
  },
  "dest": {
    "index": "dest"
  }
}

还可以使用 socket_timeout 字段设置远程连接上的套接字读取超时，使用 connect_timeout 字段设置连接超时。两者默认值为 30 秒。此示例将套接字读取超时设置为 1 分钟，连接超时设置为 10 秒

POST _reindex
{
  "source": {
    "remote": {
      "host": "http://otherhost:9200",
      ...,
      "socket_timeout": "1m",
      "connect_timeout": "10s"
    },
    "index": "source",
    "query": {
      "match": {
        "test": "data"
      }
    }
  },
  "dest": {
    "index": "dest"
  }
}

配置 SSL 参数编辑

从远程重新索引支持可配置的 SSL 设置。这些必须在 elasticsearch.yml 文件中指定，安全设置除外，您可以在 Elasticsearch 密钥库中添加安全设置。无法在 _reindex 请求的主体中配置 SSL。

支持以下设置

reindex.ssl.certificate_authorities: 应信任的 PEM 编码证书文件的路径列表。您不能同时指定 reindex.ssl.certificate_authorities 和 reindex.ssl.truststore.path。
reindex.ssl.truststore.path: 包含要信任的证书的 Java 密钥库文件的路径。此密钥库可以是“JKS”或“PKCS#12”格式。您不能同时指定 reindex.ssl.certificate_authorities 和 reindex.ssl.truststore.path。
reindex.ssl.truststore.password: 密钥库 (reindex.ssl.truststore.path) 的密码。 [7.17.0] 在 7.17.0 中已弃用。优先使用 reindex.ssl.truststore.secure_password。此设置不能与 reindex.ssl.truststore.secure_password 一起使用。
reindex.ssl.truststore.secure_password (安全): 密钥库 (reindex.ssl.truststore.path) 的密码。此设置不能与 reindex.ssl.truststore.password 一起使用。
reindex.ssl.truststore.type: 信任库的类型（reindex.ssl.truststore.path）。必须是 jks 或 PKCS12。如果信任库路径以“.p12”、“.pfx”或“pkcs12”结尾，则此设置默认为 PKCS12。否则，默认为 jks。
reindex.ssl.verification_mode: 指示用于防止中间人攻击和证书伪造的验证类型。可以是 full（验证主机名和证书路径）、certificate（验证证书路径，但不验证主机名）或 none（不执行任何验证 - 强烈建议在生产环境中不要使用此选项）。默认为 full。
reindex.ssl.certificate: 指定用于 HTTP 客户端身份验证的 PEM 编码证书（或证书链）的路径（如果远程集群需要）。此设置要求 reindex.ssl.key 也已设置。您不能同时指定 reindex.ssl.certificate 和 reindex.ssl.keystore.path。
reindex.ssl.key: 指定与用于客户端身份验证的证书关联的 PEM 编码私钥的路径（reindex.ssl.certificate）。您不能同时指定 reindex.ssl.key 和 reindex.ssl.keystore.path。
reindex.ssl.key_passphrase: 指定用于解密 PEM 编码私钥（reindex.ssl.key）的密码（如果已加密）。 [7.17.0] 已在 7.17.0 中弃用。建议使用 reindex.ssl.secure_key_passphrase。不能与 reindex.ssl.secure_key_passphrase 一起使用。
reindex.ssl.secure_key_passphrase (安全): 指定用于解密 PEM 编码私钥（reindex.ssl.key）的密码（如果已加密）。不能与 reindex.ssl.key_passphrase 一起使用。
reindex.ssl.keystore.path: 指定包含用于 HTTP 客户端身份验证的私钥和证书的密钥库的路径（如果远程集群需要）。此密钥库可以是“JKS”或“PKCS#12”格式。您不能同时指定 reindex.ssl.key 和 reindex.ssl.keystore.path。
reindex.ssl.keystore.type: 密钥库的类型（reindex.ssl.keystore.path）。必须是 jks 或 PKCS12。如果密钥库路径以“.p12”、“.pfx”或“pkcs12”结尾，则此设置默认为 PKCS12。否则，默认为 jks。
reindex.ssl.keystore.password: 密钥库的密码（reindex.ssl.keystore.path）。 [7.17.0] 已在 7.17.0 中弃用。建议使用 reindex.ssl.keystore.secure_password。此设置不能与 reindex.ssl.keystore.secure_password 一起使用。
reindex.ssl.keystore.secure_password (安全): 密钥库的密码（reindex.ssl.keystore.path）。此设置不能与 reindex.ssl.keystore.password 一起使用。
reindex.ssl.keystore.key_password: 密钥库中密钥的密码（reindex.ssl.keystore.path）。默认为密钥库密码。 [7.17.0] 已在 7.17.0 中弃用。建议使用 reindex.ssl.keystore.secure_key_password。此设置不能与 reindex.ssl.keystore.secure_key_password 一起使用。
reindex.ssl.keystore.secure_key_password (安全): 密钥库中密钥的密码（reindex.ssl.keystore.path）。默认为密钥库密码。此设置不能与 reindex.ssl.keystore.key_password 一起使用。

« 批量 API 词向量 API »

重新索引 API