« 批量 API 词条向量 API »
Elastic 文档 ›Elasticsearch 指南 [8.16] ›REST API ›文档 API

Reindex API

编辑

Reindex API

编辑

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

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

Reindex 需要所有源文档中都启用了_source。

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

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

resp = client.reindex(
    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
const response = await client.reindex({
  source: {
    index: "my-index-000001",
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(response);
POST _reindex
{
  "source": {
    "index": "my-index-000001"
  },
  "dest": {
    "index": "my-new-index-000001"
  }
}

请求

编辑

POST /_reindex

先决条件

编辑

  • 如果启用了 Elasticsearch 安全功能，则您必须具有以下安全权限

    • 源数据流、索引或别名的 read 索引权限。
    • 目标数据流、索引或索引别名的 write 索引权限。
    • 要使用 reindex 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。

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

切片

编辑

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

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

手动切片
编辑

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

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

resp1 = client.reindex(
    source={
        "index": "my-index-000001",
        "slice": {
            "id": 1,
            "max": 2
        }
    },
    dest={
        "index": "my-new-index-000001"
    },
)
print(resp1)
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
const response = await client.reindex({
  source: {
    index: "my-index-000001",
    slice: {
      id: 0,
      max: 2,
    },
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(response);

const response1 = await client.reindex({
  source: {
    index: "my-index-000001",
    slice: {
      id: 1,
      max: 2,
    },
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(response1);
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)

resp1 = client.search(
    index="my-new-index-000001",
    size="0",
    filter_path="hits.total",
)
print(resp1)
response = client.indices.refresh
puts response

response = client.search(
  index: 'my-new-index-000001',
  size: 0,
  filter_path: 'hits.total'
)
puts response
const response = await client.indices.refresh();
console.log(response);

const response1 = await client.search({
  index: "my-new-index-000001",
  size: 0,
  filter_path: "hits.total",
});
console.log(response1);
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,
    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
const response = await client.reindex({
  slices: 5,
  refresh: "true",
  source: {
    index: "my-index-000001",
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(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
const response = await client.search({
  index: "my-new-index-000001",
  size: 0,
  filter_path: "hits.total",
});
console.log(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）将按比例分配给每个子请求。将此与上面关于分布不均匀的要点结合起来，您应该得出结论，将 max_docs 与 slices 一起使用可能不会导致正好重新索引 max_docs 个文档。
  • 每个子请求都会获取源数据的一个略微不同的快照，尽管这些快照都大约是在同一时间获取的。
选择切片数量
编辑

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

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

索引性能随切片数量线性扩展到可用资源。

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

重新索引路由

编辑

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

保留
将为每个匹配项发送的批量请求上的路由设置为匹配项上的路由。这是默认值。
丢弃
将为每个匹配项发送的批量请求上的路由设置为null。
=<some text>
将为每个匹配项发送的批量请求上的路由设置为=之后的全部文本。

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

$params = [
    'body' => [
        'source' => [
            'index' => 'source',
            'query' => [
                'match' => [
                    'company' => 'cat',
                ],
            ],
        ],
        'dest' => [
            'index' => 'dest',
            'routing' => '=cat',
        ],
    ],
];
$response = $client->reindex($params);
resp = client.reindex(
    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({
  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(
    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({
  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"
  }
}

使用摄取管道重新索引

编辑

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

$params = [
    'body' => [
        'source' => [
            'index' => 'source',
        ],
        'dest' => [
            'index' => 'dest',
            'pipeline' => 'some_ingest_pipeline',
        ],
    ],
];
$response = $client->reindex($params);
resp = client.reindex(
    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({
  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"
  }
}

查询参数

编辑
刷新
（可选，布尔值）如果true，则请求刷新受影响的分片以使此操作对搜索可见。默认为false。
超时

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

默认为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。
滚动
（可选，时间单位）指定应为滚动搜索维护索引一致视图的时间长度。
切片
（可选，整数）此任务应划分为的切片数。默认为 1，表示任务不会被切分为子任务。
max_docs
（可选，整数）要处理的文档的最大数量。默认为所有文档。当设置为小于或等于scroll_size的值时，不会使用滚动来检索操作的结果。

请求正文

编辑
冲突
（可选，枚举）设置为proceed以即使存在冲突也继续重新索引。默认为abort。
max_docs
（可选，整数）要重新索引的文档的最大数量。如果冲突等于proceed，则重新索引可能会尝试从源中重新索引比max_docs更多的文档，直到它已成功将max_docs个文档索引到目标中，或者它已遍历源查询中的每个文档。
来源
索引
（必填，字符串）您要从中复制的数据流、索引或别名的名称。还接受逗号分隔的列表以从多个源重新索引。
查询
（可选，查询对象）使用查询 DSL 指定要重新索引的文档。
远程
主机
（可选，字符串）您要从中索引的 Elasticsearch 远程实例的 URL。从远程索引时需要。
用户名
（可选，字符串）用于对远程主机进行身份验证的用户名。
密码
（可选，字符串）用于对远程主机进行身份验证的密码。
socket_timeout
（可选，时间单位）远程套接字读取超时。默认为 30 秒。
connect_timeout
（可选，时间单位）远程连接超时。默认为 30 秒。
标题
（可选，对象）包含请求标头的对象。
大小
{可选，整数) 每个批次要索引的文档数量。在从远程索引时使用，以确保批次适合堆内缓冲区，该缓冲区默认为最大 100 MB。
切片
ID
（可选，整数）手动切片的切片 ID。
最大值
（可选，整数）切片的总数。
排序

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

在 7.6 中已弃用。

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

_source
（可选，字符串）如果true，则重新索引所有源字段。设置为列表以重新索引选定的字段。默认为true。
目的地
索引
（必填，字符串）您要复制到的数据流、索引或索引别名的名称。
version_type
（可选，枚举）用于索引操作的版本控制。有效值：internal、external、external_gt、external_gte。有关更多信息，请参阅版本类型。
op_type

（可选，枚举）设置为 create 以仅索引尚不存在的文档（如果不存在则放入）。有效值：index、create。默认为index。

要重新索引到数据流目标，此参数必须为create。

管道
（可选，字符串）要使用的管道的名称。
脚本
来源
（可选，字符串）重新索引时运行的脚本，用于更新文档源或元数据。
语言
（可选，枚举）脚本语言：painless、expression、mustache、java。有关更多信息，请参阅脚本。

响应正文

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

示例

编辑

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

编辑

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

resp = client.reindex(
    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
const response = await client.reindex({
  source: {
    index: "my-index-000001",
    query: {
      term: {
        "user.id": "kimchy",
      },
    },
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(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(
    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
const response = await client.reindex({
  max_docs: 1,
  source: {
    index: "my-index-000001",
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(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(
    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
const response = await client.reindex({
  source: {
    index: ["my-index-000001", "my-index-000002"],
  },
  dest: {
    index: "my-new-index-000002",
  },
});
console.log(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(
    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
const response = await client.reindex({
  source: {
    index: "my-index-000001",
    _source: ["user.id", "_doc"],
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(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,
    document={
        "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
const response = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
    text: "words words",
    flag: "foo",
  },
});
console.log(response);
POST my-index-000001/_doc/1?refresh
{
  "text": "words words",
  "flag": "foo"
}

但您不喜欢flag的名称，并希望将其替换为tag。_reindex可以为您创建另一个索引

resp = client.reindex(
    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
const response = await client.reindex({
  source: {
    index: "my-index-000001",
  },
  dest: {
    index: "my-new-index-000001",
  },
  script: {
    source: 'ctx._source.tag = ctx._source.remove("flag")',
  },
});
console.log(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
const response = await client.get({
  index: "my-new-index-000001",
  id: 1,
});
console.log(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,
    document={
        "system.cpu.idle.pct": 0.908
    },
)
print(resp)

resp1 = client.index(
    index="metricbeat-2016.05.31",
    id="1",
    refresh=True,
    document={
        "system.cpu.idle.pct": 0.105
    },
)
print(resp1)
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 response = await client.index({
  index: "metricbeat-2016.05.30",
  id: 1,
  refresh: "true",
  document: {
    "system.cpu.idle.pct": 0.908,
  },
});
console.log(response);

const response1 = await client.index({
  index: "metricbeat-2016.05.31",
  id: 1,
  refresh: "true",
  document: {
    "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(
    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({
  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)

resp1 = client.get(
    index="metricbeat-2016.05.31-1",
    id="1",
)
print(resp1)
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 response = await client.get({
  index: "metricbeat-2016.05.30-1",
  id: 1,
});
console.log(response);

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(
    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
const response = await client.reindex({
  max_docs: 10,
  source: {
    index: "my-index-000001",
    query: {
      function_score: {
        random_score: {},
        min_score: 0.9,
      },
    },
  },
  dest: {
    index: "my-new-index-000001",
  },
});
console.log(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(
    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
const response = await client.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",
  },
});
console.log(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(
    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
const response = await client.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",
  },
});
console.log(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(
    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
const response = await client.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",
  },
});
console.log(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秒。此示例将套接字读取超时设置为一分钟，连接超时设置为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 »