Reindex API

ソースから宛先にドキュメントをコピーします。

ソースは、既存のインデックス、エイリアス、またはデータストリームのいずれかである可能性があります。宛先はソースと異なる必要があります。たとえば、データストリームを自分自身に再インデックスすることはできません。

再インデックスには、ソース内のすべてのドキュメントに対して_sourceを有効にする必要があります。 

  2. マッピング、シャード数、レプリカなどは、事前に構成する必要があります。
  5. #### Python
  7. ``````python
  8. resp = client.reindex(
  9.    source={
  10.    "index": "my-index-000001"
  11.    },
  12.    dest={
  13.    "index": "my-new-index-000001"
  14.    },
  15. )
  16. print(resp)
  17. `

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001'
  5.    },
  6.    dest: {
  7.    index: 'my-new-index-000001'
  8.    }
  9.   }
  10. )
  11. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.   },
  5.   dest: {
  6.    index: "my-new-index-000001",
  7.   },
  8. });
  9. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001"
  5.   },
  6.   "dest": {
  7.    "index": "my-new-index-000001"
  8.   }
  9. }

Request

POST /_reindex

Prerequisites

  • Elasticsearchのセキュリティ機能が有効になっている場合、次のセキュリティ権限を持っている必要があります：
    • ソースデータストリーム、インデックス、またはエイリアスに対するread インデックス権限。
    • 宛先データストリーム、インデックス、またはインデックスエイリアスに対するwriteインデックス権限。
    • 再インデックスAPIリクエストでデータストリームまたはインデックスを自動的に作成するには、宛先データストリーム、インデックス、またはエイリアスに対してauto_configure、create_index、またはmanageインデックス権限を持っている必要があります。
    • リモートクラスターから再インデックスする場合、source.remote.userはソースデータストリーム、インデックス、またはエイリアスに対するmonitor クラスター権限とreadインデックス権限を持っている必要があります。
  • リモートクラスターから再インデックスする場合、reindex.remote.whitelistの設定でリモートホストを明示的に許可する必要があります。詳細はリモートから再インデックスを参照してください。
  • 自動データストリーム作成には、データストリームが有効な一致するインデックステンプレートが必要です。詳細はデータストリームの設定を参照してください。

Description

ソースインデックスから_update_by_queryを抽出し、ドキュメントを宛先インデックスにインデックスします。すべてのドキュメントを宛先インデックスにコピーすることも、ドキュメントのサブセットを再インデックスすることもできます。

_update_by_queryと同様に、_reindexはソースのスナップショットを取得しますが、その宛先は異なる必要があるため、バージョンの競合が発生しにくくなります。dest要素は、楽観的同時実行制御を制御するためにインデックスAPIのように構成できます。version_typeを省略するか、internalに設定すると、Elasticsearchはドキュメントを宛先に盲目的にダンプし、同じIDを持つドキュメントを上書きします。 

  2. `````op_type`````を`````create`````に設定すると、`````_reindex`````は宛先に欠落しているドキュメントのみを作成します。すべての既存のドキュメントはバージョンの競合を引き起こします。  
  4. データストリームは[追加専用](4618071bf1c879cb.md#data-streams-append-only)であるため、宛先データストリームへの再インデックスリクエストは`````op_type`````が`````create`````である必要があります。再インデックスは、宛先データストリームに新しいドキュメントを追加することしかできません。既存のドキュメントを宛先データストリームで更新することはできません。  
  6. デフォルトでは、バージョンの競合は`````_reindex`````プロセスを中止します。競合が発生した場合でも再インデックスを続行するには、`````"conflicts"`````リクエストボディパラメータを`````proceed`````に設定します。この場合、応答には遭遇したバージョンの競合の数が含まれます。他のエラータイプの処理は`````"conflicts"`````パラメータの影響を受けません。さらに、バージョンの競合をカウントすることを選択した場合、操作は`````max_docs`````からソースから`````max_docs`````ドキュメントを宛先に正常にインデックスするまで、またはソースクエリ内のすべてのドキュメントを通過するまで、より多くのドキュメントを再インデックスしようとする可能性があります。
  9. ### Running reindex asynchronously
  11. リクエストに`````wait_for_completion=false`````が含まれている場合、Elasticsearchは一部の事前チェックを実行し、リクエストを開始し、タスクのキャンセルまたはステータスを取得するために使用できる[`````task`````](/read/elasticsearch-8-15/4819d08b09fe89d8.md)を返します。Elasticsearchは、このタスクの記録を`````_tasks/<task_id>`````にドキュメントとして作成します。
  14. ### Reindex from multiple sources
  16. 多くのソースを再インデックスする必要がある場合、複数のソースを選択するためにグロブパターンを使用するよりも、一度に1つずつ再インデックスする方が一般的に良いです。その方が、部分的に完了したソースを削除してやり直すことで、エラーが発生した場合にプロセスを再開できます。また、プロセスを並行化するのも非常に簡単です：再インデックスするソースのリストを分割し、各リストを並行して実行します。  
  18. 一時的なbashスクリプトは、これにうまく機能するようです：
  21. #### Bash
  23. ``````bash
  24. for index in i1 i2 i3 i4 i5; do
  25.   curl -HContent-Type:application/json -XPOST localhost:9200/_reindex?pretty -d'{
  26.    "source": {
  27.    "index": "'$index'"
  28.    },
  29.    "dest": {
  30.    "index": "'$index'-reindexed"
  31.    }
  32.   }'
  33. done
  34. `

Throttling

  2. スロットリングは、バッチ間で待機することによって行われ、`````scroll`````が内部で使用する`````_reindex`````に、パディングを考慮したタイムアウトを与えることができます。パディング時間は、バッチサイズを`````requests_per_second`````で割った値と、書き込みに費やした時間の差です。デフォルトのバッチサイズは`````1000`````であるため、`````requests_per_second`````が`````500`````に設定されている場合：
  5. #### Txt
  7. ``````txt
  8. target_time = 1000 / 500 per second = 2 seconds
  9. wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds
  10. `

バッチが単一の_bulkリクエストとして発行されるため、大きなバッチサイズはElasticsearchが多くのリクエストを作成し、次のセットを開始する前にしばらく待機する原因となります。これは「バースト」ではなく「スムーズ」ではありません。

Rethrottling

requests_per_secondの値は、_rethrottle APIを使用して実行中の再インデックスで変更できます：

Php

  1. $params = [
  2.    'task_id' => 'r1A2WoRbTwKZ516z6NEs5A:36619',
  3. ];
  4. $response = $client->reindexRethrottle($params);

Python

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

Ruby

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

Go

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

Js

  1. const response = await client.reindexRethrottle({
  2.   task_id: "r1A2WoRbTwKZ516z6NEs5A:36619",
  3.   requests_per_second: "-1",
  4. });
  5. console.log(response);

Console

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

タスクIDは、requests_per_secondを使用して見つけることができます。

再インデックスAPIで設定する場合と同様に、requests_per_secondはスロットリングを無効にするための-1または1.7や12のような任意の小数にすることができます。クエリを高速化するための再スロットリングは即座に効果を発揮しますが、クエリを遅くする再スロットリングは、現在のバッチが完了した後に効果を発揮します。これにより、スクロールタイムアウトが防止されます。

Slicing

再インデックスは、再インデックスプロセスを並行化するためにSliced scrollをサポートしています。この並行化は効率を改善し、リクエストを小さな部分に分割する便利な方法を提供します。

リモートクラスターからの再インデックスは、手動または自動スライスをサポートしていません。

Manual slicing

スライスIDとスライスの総数を各リクエストに提供することで、再インデックスリクエストを手動でスライスします：

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "my-index-000001",
  4.    "slice": {
  5.    "id": 0,
  6.    "max": 2
  7.    }
  8.    },
  9.    dest={
  10.    "index": "my-new-index-000001"
  11.    },
  12. )
  13. print(resp)
  15. resp1 = client.reindex(
  16.    source={
  17.    "index": "my-index-000001",
  18.    "slice": {
  19.    "id": 1,
  20.    "max": 2
  21.    }
  22.    },
  23.    dest={
  24.    "index": "my-new-index-000001"
  25.    },
  26. )
  27. print(resp1)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001',
  5.    slice: {
  6.    id: 0,
  7.    max: 2
  8.    }
  9.    },
  10.    dest: {
  11.    index: 'my-new-index-000001'
  12.    }
  13.   }
  14. )
  15. puts response
  17. response = client.reindex(
  18.   body: {
  19.    source: {
  20.    index: 'my-index-000001',
  21.    slice: {
  22.    id: 1,
  23.    max: 2
  24.    }
  25.    },
  26.    dest: {
  27.    index: 'my-new-index-000001'
  28.    }
  29.   }
  30. )
  31. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.    slice: {
  5.    id: 0,
  6.    max: 2,
  7.    },
  8.   },
  9.   dest: {
  10.    index: "my-new-index-000001",
  11.   },
  12. });
  13. console.log(response);
  15. const response1 = await client.reindex({
  16.   source: {
  17.    index: "my-index-000001",
  18.    slice: {
  19.    id: 1,
  20.    max: 2,
  21.    },
  22.   },
  23.   dest: {
  24.    index: "my-new-index-000001",
  25.   },
  26. });
  27. console.log(response1);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001",
  5.    "slice": {
  6.    "id": 0,
  7.    "max": 2
  8.    }
  9.   },
  10.   "dest": {
  11.    "index": "my-new-index-000001"
  12.   }
  13. }
  14. POST _reindex
  15. {
  16.   "source": {
  17.    "index": "my-index-000001",
  18.    "slice": {
  19.    "id": 1,
  20.    "max": 2
  21.    }
  22.   },
  23.   "dest": {
  24.    "index": "my-new-index-000001"
  25.   }
  26. }

これが機能することを確認できます：

Python

  1. resp = client.indices.refresh()
  2. print(resp)
  4. resp1 = client.search(
  5.    index="my-new-index-000001",
  6.    size="0",
  7.    filter_path="hits.total",
  8. )
  9. print(resp1)

Ruby

  1. response = client.indices.refresh
  2. puts response
  4. response = client.search(
  5.   index: 'my-new-index-000001',
  6.   size: 0,
  7.   filter_path: 'hits.total'
  8. )
  9. puts response

Js

  1. const response = await client.indices.refresh();
  2. console.log(response);
  4. const response1 = await client.search({
  5.   index: "my-new-index-000001",
  6.   size: 0,
  7.   filter_path: "hits.total",
  8. });
  9. console.log(response1);

Console

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

これにより、次のような妥当なtotalが得られます：

Console-Result

  1. {
  2.   "hits": {
  3.    "total" : {
  4.    "value": 120,
  5.    "relation": "eq"
  6.    }
  7.   }
  8. }

Automatic slicing

_reindexを使用して、Sliced scrollを使用して自動的に並行化することもできます。_idでスライスの数を指定します：

Python

  1. resp = client.reindex(
  2.    slices="5",
  3.    refresh=True,
  4.    source={
  5.    "index": "my-index-000001"
  6.    },
  7.    dest={
  8.    "index": "my-new-index-000001"
  9.    },
  10. )
  11. print(resp)

Ruby

  1. response = client.reindex(
  2.   slices: 5,
  3.   refresh: true,
  4.   body: {
  5.    source: {
  6.    index: 'my-index-000001'
  7.    },
  8.    dest: {
  9.    index: 'my-new-index-000001'
  10.    }
  11.   }
  12. )
  13. puts response

Js

  1. const response = await client.reindex({
  2.   slices: 5,
  3.   refresh: "true",
  4.   source: {
  5.    index: "my-index-000001",
  6.   },
  7.   dest: {
  8.    index: "my-new-index-000001",
  9.   },
  10. });
  11. console.log(response);

Console

  1. POST _reindex?slices=5&refresh
  2. {
  3.   "source": {
  4.    "index": "my-index-000001"
  5.   },
  6.   "dest": {
  7.    "index": "my-new-index-000001"
  8.   }
  9. }

これが機能することを確認できます：

Python

  1. resp = client.search(
  2.    index="my-new-index-000001",
  3.    size="0",
  4.    filter_path="hits.total",
  5. )
  6. print(resp)

Ruby

  1. response = client.search(
  2.   index: 'my-new-index-000001',
  3.   size: 0,
  4.   filter_path: 'hits.total'
  5. )
  6. puts response

Js

  1. const response = await client.search({
  2.   index: "my-new-index-000001",
  3.   size: 0,
  4.   filter_path: "hits.total",
  5. });
  6. console.log(response);

Console

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

これにより、次のような妥当なtotalが得られます：

Console-Result

  1. {
  2.   "hits": {
  3.    "total" : {
  4.    "value": 120,
  5.    "relation": "eq"
  6.    }
  7.   }
  8. }
  2. `````slices`````を`````_reindex`````に追加すると、上記のセクションで使用される手動プロセスが自動化され、サブリクエストが作成されます。これにはいくつかの特異性があります：  
  4. -  これらのリクエストは、[タスクAPI](9f223278767f8ed0.md#docs-reindex-task-api)で確認できます。これらのサブリクエストは、`````slices`````を持つリクエストのタスクの「子」タスクです。  
  5. -  `````slices`````を持つリクエストのタスクのステータスを取得すると、完了したスライスのステータスのみが含まれます。  
  6. -  これらのサブリクエストは、キャンセルや再スロットリングなどのために個別にアドレス指定できます。  
  7. -  `````slices`````を持つリクエストを再スロットリングすると、未完了のサブリクエストが比例して再スロットリングされます。  
  8. -  `````slices`````を持つリクエストをキャンセルすると、各サブリクエストがキャンセルされます。  
  9. -  `````slices`````の性質上、各サブリクエストはドキュメントの完全に均等な部分を取得しません。すべてのドキュメントが対象になりますが、一部のスライスは他のスライスよりも大きくなる可能性があります。大きなスライスは、より均等な分布を持つことが期待されます。  
  10. -  `````requests_per_second`````や`````max_docs`````のようなパラメータは、`````slices`````を持つリクエストの各サブリクエストに比例して分配されます。これを上記の分布が不均等であるという点と組み合わせると、`````max_docs`````を`````slices`````と一緒に使用すると、正確に`````max_docs`````ドキュメントが再インデックスされるとは限らないことがわかります。  
  11. -  各サブリクエストは、ソースのわずかに異なるスナップショットを取得しますが、これらはすべてほぼ同時に取得されます。
  14. #### Picking the number of slices
  16. 自動的にスライスする場合、`````slices`````を`````auto`````に設定すると、ほとんどのインデックスに対して合理的な数が選択されます。手動でスライスする場合や自動スライスを調整する場合は、次のガイドラインを使用します。  
  18. クエリパフォーマンスは、`````slices`````の数がインデックスのシャード数と等しいときに最も効率的です。その数が大きい場合（例：500）、`````slices`````が多すぎるとパフォーマンスが低下するため、低い数を選択します。`````slices`````をシャード数よりも高く設定しても、一般的に効率は向上せず、オーバーヘッドが追加されます。  
  20. インデックスパフォーマンスは、スライスの数に応じて利用可能なリソース全体で線形にスケールします。  
  22. クエリまたはインデックスパフォーマンスがランタイムを支配するかどうかは、再インデックスされるドキュメントとクラスターリソースによります。
  25. ### Reindex routing
  27. デフォルトでは、`````_reindex`````がルーティングを持つドキュメントを見た場合、スクリプトによって変更されない限り、ルーティングは保持されます。これを変更するには、`````routing`````を`````dest`````リクエストに設定できます：  
  29. -   `````keep
  • 各マッチに送信されるバルクリクエストのルーティングをマッチのルーティングに設定します。これはデフォルト値です。
  • discard
  • 各マッチに送信されるバルクリクエストのルーティングをnullに設定します。
  • =<some text>
  • 各マッチに送信されるバルクリクエストのルーティングを=の後のすべてのテキストに設定します。

たとえば、sourceから会社名catのすべてのドキュメントをdestにコピーし、ルーティングをcatに設定するために、次のリクエストを使用できます。

Php

  1. $params = [
  2.    'body' => [
  3.    'source' => [
  4.    'index' => 'source',
  5.    'query' => [
  6.    'match' => [
  7.    'company' => 'cat',
  8.    ],
  9.    ],
  10.    ],
  11.    'dest' => [
  12.    'index' => 'dest',
  13.    'routing' => '=cat',
  14.    ],
  15.    ],
  16. ];
  17. $response = $client->reindex($params);

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "source",
  4.    "query": {
  5.    "match": {
  6.    "company": "cat"
  7.    }
  8.    }
  9.    },
  10.    dest={
  11.    "index": "dest",
  12.    "routing": "=cat"
  13.    },
  14. )
  15. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'source',
  5.    query: {
  6.    match: {
  7.    company: 'cat'
  8.    }
  9.    }
  10.    },
  11.    dest: {
  12.    index: 'dest',
  13.    routing: '=cat'
  14.    }
  15.   }
  16. )
  17. puts response

Go

  1. res, err := es.Reindex(
  2.     strings.NewReader(`{
  3.       "source": {
  4.       "index": "source",
  5.       "query": {
  6.       "match": {
  7.       "company": "cat"
  8.       }
  9.       }
  10.       },
  11.       "dest": {
  12.       "index": "dest",
  13.       "routing": "=cat"
  14.       }
  15.     }`))
  16. fmt.Println(res, err)

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "source",
  4.    query: {
  5.    match: {
  6.    company: "cat",
  7.    },
  8.    },
  9.   },
  10.   dest: {
  11.    index: "dest",
  12.    routing: "=cat",
  13.   },
  14. });
  15. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "source",
  5.    "query": {
  6.    "match": {
  7.    "company": "cat"
  8.    }
  9.    }
  10.   },
  11.   "dest": {
  12.    "index": "dest",
  13.    "routing": "=cat"
  14.   }
  15. }

デフォルトでは、_reindexは1000のスクロールバッチを使用します。sizeフィールドをsource要素で変更して、バッチサイズを変更できます：

Php

  1. $params = [
  2.    'body' => [
  3.    'source' => [
  4.    'index' => 'source',
  5.    'size' => 100,
  6.    ],
  7.    'dest' => [
  8.    'index' => 'dest',
  9.    'routing' => '=cat',
  10.    ],
  11.    ],
  12. ];
  13. $response = $client->reindex($params);

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "source",
  4.    "size": 100
  5.    },
  6.    dest={
  7.    "index": "dest",
  8.    "routing": "=cat"
  9.    },
  10. )
  11. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'source',
  5.    size: 100
  6.    },
  7.    dest: {
  8.    index: 'dest',
  9.    routing: '=cat'
  10.    }
  11.   }
  12. )
  13. puts response

Go

  1. res, err := es.Reindex(
  2.     strings.NewReader(`{
  3.       "source": {
  4.       "index": "source",
  5.       "size": 100
  6.       },
  7.       "dest": {
  8.       "index": "dest",
  9.       "routing": "=cat"
  10.       }
  11.     }`))
  12. fmt.Println(res, err)

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "source",
  4.    size: 100,
  5.   },
  6.   dest: {
  7.    index: "dest",
  8.    routing: "=cat",
  9.   },
  10. });
  11. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "source",
  5.    "size": 100
  6.   },
  7.   "dest": {
  8.    "index": "dest",
  9.    "routing": "=cat"
  10.   }
  11. }

Reindex with an ingest pipeline

再インデックスは、pipelineを次のように指定することで、インジェストパイプライン機能を使用することもできます：

Php

  1. $params = [
  2.    'body' => [
  3.    'source' => [
  4.    'index' => 'source',
  5.    ],
  6.    'dest' => [
  7.    'index' => 'dest',
  8.    'pipeline' => 'some_ingest_pipeline',
  9.    ],
  10.    ],
  11. ];
  12. $response = $client->reindex($params);

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "source"
  4.    },
  5.    dest={
  6.    "index": "dest",
  7.    "pipeline": "some_ingest_pipeline"
  8.    },
  9. )
  10. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'source'
  5.    },
  6.    dest: {
  7.    index: 'dest',
  8.    pipeline: 'some_ingest_pipeline'
  9.    }
  10.   }
  11. )
  12. puts response

Go

  1. res, err := es.Reindex(
  2.     strings.NewReader(`{
  3.       "source": {
  4.       "index": "source"
  5.       },
  6.       "dest": {
  7.       "index": "dest",
  8.       "pipeline": "some_ingest_pipeline"
  9.       }
  10.     }`))
  11. fmt.Println(res, err)

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "source",
  4.   },
  5.   dest: {
  6.    index: "dest",
  7.    pipeline: "some_ingest_pipeline",
  8.   },
  9. });
  10. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "source"
  5.   },
  6.   "dest": {
  7.    "index": "dest",
  8.    "pipeline": "some_ingest_pipeline"
  9.   }
  10. }

Query parameters

  • refresh
  • （オプション、ブール値）trueの場合、リクエストは影響を受けるシャードを更新して、この操作を検索可能にします。デフォルトはfalseです。
  • timeout
  • （オプション、時間単位）各インデックス作成が次の操作を待機する期間：
  • 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以下の値に設定すると、操作の結果を取得するためにスクロールは使用されません。

Request body

  • conflicts
  • （オプション、列挙型）proceedに設定すると、競合があっても再インデックスを続行します。デフォルトはabortです。
  • max_docs
  • （オプション、整数）再インデックスする最大ドキュメント数。proceedがmax_docsに等しい場合、再インデックスはmax_docsドキュメントをターゲットに正常にインデックスするまで、またはソースクエリ内のすべてのドキュメントを通過するまで、ソースからsourceドキュメントを再インデックスしようとする可能性があります。
  • index
    • query
    • （必須、文字列）コピー元のデータストリーム、インデックス、またはエイリアスの名前。複数のソースから再インデックスするためにカンマ区切りのリストも受け入れます。
    • remote
    • （オプション、クエリオブジェクト）Query DSLを使用して再インデックスするドキュメントを指定します。
    • host
      • username
    • （オプション、文字列）リモートインスタンスのElasticsearchのURL。リモートからインデックスする場合は必須です。
    • password
    • （オプション、文字列）リモートホストとの認証に使用するユーザー名。
    • socket_timeout
    • （オプション、文字列）リモートホストとの認証に使用するパスワード。
    • connect_timeout
    • （オプション、時間単位）リモートソケットの読み取りタイムアウト。デフォルトは30秒です。
    • headers
    • （オプション、時間単位）リモート接続のタイムアウト。デフォルトは30秒です。
    • size
    • （オプション、オブジェクト）リクエストのヘッダーを含むオブジェクト。
    • slice
    • {オプション、整数）バッチごとにインデックスするドキュメントの数。リモートからインデックスする際に、バッチがヒープバッファ内に収まることを確認するために使用します。デフォルトは最大サイズ100MBです。
    • id
      • max
    • （オプション、整数）手動スライスのスライスID。
    • sort
    • （オプション、整数）スライスの総数。
    • <field>:<direction>
    • （オプション、リスト）インデックスする前にソートするためのカンマ区切りのmax_docsペアのリスト。max_docsと組み合わせて、どのドキュメントが再インデックスされるかを制御します。

Deprecated in 7.6.

再インデックスのソートは非推奨です。再インデックスでのソートは、ドキュメントを順序通りにインデックスすることが保証されておらず、再インデックスのさらなる開発（耐障害性やパフォーマンスの改善など）を妨げます。max_docsと組み合わせて使用する場合は、代わりにクエリフィルターを使用することを検討してください。

  • _source
  • （オプション、文字列）trueの場合、すべてのソースフィールドを再インデックスします。選択したフィールドを再インデックスするためにリストに設定します。デフォルトはtrueです。
    • dest
      • index
  • （必須、文字列）コピー先のデータストリーム、インデックス、またはインデックスエイリアスの名前。
  • version_type
  • （オプション、列挙型）インデックス操作に使用するバージョン管理。有効な値：internal、external、external_gt、external_gte。詳細についてはバージョンタイプを参照してください。
  • op_type
  • （オプション、列挙型）存在しないドキュメントのみをインデックスするために作成に設定します（存在しない場合は置き換え）。有効な値：index、create。デフォルトはindexです。
    データストリーム宛先に再インデックスするには、この引数はcreateでなければなりません。
  • pipeline
  • （オプション、文字列）使用するパイプラインの名前。
    • script
    • source
  • （オプション、文字列）再インデックス時にドキュメントソースまたはメタデータを更新するために実行するスクリプト。
  • lang
  • （オプション、列挙型）スクリプト言語：painless、expression、mustache、java。詳細についてはScriptingを参照してください。

Response body

  • took
  • （整数）全体の操作にかかったミリ秒の合計。
  • timed_out
  • （ブール値）再インデックス中に実行されたリクエストのいずれかがタイムアウトした場合、このフラグはtrueに設定されます。
  • total
  • （整数）正常に処理されたドキュメントの数。
  • updated
  • （整数）正常に更新されたドキュメントの数。すなわち、同じIDのドキュメントが再インデックスによって更新される前にすでに存在していました。
  • created
  • （整数）正常に作成されたドキュメントの数。
  • deleted
  • （整数）正常に削除されたドキュメントの数。
  • batches
  • （整数）再インデックスによって引き戻されたスクロール応答の数。
  • noops
  • （整数）再インデックスのために使用されたスクリプトがnoopの値をctx.opに返したために無視されたドキュメントの数。
  • version_conflicts
  • （整数）再インデックスがヒットしたバージョンの競合の数。
  • retries
  • （整数）再インデックスによって試みられた再試行の数。bulkは再試行されたバルクアクションの数で、searchは再試行された検索アクションの数です。
  • throttled_millis
  • （整数）requests_per_secondに準拠するためにリクエストがスリープしたミリ秒数。
  • requests_per_second
  • （整数）再インデックス中に実行されたリクエストの数。
  • throttled_until_millis
  • （整数）このフィールドは、_reindex応答で常にゼロである必要があります。これは、タスクAPIを使用している場合にのみ意味を持ち、スロットルされたリクエストがrequests_per_secondに準拠するために次に実行される時間（エポックからのミリ秒）を示します。
  • failures
  • （配列）プロセス中に回復不可能なエラーが発生した場合の失敗の配列。これが非空の場合、リクエストはこれらの失敗のために中止されました。再インデックスはバッチを使用して実装されており、いずれかの失敗が発生すると全体のプロセスが中止されますが、現在のバッチ内のすべての失敗は配列に収集されます。conflictsオプションを使用して、バージョンの競合で再インデックスが中止されないようにすることができます。

Examples

Reindex select documents with a query

クエリをsourceに追加することで、ドキュメントを制限できます。たとえば、次のリクエストは、user.idがkimchyのドキュメントのみをmy-new-index-000001にコピーします：

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "my-index-000001",
  4.    "query": {
  5.    "term": {
  6.    "user.id": "kimchy"
  7.    }
  8.    }
  9.    },
  10.    dest={
  11.    "index": "my-new-index-000001"
  12.    },
  13. )
  14. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001',
  5.    query: {
  6.    term: {
  7.    'user.id' => 'kimchy'
  8.    }
  9.    }
  10.    },
  11.    dest: {
  12.    index: 'my-new-index-000001'
  13.    }
  14.   }
  15. )
  16. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.    query: {
  5.    term: {
  6.    "user.id": "kimchy",
  7.    },
  8.    },
  9.   },
  10.   dest: {
  11.    index: "my-new-index-000001",
  12.   },
  13. });
  14. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001",
  5.    "query": {
  6.    "term": {
  7.    "user.id": "kimchy"
  8.    }
  9.    }
  10.   },
  11.   "dest": {
  12.    "index": "my-new-index-000001"
  13.   }
  14. }

Reindex select documents with max_docs

処理するドキュメントの数をmax_docsを設定することで制限できます。たとえば、このリクエストは、my-index-000001からmy-new-index-000001に単一のドキュメントをコピーします：

Python

  1. resp = client.reindex(
  2.    max_docs=1,
  3.    source={
  4.    "index": "my-index-000001"
  5.    },
  6.    dest={
  7.    "index": "my-new-index-000001"
  8.    },
  9. )
  10. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    max_docs: 1,
  4.    source: {
  5.    index: 'my-index-000001'
  6.    },
  7.    dest: {
  8.    index: 'my-new-index-000001'
  9.    }
  10.   }
  11. )
  12. puts response

Js

  1. const response = await client.reindex({
  2.   max_docs: 1,
  3.   source: {
  4.    index: "my-index-000001",
  5.   },
  6.   dest: {
  7.    index: "my-new-index-000001",
  8.   },
  9. });
  10. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "max_docs": 1,
  4.   "source": {
  5.    "index": "my-index-000001"
  6.   },
  7.   "dest": {
  8.    "index": "my-new-index-000001"
  9.   }
  10. }

Reindex from multiple sources

  3. #### Python
  5. ``````python
  6. resp = client.reindex(
  7.    source={
  8.    "index": [
  9.    "my-index-000001",
  10.    "my-index-000002"
  11.    ]
  12.    },
  13.    dest={
  14.    "index": "my-new-index-000002"
  15.    },
  16. )
  17. print(resp)
  18. `

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: [
  5.    'my-index-000001',
  6.    'my-index-000002'
  7.    ]
  8.    },
  9.    dest: {
  10.    index: 'my-new-index-000002'
  11.    }
  12.   }
  13. )
  14. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: ["my-index-000001", "my-index-000002"],
  4.   },
  5.   dest: {
  6.    index: "my-new-index-000002",
  7.   },
  8. });
  9. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": ["my-index-000001", "my-index-000002"]
  5.   },
  6.   "dest": {
  7.    "index": "my-new-index-000002"
  8.   }
  9. }

再インデックスAPIはIDの衝突を処理しようとしないため、最後に書き込まれたドキュメントが「勝ち」ますが、順序は通常予測できないため、この動作に依存するのは良い考えではありません。代わりに、スクリプトを使用してIDが一意であることを確認してください。

Reindex select fields with a source filter

ソースフィルタリングを使用して、元のドキュメントのフィールドのサブセットを再インデックスできます。たとえば、次のリクエストは、各ドキュメントのuser.idと_docフィールドのみを再インデックスします：

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "my-index-000001",
  4.    "_source": [
  5.    "user.id",
  6.    "_doc"
  7.    ]
  8.    },
  9.    dest={
  10.    "index": "my-new-index-000001"
  11.    },
  12. )
  13. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001',
  5.    _source: [
  6.    'user.id',
  7.    '_doc'
  8.    ]
  9.    },
  10.    dest: {
  11.    index: 'my-new-index-000001'
  12.    }
  13.   }
  14. )
  15. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.    _source: ["user.id", "_doc"],
  5.   },
  6.   dest: {
  7.    index: "my-new-index-000001",
  8.   },
  9. });
  10. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001",
  5.    "_source": ["user.id", "_doc"]
  6.   },
  7.   "dest": {
  8.    "index": "my-new-index-000001"
  9.   }
  10. }

Reindex to change the name of a field

  3. #### Python
  5. ``````python
  6. resp = client.index(
  7.    index="my-index-000001",
  8.    id="1",
  9.    refresh=True,
  10.    document={
  11.    "text": "words words",
  12.    "flag": "foo"
  13.    },
  14. )
  15. print(resp)
  16. `

Ruby

  1. response = client.index(
  2.   index: 'my-index-000001',
  3.   id: 1,
  4.   refresh: true,
  5.   body: {
  6.    text: 'words words',
  7.    flag: 'foo'
  8.   }
  9. )
  10. puts response

Js

  1. const response = await client.index({
  2.   index: "my-index-000001",
  3.   id: 1,
  4.   refresh: "true",
  5.   document: {
  6.    text: "words words",
  7.    flag: "foo",
  8.   },
  9. });
  10. console.log(response);

Console

  1. POST my-index-000001/_doc/1?refresh
  2. {
  3.   "text": "words words",
  4.   "flag": "foo"
  5. }

しかし、flagという名前が気に入らず、tagに置き換えたいとします。_reindexが他のインデックスを作成できます：

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "my-index-000001"
  4.    },
  5.    dest={
  6.    "index": "my-new-index-000001"
  7.    },
  8.    script={
  9.    "source": "ctx._source.tag = ctx._source.remove(\"flag\")"
  10.    },
  11. )
  12. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001'
  5.    },
  6.    dest: {
  7.    index: 'my-new-index-000001'
  8.    },
  9.    script: {
  10.    source: 'ctx._source.tag = ctx._source.remove("flag")'
  11.    }
  12.   }
  13. )
  14. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.   },
  5.   dest: {
  6.    index: "my-new-index-000001",
  7.   },
  8.   script: {
  9.    source: 'ctx._source.tag = ctx._source.remove("flag")',
  10.   },
  11. });
  12. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001"
  5.   },
  6.   "dest": {
  7.    "index": "my-new-index-000001"
  8.   },
  9.   "script": {
  10.    "source": "ctx._source.tag = ctx._source.remove(\"flag\")"
  11.   }
  12. }

新しいドキュメントを取得できます：

Python

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

Ruby

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

Js

  1. const response = await client.get({
  2.   index: "my-new-index-000001",
  3.   id: 1,
  4. });
  5. console.log(response);

Console

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

返されるのは:

コンソール-結果

  1. {
  2.   "found": true,
  3.   "_id": "1",
  4.   "_index": "my-new-index-000001",
  5.   "_version": 1,
  6.   "_seq_no": 44,
  7.   "_primary_term": 1,
  8.   "_source": {
  9.    "text": "words words",
  10.    "tag": "foo"
  11.   }
  12. }

Reindex daily indices

_reindex を Painless と組み合わせて使用することで、日次インデックスを再インデックス化し、既存のドキュメントに新しいテンプレートを適用できます。

ドキュメントを含むインデックスがあると仮定します:

Php

  1. $params = [
  2.    'index' => 'metricbeat-2016.05.30',
  3.    'id' => '1',
  4.    'body' => [
  5.    'system.cpu.idle.pct' => 0.908,
  6.    ],
  7. ];
  8. $response = $client->index($params);
  9. $params = [
  10.    'index' => 'metricbeat-2016.05.31',
  11.    'id' => '1',
  12.    'body' => [
  13.    'system.cpu.idle.pct' => 0.105,
  14.    ],
  15. ];
  16. $response = $client->index($params);

Python

  1. resp = client.index(
  2.    index="metricbeat-2016.05.30",
  3.    id="1",
  4.    refresh=True,
  5.    document={
  6.    "system.cpu.idle.pct": 0.908
  7.    },
  8. )
  9. print(resp)
  11. resp1 = client.index(
  12.    index="metricbeat-2016.05.31",
  13.    id="1",
  14.    refresh=True,
  15.    document={
  16.    "system.cpu.idle.pct": 0.105
  17.    },
  18. )
  19. print(resp1)

Ruby

  1. response = client.index(
  2.   index: 'metricbeat-2016.05.30',
  3.   id: 1,
  4.   refresh: true,
  5.   body: {
  6.    'system.cpu.idle.pct' => 0.908
  7.   }
  8. )
  9. puts response
  11. response = client.index(
  12.   index: 'metricbeat-2016.05.31',
  13.   id: 1,
  14.   refresh: true,
  15.   body: {
  16.    'system.cpu.idle.pct' => 0.105
  17.   }
  18. )
  19. puts response

Go

  1. {
  2.     res, err := es.Index(
  3.         "metricbeat-2016.05.30",
  4.         strings.NewReader(`{
  5.       "system.cpu.idle.pct": 0.908
  6.     }`),
  7.         es.Index.WithDocumentID("1"),
  8.         es.Index.WithRefresh("true"),
  9.         es.Index.WithPretty(),
  10.     )
  11.     fmt.Println(res, err)
  12. }
  14. {
  15.     res, err := es.Index(
  16.         "metricbeat-2016.05.31",
  17.         strings.NewReader(`{
  18.       "system.cpu.idle.pct": 0.105
  19.     }`),
  20.         es.Index.WithDocumentID("1"),
  21.         es.Index.WithRefresh("true"),
  22.         es.Index.WithPretty(),
  23.     )
  24.     fmt.Println(res, err)
  25. }

Js

  1. const response = await client.index({
  2.   index: "metricbeat-2016.05.30",
  3.   id: 1,
  4.   refresh: "true",
  5.   document: {
  6.    "system.cpu.idle.pct": 0.908,
  7.   },
  8. });
  9. console.log(response);
  11. const response1 = await client.index({
  12.   index: "metricbeat-2016.05.31",
  13.   id: 1,
  14.   refresh: "true",
  15.   document: {
  16.    "system.cpu.idle.pct": 0.105,
  17.   },
  18. });
  19. console.log(response1);

Console

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

metricbeat-* インデックスの新しいテンプレートはすでに Elasticsearch にロードされていますが、新しく作成されたインデックスにのみ適用されます。Painless を使用して既存のドキュメントを再インデックス化し、新しいテンプレートを適用できます。

以下のスクリプトは、インデックス名から日付を抽出し、-1 を追加した新しいインデックスを作成します。metricbeat-2016.05.31 からのすべてのデータは metricbeat-2016.05.31-1 に再インデックス化されます。

Php

  1. $params = [
  2.    'body' => [
  3.    'source' => [
  4.    'index' => 'metricbeat-*',
  5.    ],
  6.    'dest' => [
  7.    'index' => 'metricbeat',
  8.    ],
  9.    'script' => [
  10.    'lang' => 'painless',
  11.    'source' => 'ctx._index = \'metricbeat-\' + (ctx._index.substring(\'metricbeat-\'.length(), ctx._index.length())) + \'-1\'',
  12.    ],
  13.    ],
  14. ];
  15. $response = $client->reindex($params);

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "metricbeat-*"
  4.    },
  5.    dest={
  6.    "index": "metricbeat"
  7.    },
  8.    script={
  9.    "lang": "painless",
  10.    "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
  11.    },
  12. )
  13. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'metricbeat-*'
  5.    },
  6.    dest: {
  7.    index: 'metricbeat'
  8.    },
  9.    script: {
  10.    lang: 'painless',
  11.    source: "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
  12.    }
  13.   }
  14. )
  15. puts response

Go

  1. res, err := es.Reindex(
  2.     strings.NewReader(`{
  3.       "source": {
  4.       "index": "metricbeat-*"
  5.       },
  6.       "dest": {
  7.       "index": "metricbeat"
  8.       },
  9.       "script": {
  10.       "lang": "painless",
  11.       "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
  12.       }
  13.     }`))
  14. fmt.Println(res, err)

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "metricbeat-*",
  4.   },
  5.   dest: {
  6.    index: "metricbeat",
  7.   },
  8.   script: {
  9.    lang: "painless",
  10.    source:
  11.    "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'",
  12.   },
  13. });
  14. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "metricbeat-*"
  5.   },
  6.   "dest": {
  7.    "index": "metricbeat"
  8.   },
  9.   "script": {
  10.    "lang": "painless",
  11.    "source": "ctx._index = 'metricbeat-' + (ctx._index.substring('metricbeat-'.length(), ctx._index.length())) + '-1'"
  12.   }
  13. }

以前の metricbeat インデックスからのすべてのドキュメントは、*-1 インデックスに見つかるようになりました。

Php

  1. $params = [
  2.    'index' => 'metricbeat-2016.05.30-1',
  3.    'id' => '1',
  4. ];
  5. $response = $client->get($params);
  6. $params = [
  7.    'index' => 'metricbeat-2016.05.31-1',
  8.    'id' => '1',
  9. ];
  10. $response = $client->get($params);

Python

  1. resp = client.get(
  2.    index="metricbeat-2016.05.30-1",
  3.    id="1",
  4. )
  5. print(resp)
  7. resp1 = client.get(
  8.    index="metricbeat-2016.05.31-1",
  9.    id="1",
  10. )
  11. print(resp1)

Ruby

  1. response = client.get(
  2.   index: 'metricbeat-2016.05.30-1',
  3.   id: 1
  4. )
  5. puts response
  7. response = client.get(
  8.   index: 'metricbeat-2016.05.31-1',
  9.   id: 1
  10. )
  11. puts response

Go

  1. {
  2.     res, err := es.Get("metricbeat-2016.05.30-1", "1", es.Get.WithPretty())
  3.     fmt.Println(res, err)
  4. }
  6. {
  7.     res, err := es.Get("metricbeat-2016.05.31-1", "1", es.Get.WithPretty())
  8.     fmt.Println(res, err)
  9. }

Js

  1. const response = await client.get({
  2.   index: "metricbeat-2016.05.30-1",
  3.   id: 1,
  4. });
  5. console.log(response);
  7. const response1 = await client.get({
  8.   index: "metricbeat-2016.05.31-1",
  9.   id: 1,
  10. });
  11. console.log(response1);

Console

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

以前の方法は、フィールド名の変更 と組み合わせて使用することもでき、既存のデータのみを新しいインデックスにロードし、必要に応じてフィールドの名前を変更できます。

Extract a random subset of the source

_reindex を使用して、テスト用にソースのランダムなサブセットを抽出できます:

Python

  1. resp = client.reindex(
  2.    max_docs=10,
  3.    source={
  4.    "index": "my-index-000001",
  5.    "query": {
  6.    "function_score": {
  7.    "random_score": {},
  8.    "min_score": 0.9
  9.    }
  10.    }
  11.    },
  12.    dest={
  13.    "index": "my-new-index-000001"
  14.    },
  15. )
  16. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    max_docs: 10,
  4.    source: {
  5.    index: 'my-index-000001',
  6.    query: {
  7.    function_score: {
  8.    random_score: {},
  9.    min_score: 0.9
  10.    }
  11.    }
  12.    },
  13.    dest: {
  14.    index: 'my-new-index-000001'
  15.    }
  16.   }
  17. )
  18. puts response

Js

  1. const response = await client.reindex({
  2.   max_docs: 10,
  3.   source: {
  4.    index: "my-index-000001",
  5.    query: {
  6.    function_score: {
  7.    random_score: {},
  8.    min_score: 0.9,
  9.    },
  10.    },
  11.   },
  12.   dest: {
  13.    index: "my-new-index-000001",
  14.   },
  15. });
  16. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "max_docs": 10,
  4.   "source": {
  5.    "index": "my-index-000001",
  6.    "query": {
  7.    "function_score" : {
  8.    "random_score" : {},
  9.    "min_score" : 0.9
  10.    }
  11.    }
  12.   },
  13.   "dest": {
  14.    "index": "my-new-index-000001"
  15.   }
  16. }
ソースから抽出されたデータの相対量に応じて min_score を調整する必要があるかもしれません。

Modify documents during reindexing

_update_by_query と同様に、_reindex はドキュメントを変更するスクリプトをサポートしています。_update_by_query とは異なり、スクリプトはドキュメントのメタデータを変更することが許可されています。この例では、ソースドキュメントのバージョンを上げます:

Python

  1. resp = client.reindex(
  2.    source={
  3.    "index": "my-index-000001"
  4.    },
  5.    dest={
  6.    "index": "my-new-index-000001",
  7.    "version_type": "external"
  8.    },
  9.    script={
  10.    "source": "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
  11.    "lang": "painless"
  12.    },
  13. )
  14. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    index: 'my-index-000001'
  5.    },
  6.    dest: {
  7.    index: 'my-new-index-000001',
  8.    version_type: 'external'
  9.    },
  10.    script: {
  11.    source: "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
  12.    lang: 'painless'
  13.    }
  14.   }
  15. )
  16. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    index: "my-index-000001",
  4.   },
  5.   dest: {
  6.    index: "my-new-index-000001",
  7.    version_type: "external",
  8.   },
  9.   script: {
  10.    source:
  11.    "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
  12.    lang: "painless",
  13.   },
  14. });
  15. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "index": "my-index-000001"
  5.   },
  6.   "dest": {
  7.    "index": "my-new-index-000001",
  8.    "version_type": "external"
  9.   },
  10.   "script": {
  11.    "source": "if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}",
  12.    "lang": "painless"
  13.   }
  14. }

_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 リクエストで使用するバージョンに関係なく、ドキュメントが宛先で上書きされます。

Reindex from remote

リインデックスは、リモート Elasticsearch クラスターからの再インデックス化をサポートしています:

Python

  1. resp = client.reindex(
  2.    source={
  3.    "remote": {
  4.    "host": "http://otherhost:9200",
  5.    "username": "user",
  6.    "password": "pass"
  7.    },
  8.    "index": "my-index-000001",
  9.    "query": {
  10.    "match": {
  11.    "test": "data"
  12.    }
  13.    }
  14.    },
  15.    dest={
  16.    "index": "my-new-index-000001"
  17.    },
  18. )
  19. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    remote: {
  5.    host: 'http://otherhost:9200',
  6.    username: 'user',
  7.    password: 'pass'
  8.    },
  9.    index: 'my-index-000001',
  10.    query: {
  11.    match: {
  12.    test: 'data'
  13.    }
  14.    }
  15.    },
  16.    dest: {
  17.    index: 'my-new-index-000001'
  18.    }
  19.   }
  20. )
  21. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    remote: {
  4.    host: "http://otherhost:9200",
  5.    username: "user",
  6.    password: "pass",
  7.    },
  8.    index: "my-index-000001",
  9.    query: {
  10.    match: {
  11.    test: "data",
  12.    },
  13.    },
  14.   },
  15.   dest: {
  16.    index: "my-new-index-000001",
  17.   },
  18. });
  19. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "remote": {
  5.    "host": "http://otherhost:9200",
  6.    "username": "user",
  7.    "password": "pass"
  8.    },
  9.    "index": "my-index-000001",
  10.    "query": {
  11.    "match": {
  12.    "test": "data"
  13.    }
  14.    }
  15.   },
  16.   "dest": {
  17.    "index": "my-new-index-000001"
  18.   }
  19. }

host パラメータには、スキーム、ホスト、ポート (例: https://otherhost:9200)、およびオプションのパス (例: https://otherhost:9200/proxy) が含まれている必要があります。username および password パラメータはオプションであり、これらが存在する場合、_reindex は基本認証を使用してリモート Elasticsearch ノードに接続します。基本認証を使用する場合は https を使用してください。さもなければ、パスワードは平文で送信されます。https 接続の動作を構成するためのさまざまな 設定 が利用可能です。

Elastic Cloud を使用している場合、有効な API キーを使用してリモートクラスターに対して認証することも可能です:

Python

  1. resp = client.reindex(
  2.    source={
  3.    "remote": {
  4.    "host": "http://otherhost:9200",
  5.    "headers": {
  6.    "Authorization": "ApiKey API_KEY_VALUE"
  7.    }
  8.    },
  9.    "index": "my-index-000001",
  10.    "query": {
  11.    "match": {
  12.    "test": "data"
  13.    }
  14.    }
  15.    },
  16.    dest={
  17.    "index": "my-new-index-000001"
  18.    },
  19. )
  20. print(resp)

Ruby

  1. response = client.reindex(
  2.   body: {
  3.    source: {
  4.    remote: {
  5.    host: 'http://otherhost:9200',
  6.    headers: {
  7.    "Authorization": 'ApiKey API_KEY_VALUE'
  8.    }
  9.    },
  10.    index: 'my-index-000001',
  11.    query: {
  12.    match: {
  13.    test: 'data'
  14.    }
  15.    }
  16.    },
  17.    dest: {
  18.    index: 'my-new-index-000001'
  19.    }
  20.   }
  21. )
  22. puts response

Js

  1. const response = await client.reindex({
  2.   source: {
  3.    remote: {
  4.    host: "http://otherhost:9200",
  5.    headers: {
  6.    Authorization: "ApiKey API_KEY_VALUE",
  7.    },
  8.    },
  9.    index: "my-index-000001",
  10.    query: {
  11.    match: {
  12.    test: "data",
  13.    },
  14.    },
  15.   },
  16.   dest: {
  17.    index: "my-new-index-000001",
  18.   },
  19. });
  20. console.log(response);

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "remote": {
  5.    "host": "http://otherhost:9200",
  6.    "headers": {
  7.    "Authorization": "ApiKey API_KEY_VALUE"
  8.    }
  9.    },
  10.    "index": "my-index-000001",
  11.    "query": {
  12.    "match": {
  13.    "test": "data"
  14.    }
  15.    }
  16.   },
  17.   "dest": {
  18.    "index": "my-new-index-000001"
  19.   }
  20. }

リモートホストは、elasticsearch.yml で reindex.remote.whitelist プロパティを使用して明示的に許可する必要があります。許可されたリモート host と port の組み合わせのカンマ区切りリストに設定できます。スキームは無視され、ホストとポートのみが使用されます。例えば:

Yaml

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

許可されたホストのリストは、再インデックスを調整するノードで構成する必要があります。

この機能は、見つかる可能性のある任意のバージョンのリモートクラスターで機能するはずです。これにより、古いバージョンのクラスターから再インデックス化することで、任意のバージョンの Elasticsearch から現在のバージョンにアップグレードできるはずです。

Elasticsearch は、メジャーバージョン間の前方互換性をサポートしていません。たとえば、7.x クラスターから 6.x クラスターに再インデックス化することはできません。

古いバージョンの Elasticsearch に送信されたクエリを有効にするために、query パラメータは検証や変更なしにリモートホストに直接送信されます。

リモートクラスターからの再インデックスは、手動または自動スライスをサポートしていません。

リモートサーバーからの再インデックス化は、デフォルトで最大サイズが 100mb のヒープ内バッファを使用します。リモートインデックスに非常に大きなドキュメントが含まれている場合は、より小さなバッチサイズを使用する必要があります。以下の例では、バッチサイズを 10 に設定しています。これは非常に非常に小さいです。

Console

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "remote": {
  5.    "host": "http://otherhost:9200",
  6.    ...
  7.    },
  8.    "index": "source",
  9.    "size": 10,
  10.    "query": {
  11.    "match": {
  12.    "test": "data"
  13.    }
  14.    }
  15.   },
  16.   "dest": {
  17.    "index": "dest"
  18.   }
  19. }

リモート接続のソケット読み取りタイムアウトを socket_timeout フィールドで設定し、接続タイムアウトを connect_timeout フィールドで設定することも可能です。両方ともデフォルトで 30 秒です。この例では、ソケット読み取りタイムアウトを 1 分、接続タイムアウトを 10 秒に設定します:

コンソール

  1. POST _reindex
  2. {
  3.   "source": {
  4.    "remote": {
  5.    "host": "http://otherhost:9200",
  6.    ...,
  7.    "socket_timeout": "1m",
  8.    "connect_timeout": "10s"
  9.    },
  10.    "index": "source",
  11.    "query": {
  12.    "match": {
  13.    "test": "data"
  14.    }
  15.    }
  16.   },
  17.   "dest": {
  18.    "index": "dest"
  19.   }
  20. }

Configuring SSL parameters

リモートからの再インデックスは、構成可能な 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 (Secure)
  • トラストストアのパスワード (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 (Secure)
  • 暗号化されている場合、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 (Secure)
  • キーストアのパスワード (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 (Secure)
  • キーストア内のキーのパスワード (reindex.ssl.keystore.path)。デフォルトはキーストアのパスワードです。この設定は reindex.ssl.keystore.key_password と一緒に使用できません。