« 创建快照 可搜索快照 »
Elastic 文档 ›Elasticsearch 指南 [8.17] ›快照和恢复

恢复快照

编辑

恢复快照

编辑

本指南将向您展示如何恢复快照。快照是一种将数据副本存储在集群之外的便捷方式。您可以恢复快照以在删除或硬件故障后恢复索引和数据流。您还可以使用快照在集群之间传输数据。

在本指南中，您将学习如何

  • 获取可用快照列表
  • 从快照恢复索引或数据流
  • 恢复功能状态
  • 恢复整个集群
  • 监控恢复操作
  • 取消正在进行的恢复

本指南还提供了恢复到另一个集群和排除常见恢复错误故障的提示。

先决条件

编辑

  • 要使用 Kibana 的 快照和恢复 功能，您必须具有以下权限

    • 集群权限：monitor，manage_slm，cluster:admin/snapshot 和 cluster:admin/repository
    • 索引权限：all 在 monitor 索引上
  • 您只能将快照恢复到具有选定主节点的正在运行的集群。快照的存储库必须已注册并且可供集群使用。
  • 快照和集群版本必须兼容。请参阅快照兼容性。
  • 要恢复快照，集群的全局元数据必须是可写的。请确保没有任何集群块阻止写入。恢复操作会忽略索引块。

  • 在恢复数据流之前，请确保集群包含一个启用了数据流的匹配的索引模板。要检查，请使用 Kibana 的索引管理功能或获取索引模板 API

    resp = client.indices.get_index_template(
    name="*",
    filter_path="index_templates.name,index_templates.index_template.index_patterns,index_templates.index_template.data_stream",
)
print(resp)
    response = client.indices.get_index_template(
  name: '*',
  filter_path: 'index_templates.name,index_templates.index_template.index_patterns,index_templates.index_template.data_stream'
)
puts response
    const response = await client.indices.getIndexTemplate({
  name: "*",
  filter_path:
    "index_templates.name,index_templates.index_template.index_patterns,index_templates.index_template.data_stream",
});
console.log(response);
    GET _index_template/*?filter_path=index_templates.name,index_templates.index_template.index_patterns,index_templates.index_template.data_stream

    如果不存在此类模板，您可以创建一个或恢复包含一个索引模板的集群状态。如果没有匹配的索引模板，数据流将无法滚动或创建后备索引。

  • 如果您的快照包含来自 App Search 或 Workplace Search 的数据，请确保在恢复快照之前恢复企业搜索加密密钥。

注意事项

编辑

从快照恢复数据时，请注意以下几点

  • 如果您恢复数据流，您还将恢复其后备索引。
  • 仅当现有索引关闭且快照中的索引具有相同数量的主分片时，才能恢复该索引。
  • 您无法恢复现有的打开索引。这包括数据流的后备索引。
  • 恢复操作会自动打开恢复的索引，包括后备索引。
  • 您只能从数据流中恢复特定的后备索引。但是，恢复操作不会将恢复的后备索引添加到任何现有数据流中。

获取可用快照列表

编辑

要在 Kibana 中查看可用快照列表，请转到主菜单，然后单击 堆栈管理 > 快照和恢复。

您还可以使用获取存储库 API和获取快照 API来查找可用于恢复的快照。首先，使用获取存储库 API 获取注册的快照存储库列表。

resp = client.snapshot.get_repository()
print(resp)
response = client.snapshot.get_repository
puts response
const response = await client.snapshot.getRepository();
console.log(response);
GET _snapshot

然后，使用获取快照 API 获取特定存储库中的快照列表。这还会返回每个快照的内容。

resp = client.snapshot.get(
    repository="my_repository",
    snapshot="*",
    verbose=False,
)
print(resp)
response = client.snapshot.get(
  repository: 'my_repository',
  snapshot: '*',
  verbose: false
)
puts response
const response = await client.snapshot.get({
  repository: "my_repository",
  snapshot: "*",
  verbose: "false",
});
console.log(response);
GET _snapshot/my_repository/*?verbose=false

恢复索引或数据流

编辑

您可以使用 Kibana 的 快照和恢复 功能或恢复快照 API来恢复快照。

默认情况下，恢复请求会尝试恢复快照中的所有常规索引和常规数据流。在大多数情况下，您只需要从快照中恢复特定的索引或数据流。但是，您无法恢复现有的打开索引。

如果您要将数据恢复到预先存在的集群，请使用以下方法之一以避免与现有索引和数据流发生冲突

删除并恢复

编辑

避免冲突的最简单方法是在恢复现有索引或数据流之前将其删除。为了防止意外重新创建索引或数据流，我们建议您在恢复操作完成之前暂时停止所有索引。

如果 action.destructive_requires_name 集群设置是 false，请勿使用 删除索引 API 来定位 * 或 .* 通配符模式。如果您使用 Elasticsearch 的安全功能，这将删除身份验证所需的系统索引。而是定位 *,-.* 通配符模式以排除这些系统索引和其他以点号 ( . ) 开头的索引名称。

resp = client.indices.delete(
    index="my-index",
)
print(resp)

resp1 = client.indices.delete_data_stream(
    name="logs-my_app-default",
)
print(resp1)
response = client.indices.delete(
  index: 'my-index'
)
puts response

response = client.indices.delete_data_stream(
  name: 'logs-my_app-default'
)
puts response
const response = await client.indices.delete({
  index: "my-index",
});
console.log(response);

const response1 = await client.indices.deleteDataStream({
  name: "logs-my_app-default",
});
console.log(response1);
# Delete an index
DELETE my-index

# Delete a data stream
DELETE _data_stream/logs-my_app-default

在恢复请求中，显式指定要恢复的任何索引和数据流。

resp = client.snapshot.restore(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
    indices="my-index,logs-my_app-default",
)
print(resp)
response = client.snapshot.restore(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06',
  body: {
    indices: 'my-index,logs-my_app-default'
  }
)
puts response
const response = await client.snapshot.restore({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
  indices: "my-index,logs-my_app-default",
});
console.log(response);
POST _snapshot/my_repository/my_snapshot_2099.05.06/_restore
{
  "indices": "my-index,logs-my_app-default"
}

在恢复时重命名

编辑

如果您想避免删除现有数据，则可以重命名恢复的索引和数据流。您通常使用此方法将现有数据与快照中的历史数据进行比较。例如，您可以使用此方法在意外更新或删除后查看文档。

在开始之前，请确保集群具有足够的容量来容纳现有数据和恢复的数据。

以下恢复快照 API 请求会将 restored- 添加到任何恢复的索引或数据流的名称中。

resp = client.snapshot.restore(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
    indices="my-index,logs-my_app-default",
    rename_pattern="(.+)",
    rename_replacement="restored-$1",
)
print(resp)
response = client.snapshot.restore(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06',
  body: {
    indices: 'my-index,logs-my_app-default',
    rename_pattern: '(.+)',
    rename_replacement: 'restored-$1'
  }
)
puts response
const response = await client.snapshot.restore({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
  indices: "my-index,logs-my_app-default",
  rename_pattern: "(.+)",
  rename_replacement: "restored-$1",
});
console.log(response);
POST _snapshot/my_repository/my_snapshot_2099.05.06/_restore
{
  "indices": "my-index,logs-my_app-default",
  "rename_pattern": "(.+)",
  "rename_replacement": "restored-$1"
}

如果重命名选项产生两个或多个名称相同的索引或数据流，则恢复操作将失败。

如果您重命名数据流，其后备索引也会被重命名。例如，如果您将 logs-my_app-default 数据流重命名为 restored-logs-my_app-default，则后备索引 .ds-logs-my_app-default-2099.03.09-000005 将重命名为 .ds-restored-logs-my_app-default-2099.03.09-000005。

恢复操作完成后，您可以比较原始数据和恢复的数据。如果您不再需要原始索引或数据流，可以将其删除并使用 重新索引来重命名恢复的索引或数据流。

resp = client.indices.delete(
    index="my-index",
)
print(resp)

resp1 = client.reindex(
    source={
        "index": "restored-my-index"
    },
    dest={
        "index": "my-index"
    },
)
print(resp1)

resp2 = client.indices.delete_data_stream(
    name="logs-my_app-default",
)
print(resp2)

resp3 = client.reindex(
    source={
        "index": "restored-logs-my_app-default"
    },
    dest={
        "index": "logs-my_app-default",
        "op_type": "create"
    },
)
print(resp3)
response = client.indices.delete(
  index: 'my-index'
)
puts response

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

response = client.indices.delete_data_stream(
  name: 'logs-my_app-default'
)
puts response

response = client.reindex(
  body: {
    source: {
      index: 'restored-logs-my_app-default'
    },
    dest: {
      index: 'logs-my_app-default',
      op_type: 'create'
    }
  }
)
puts response
const response = await client.indices.delete({
  index: "my-index",
});
console.log(response);

const response1 = await client.reindex({
  source: {
    index: "restored-my-index",
  },
  dest: {
    index: "my-index",
  },
});
console.log(response1);

const response2 = await client.indices.deleteDataStream({
  name: "logs-my_app-default",
});
console.log(response2);

const response3 = await client.reindex({
  source: {
    index: "restored-logs-my_app-default",
  },
  dest: {
    index: "logs-my_app-default",
    op_type: "create",
  },
});
console.log(response3);
# Delete the original index
DELETE my-index

# Reindex the restored index to rename it
POST _reindex
{
  "source": {
    "index": "restored-my-index"
  },
  "dest": {
    "index": "my-index"
  }
}

# Delete the original data stream
DELETE _data_stream/logs-my_app-default

# Reindex the restored data stream to rename it
POST _reindex
{
  "source": {
    "index": "restored-logs-my_app-default"
  },
  "dest": {
    "index": "logs-my_app-default",
    "op_type": "create"
  }
}

恢复功能状态

编辑

您可以恢复功能状态以从快照中恢复功能系统的索引、系统数据流和其他配置数据。

如果您恢复快照的集群状态，则默认情况下该操作会恢复快照中的所有功能状态。同样，如果您不恢复快照的集群状态，则默认情况下该操作不会恢复任何功能状态。您也可以选择仅从快照中恢复特定的功能状态，而不管集群状态如何。

要查看快照的功能状态，请使用获取快照 API。

resp = client.snapshot.get(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
)
print(resp)
response = client.snapshot.get(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06'
)
puts response
const response = await client.snapshot.get({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
});
console.log(response);
GET _snapshot/my_repository/my_snapshot_2099.05.06

响应的 feature_states 属性包含快照中的功能列表以及每个功能的索引。

要从快照中恢复特定的功能状态，请在恢复快照 API 的 feature_states 参数中指定响应中的 feature_name。

当您恢复功能状态时，Elasticsearch 会关闭并覆盖该功能的现有索引。

恢复 security 功能状态会覆盖用于身份验证的系统索引。如果您使用 Elasticsearch Service，请确保在恢复 security 功能状态之前可以访问 Elasticsearch Service 控制台。如果您在自己的硬件上运行 Elasticsearch，请在文件领域中创建一个超级用户，以确保您仍然能够访问您的集群。

resp = client.snapshot.restore(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
    feature_states=[
        "geoip"
    ],
    include_global_state=False,
    indices="-*",
)
print(resp)
response = client.snapshot.restore(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06',
  body: {
    feature_states: [
      'geoip'
    ],
    include_global_state: false,
    indices: '-*'
  }
)
puts response
const response = await client.snapshot.restore({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
  feature_states: ["geoip"],
  include_global_state: false,
  indices: "-*",
});
console.log(response);
POST _snapshot/my_repository/my_snapshot_2099.05.06/_restore
{
  "feature_states": [ "geoip" ],
  "include_global_state": false,    
  "indices": "-*"                   
}

从恢复操作中排除集群状态。

从恢复操作中排除快照中的其他索引和数据流。

恢复整个集群

编辑

在某些情况下，您需要从快照恢复整个集群，包括集群状态和所有功能状态。这些情况应该很少发生，例如在发生灾难性故障时。

恢复整个集群涉及删除重要的系统索引，包括用于身份验证的索引。请考虑是否可以改为恢复特定的索引或数据流。

如果要恢复到不同的集群，请在开始之前查看恢复到不同的集群。

  1. 如果您备份了集群的配置文件，您可以将它们恢复到每个节点。此步骤是可选的，并且需要完全集群重启。

    在您关闭节点后，将备份的配置文件复制到该节点的 $ES_PATH_CONF 目录。在重启节点之前，请确保 elasticsearch.yml 包含适当的节点角色、节点名称和其他特定于节点的设置。

    如果您选择执行此步骤，则必须在集群中的每个节点上重复此过程。

  2. 暂时停止索引并关闭以下功能

    • GeoIP 数据库下载器和 ILM 历史存储

      resp = client.cluster.put_settings(
    persistent={
        "ingest.geoip.downloader.enabled": False,
        "indices.lifecycle.history_index_enabled": False
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'ingest.geoip.downloader.enabled' => false,
      'indices.lifecycle.history_index_enabled' => false
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "ingest.geoip.downloader.enabled": false,
    "indices.lifecycle.history_index_enabled": false,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "ingest.geoip.downloader.enabled": false,
    "indices.lifecycle.history_index_enabled": false
  }
}

    • ILM

      resp = client.ilm.stop()
print(resp)
      response = client.ilm.stop
puts response
      const response = await client.ilm.stop();
console.log(response);
      POST _ilm/stop

    • 机器学习

      resp = client.ml.set_upgrade_mode(
    enabled=True,
)
print(resp)
      response = client.ml.set_upgrade_mode(
  enabled: true
)
puts response
      const response = await client.ml.setUpgradeMode({
  enabled: "true",
});
console.log(response);
      POST _ml/set_upgrade_mode?enabled=true

    • 监控

      resp = client.cluster.put_settings(
    persistent={
        "xpack.monitoring.collection.enabled": False
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'xpack.monitoring.collection.enabled' => false
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "xpack.monitoring.collection.enabled": false,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "xpack.monitoring.collection.enabled": false
  }
}

    • Watcher

      resp = client.watcher.stop()
print(resp)
      response = client.watcher.stop
puts response
      const response = await client.watcher.stop();
console.log(response);
      POST _watcher/_stop

    • 通用分析

      检查是否启用了通用分析索引模板管理

      resp = client.cluster.get_settings(
    filter_path="**.xpack.profiling.templates.enabled",
    include_defaults=True,
)
print(resp)
      response = client.cluster.get_settings(
  filter_path: '**.xpack.profiling.templates.enabled',
  include_defaults: true
)
puts response
      const response = await client.cluster.getSettings({
  filter_path: "**.xpack.profiling.templates.enabled",
  include_defaults: "true",
});
console.log(response);
      GET /_cluster/settings?filter_path=**.xpack.profiling.templates.enabled&include_defaults=true

      如果值为 true，则禁用通用分析索引模板管理

      resp = client.cluster.put_settings(
    persistent={
        "xpack.profiling.templates.enabled": False
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'xpack.profiling.templates.enabled' => false
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "xpack.profiling.templates.enabled": false,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "xpack.profiling.templates.enabled": false
  }
}

  3. 如果您使用 Elasticsearch 安全功能，请登录到节点主机，导航到 Elasticsearch 安装目录，然后使用 elasticsearch-users 工具向文件 realm 添加具有 superuser 角色的用户。

    例如，以下命令创建一个名为 restore_user 的用户。

    ./bin/elasticsearch-users useradd restore_user -p my_password -r superuser

    在恢复操作完成之前，使用此文件 realm 用户对请求进行身份验证。

  4. 使用 集群更新设置 API 将 action.destructive_requires_name 设置为 false。这允许您使用通配符删除数据流和索引。

    resp = client.cluster.put_settings(
    persistent={
        "action.destructive_requires_name": False
    },
)
print(resp)
    response = client.cluster.put_settings(
  body: {
    persistent: {
      'action.destructive_requires_name' => false
    }
  }
)
puts response
    const response = await client.cluster.putSettings({
  persistent: {
    "action.destructive_requires_name": false,
  },
});
console.log(response);
    PUT _cluster/settings
{
  "persistent": {
    "action.destructive_requires_name": false
  }
}

  5. 删除集群上的所有现有数据流。

    resp = client.indices.delete_data_stream(
    name="*",
    expand_wildcards="all",
)
print(resp)
    response = client.indices.delete_data_stream(
  name: '*',
  expand_wildcards: 'all'
)
puts response
    const response = await client.indices.deleteDataStream({
  name: "*",
  expand_wildcards: "all",
});
console.log(response);
    DELETE _data_stream/*?expand_wildcards=all

  6. 删除集群上的所有现有索引。

    resp = client.indices.delete(
    index="*",
    expand_wildcards="all",
)
print(resp)
    response = client.indices.delete(
  index: '*',
  expand_wildcards: 'all'
)
puts response
    const response = await client.indices.delete({
  index: "*",
  expand_wildcards: "all",
});
console.log(response);
    DELETE *?expand_wildcards=all

  7. 恢复整个快照，包括集群状态。默认情况下，恢复集群状态还会恢复快照中的任何功能状态。

    resp = client.snapshot.restore(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
    indices="*",
    include_global_state=True,
)
print(resp)
    response = client.snapshot.restore(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06',
  body: {
    indices: '*',
    include_global_state: true
  }
)
puts response
    const response = await client.snapshot.restore({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
  indices: "*",
  include_global_state: true,
});
console.log(response);
    POST _snapshot/my_repository/my_snapshot_2099.05.06/_restore
{
  "indices": "*",
  "include_global_state": true
}

  8. 当恢复操作完成时，恢复索引并重新启动您停止的任何功能

    当快照恢复后，快照拍摄时使用的许可证也将恢复。如果您的许可证自拍摄快照后已过期，您将需要使用 更新许可证 API 来安装当前许可证。

    • GeoIP 数据库下载器和 ILM 历史存储

      resp = client.cluster.put_settings(
    persistent={
        "ingest.geoip.downloader.enabled": True,
        "indices.lifecycle.history_index_enabled": True
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'ingest.geoip.downloader.enabled' => true,
      'indices.lifecycle.history_index_enabled' => true
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "ingest.geoip.downloader.enabled": true,
    "indices.lifecycle.history_index_enabled": true,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "ingest.geoip.downloader.enabled": true,
    "indices.lifecycle.history_index_enabled": true
  }
}

    • ILM

      resp = client.ilm.start()
print(resp)
      response = client.ilm.start
puts response
      const response = await client.ilm.start();
console.log(response);
      POST _ilm/start

    • 机器学习

      resp = client.ml.set_upgrade_mode(
    enabled=False,
)
print(resp)
      response = client.ml.set_upgrade_mode(
  enabled: false
)
puts response
      const response = await client.ml.setUpgradeMode({
  enabled: "false",
});
console.log(response);
      POST _ml/set_upgrade_mode?enabled=false

    • 监控

      resp = client.cluster.put_settings(
    persistent={
        "xpack.monitoring.collection.enabled": True
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'xpack.monitoring.collection.enabled' => true
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "xpack.monitoring.collection.enabled": true,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "xpack.monitoring.collection.enabled": true
  }
}

    • Watcher

      resp = client.watcher.start()
print(resp)
      response = client.watcher.start
puts response
      const response = await client.watcher.start();
console.log(response);
      POST _watcher/_start

    • 通用分析

      如果初始值为 true，则重新启用通用分析索引模板管理，否则跳过此步骤

      resp = client.cluster.put_settings(
    persistent={
        "xpack.profiling.templates.enabled": True
    },
)
print(resp)
      response = client.cluster.put_settings(
  body: {
    persistent: {
      'xpack.profiling.templates.enabled' => true
    }
  }
)
puts response
      const response = await client.cluster.putSettings({
  persistent: {
    "xpack.profiling.templates.enabled": true,
  },
});
console.log(response);
      PUT _cluster/settings
{
  "persistent": {
    "xpack.profiling.templates.enabled": true
  }
}

  9. 如果需要，重置 action.destructive_requires_name 集群设置。

    resp = client.cluster.put_settings(
    persistent={
        "action.destructive_requires_name": None
    },
)
print(resp)
    response = client.cluster.put_settings(
  body: {
    persistent: {
      'action.destructive_requires_name' => nil
    }
  }
)
puts response
    const response = await client.cluster.putSettings({
  persistent: {
    "action.destructive_requires_name": null,
  },
});
console.log(response);
    PUT _cluster/settings
{
  "persistent": {
    "action.destructive_requires_name": null
  }
}

监控恢复

编辑

恢复操作使用 分片恢复过程 从快照恢复索引的主分片。当恢复操作恢复主分片时，集群将具有 yellow 健康状态。

在所有主分片恢复后，复制过程会创建副本并将其分布到符合条件的数据节点上。当复制完成时，集群健康状态通常变为 green。

一旦您在 Kibana 中开始恢复，您将被导航到恢复状态页面。您可以使用此页面来跟踪快照中每个分片的当前状态。

您还可以使用 Elasticsearch API 监控快照恢复。要监控集群健康状态，请使用 集群健康 API。

$response = $client->cluster()->health();
resp = client.cluster.health()
print(resp)
response = client.cluster.health
puts response
res, err := es.Cluster.Health()
fmt.Println(res, err)
const response = await client.cluster.health();
console.log(response);
GET _cluster/health

要获取有关正在进行的分片恢复的详细信息，请使用 索引恢复 API。

resp = client.indices.recovery(
    index="my-index",
)
print(resp)
response = client.indices.recovery(
  index: 'my-index'
)
puts response
const response = await client.indices.recovery({
  index: "my-index",
});
console.log(response);
GET my-index/_recovery

要查看任何未分配的分片，请使用 cat 分片 API。

resp = client.cat.shards(
    v=True,
    h="index,shard,prirep,state,node,unassigned.reason",
    s="state",
)
print(resp)
response = client.cat.shards(
  v: true,
  h: 'index,shard,prirep,state,node,unassigned.reason',
  s: 'state'
)
puts response
const response = await client.cat.shards({
  v: "true",
  h: "index,shard,prirep,state,node,unassigned.reason",
  s: "state",
});
console.log(response);
GET _cat/shards?v=true&h=index,shard,prirep,state,node,unassigned.reason&s=state

未分配的分片的 state 为 UNASSIGNED。prirep 值对于主分片为 p，对于副本为 r。unassigned.reason 描述了分片保持未分配的原因。

要更深入地解释未分配的分片的分配状态，请使用 集群分配解释 API。

resp = client.cluster.allocation_explain(
    index="my-index",
    shard=0,
    primary=False,
    current_node="my-node",
)
print(resp)
response = client.cluster.allocation_explain(
  body: {
    index: 'my-index',
    shard: 0,
    primary: false,
    current_node: 'my-node'
  }
)
puts response
const response = await client.cluster.allocationExplain({
  index: "my-index",
  shard: 0,
  primary: false,
  current_node: "my-node",
});
console.log(response);
GET _cluster/allocation/explain
{
  "index": "my-index",
  "shard": 0,
  "primary": false,
  "current_node": "my-node"
}

取消恢复

编辑

您可以删除索引或数据流以取消其正在进行的恢复。这也会删除集群中索引或数据流的任何现有数据。删除索引或数据流不会影响快照或其数据。

resp = client.indices.delete(
    index="my-index",
)
print(resp)

resp1 = client.indices.delete_data_stream(
    name="logs-my_app-default",
)
print(resp1)
response = client.indices.delete(
  index: 'my-index'
)
puts response

response = client.indices.delete_data_stream(
  name: 'logs-my_app-default'
)
puts response
const response = await client.indices.delete({
  index: "my-index",
});
console.log(response);

const response1 = await client.indices.deleteDataStream({
  name: "logs-my_app-default",
});
console.log(response1);
# Delete an index
DELETE my-index

# Delete a data stream
DELETE _data_stream/logs-my_app-default

恢复到不同的集群

编辑

Elasticsearch Service 可以帮助您从其他部署恢复快照。请参阅 使用快照。

快照不与特定集群或集群名称绑定。您可以在一个集群中创建快照，并在另一个兼容的集群中恢复它。从快照恢复的任何数据流或索引也必须与当前集群的版本兼容。集群的拓扑结构不需要匹配。

要恢复快照，必须注册其仓库并且对新集群可用。如果原始集群仍然对仓库具有写入权限，请将该仓库注册为只读。这可以防止多个集群同时写入仓库并损坏仓库的内容。它还可以防止 Elasticsearch 缓存仓库的内容，这意味着其他集群所做的更改将立即可见。

在开始恢复操作之前，请确保新集群有足够的容量来存储您要恢复的任何数据流或索引。如果新集群的容量较小，您可以

  • 添加节点或升级硬件以增加容量。
  • 恢复较少的索引和数据流。

  • 减少恢复的索引的副本数量。

    例如，以下恢复快照 API 请求使用 index_settings 选项将 index.number_of_replicas 设置为 1。

    resp = client.snapshot.restore(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
    indices="my-index,logs-my_app-default",
    index_settings={
        "index.number_of_replicas": 1
    },
)
print(resp)
    response = client.snapshot.restore(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06',
  body: {
    indices: 'my-index,logs-my_app-default',
    index_settings: {
      'index.number_of_replicas' => 1
    }
  }
)
puts response
    const response = await client.snapshot.restore({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
  indices: "my-index,logs-my_app-default",
  index_settings: {
    "index.number_of_replicas": 1,
  },
});
console.log(response);
    POST _snapshot/my_repository/my_snapshot_2099.05.06/_restore
{
  "indices": "my-index,logs-my_app-default",
  "index_settings": {
    "index.number_of_replicas": 1
  }
}

如果原始集群中的索引或后备索引是使用分片分配过滤分配给特定节点的，则相同的规则将在新集群中强制执行。如果新集群不包含可以分配恢复索引的具有适当属性的节点，则除非在恢复操作期间更改这些索引分配设置，否则索引将无法成功恢复。

恢复操作还会检查恢复的持久设置是否与当前集群兼容，以避免意外恢复不兼容的设置。如果您需要恢复具有不兼容持久设置的快照，请尝试在不使用全局集群状态的情况下恢复它。

解决恢复错误

编辑

以下是如何解决恢复请求返回的常见错误。

无法恢复索引 [<索引>]，因为集群中已经存在具有相同名称的打开索引

编辑

您无法恢复已存在的打开索引。要解决此错误，请尝试 恢复索引或数据流 中的方法之一。

无法从具有 [y] 个分片的索引 [<snapshot-index>] 的快照恢复具有 [x] 个分片的索引 [<索引>]

编辑

仅当现有索引已关闭且快照中的索引具有相同数量的主分片时，才能恢复现有索引。此错误表明快照中的索引具有不同数量的主分片。

要解决此错误，请尝试 恢复索引或数据流 中的方法之一。

« 创建快照 可搜索快照 »