Создание моментального снимка

Это руководство показывает, как делать снимки моментального состояния работающего кластера. Позже вы можете восстановить снимок, чтобы восстановить или перенести данные.

В этом руководстве вы узнаете, как:

В руководстве также приведены советы по созданию снимков состояния кластера и созданию снимков с разными интервалами.

Управление жизненным циклом снимков (SLM) является наиболее простым способом регулярного резервного копирования кластера. Политика SLM автоматически создаёт снимки по заданному расписанию. Политика также может удалять снимки на основе правил удержания, которые вы определяете.

Следующие права доступа к кластеру контролируют доступ к действиям SLM при включенных функциях безопасности Elasticsearch:

Вы можете создавать и управлять ролями для назначения этих прав через Kibana Management.

Для предоставления прав, необходимых для создания и управления политиками SLM и снимками, вы можете настроить роль с правами кластера manage_slm и cluster:admin/snapshot/* и полным доступом к истории SLM.

Например, следующий запрос создаёт роль slm-admin:

resp = client.security.put_role(
    name="slm-admin",
    cluster=[
        "manage_slm",
        "cluster:admin/snapshot/*"
    ],
    indices=[
        {
            "names": [
                ".slm-history-*"
            ],
            "privileges": [
                "all"
            ]
        }
    ],
)
print(resp)

const response = await client.security.putRole({
  name: "slm-admin",
  cluster: ["manage_slm", "cluster:admin/snapshot/*"],
  indices: [
    {
      names: [".slm-history-*"],
      privileges: ["all"],
    },
  ],
});
console.log(response);

POST _security/role/slm-admin
{
  "cluster": [ "manage_slm", "cluster:admin/snapshot/*" ],
  "indices": [
    {
      "names": [ ".slm-history-*" ],
      "privileges": [ "all" ]
    }
  ]
}

Для предоставления только прав доступа для чтения к политикам SLM и истории снимков вы можете настроить роль с правом доступа к кластеру read_slm и чтению истории управления жизненным циклом снимков.

Например, следующий запрос создаёт роль slm-read-only:

resp = client.security.put_role(
    name="slm-read-only",
    cluster=[
        "read_slm"
    ],
    indices=[
        {
            "names": [
                ".slm-history-*"
            ],
            "privileges": [
                "read"
            ]
        }
    ],
)
print(resp)

const response = await client.security.putRole({
  name: "slm-read-only",
  cluster: ["read_slm"],
  indices: [
    {
      names: [".slm-history-*"],
      privileges: ["read"],
    },
  ],
});
console.log(response);

POST _security/role/slm-read-only
{
  "cluster": [ "read_slm" ],
  "indices": [
    {
      "names": [ ".slm-history-*" ],
      "privileges": [ "read" ]
    }
  ]
}

Чтобы управлять SLM в Kibana, перейдите в главное меню и нажмите Управление стеком > Снимок и восстановление > Политики. Чтобы создать политику, нажмите Создать политику.

Вы также можете управлять SLM с помощью API SLM. Для создания политики используйте API создания политики SLM.

Следующий запрос создаёт политику, которая ежедневно в 1:30 по UTC создаёт резервную копию состояния кластера, всех потоков данных и всех индексов.

resp = client.slm.put_lifecycle(
    policy_id="nightly-snapshots",
    schedule="0 30 1 * * ?",
    name="<nightly-snap-{now/d}>",
    repository="my_repository",
    config={
        "indices": "*",
        "include_global_state": True
    },
    retention={
        "expire_after": "30d",
        "min_count": 5,
        "max_count": 50
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "nightly-snapshots",
  schedule: "0 30 1 * * ?",
  name: "<nightly-snap-{now/d}>",
  repository: "my_repository",
  config: {
    indices: "*",
    include_global_state: true,
  },
  retention: {
    expire_after: "30d",
    min_count: 5,
    max_count: 50,
  },
});
console.log(response);

PUT _slm/policy/nightly-snapshots
{
  "schedule": "0 30 1 * * ?",       
  "name": "<nightly-snap-{now/d}>", 
  "repository": "my_repository",    
  "config": {
    "indices": "*",                 
    "include_global_state": true    
  },
  "retention": {                    
    "expire_after": "30d",
    "min_count": 5,
    "max_count": 50
  }
}

Вы можете вручную запустить политику SLM, чтобы немедленно создать снимок. Это полезно для тестирования новой политики или создания снимка перед обновлением. Вручную запуск политики не влияет на её расписание.

Чтобы запустить политику в Kibana, перейдите на страницу Политики и нажмите значок запуска в колонке Действия. Вы также можете использовать API выполнения политики SLM.

POST _slm/policy/nightly-snapshots/_execute

Процесс создания снимка выполняется в фоновом режиме. Чтобы отследить его ход, см. Отслеживание снимка.

Удержание снимков SLM — это задача на уровне кластера, которая выполняется отдельно от расписания создания снимков политики. Чтобы управлять запуском задачи удержания SLM, настройте настройку кластера slm.retention_schedule.

resp = client.cluster.put_settings(
    persistent={
        "slm.retention_schedule": "0 30 1 * * ?"
    },
)
print(resp)

response = client.cluster.put_settings(
  body: {
    persistent: {
      'slm.retention_schedule' => '0 30 1 * * ?'
    }
  }
)
puts response

const response = await client.cluster.putSettings({
  persistent: {
    "slm.retention_schedule": "0 30 1 * * ?",
  },
});
console.log(response);

PUT _cluster/settings
{
  "persistent" : {
    "slm.retention_schedule" : "0 30 1 * * ?"
  }
}

Чтобы немедленно запустить задачу сохранения, используйте API выполнения политики сохранения снимков SLM.

resp = client.slm.execute_retention()
print(resp)

response = client.slm.execute_retention
puts response

const response = await client.slm.executeRetention();
console.log(response);

POST _slm/_execute_retention

Правила сохранения политики SLM применяются только к снимкам, созданным с использованием этой политики. Другие снимки не учитываются в лимитах сохранения политики.

Рекомендуется включать правила сохранения в политику SLM для удаления снимков, которые больше не нужны.

Репозиторий снимков может безопасно масштабироваться до тысяч снимков. Однако для управления его метаданными большой репозиторий требует больше памяти на узле мастера. Правила сохранения гарантируют, что метаданные репозитория не вырастут до размера, который может дестабилизировать мастер-узел.

Для создания снимка без политики SLM используйте API создания снимка. Имя снимка поддерживает математику дат.

resp = client.snapshot.create(
    repository="my_repository",
    snapshot="<my_snapshot_{now/d}>",
)
print(resp)

response = client.snapshot.create(
  repository: 'my_repository',
  snapshot: '<my_snapshot_{now/d}>'
)
puts response

const response = await client.snapshot.create({
  repository: "my_repository",
  snapshot: "<my_snapshot_{now/d}>",
});
console.log(response);

# PUT _snapshot/my_repository/<my_snapshot_{now/d}>
PUT _snapshot/my_repository/%3Cmy_snapshot_%7Bnow%2Fd%7D%3E

В зависимости от размера создание снимка может занять некоторое время. По умолчанию API создания снимка только инициирует процесс создания снимка, который выполняется в фоновом режиме. Чтобы заблокировать клиента до завершения снимка, установите параметр запроса wait_for_completion в значение true.

resp = client.snapshot.create(
    repository="my_repository",
    snapshot="my_snapshot",
    wait_for_completion=True,
)
print(resp)

response = client.snapshot.create(
  repository: 'my_repository',
  snapshot: 'my_snapshot',
  wait_for_completion: true
)
puts response

const response = await client.snapshot.create({
  repository: "my_repository",
  snapshot: "my_snapshot",
  wait_for_completion: "true",
});
console.log(response);

PUT _snapshot/my_repository/my_snapshot?wait_for_completion=true

Вы также можете клонировать существующий снимок, используя API клонирования снимка.

Для мониторинга любых выполняемых в данный момент снимков используйте API получения снимка с параметром пути запроса _current.

resp = client.snapshot.get(
    repository="my_repository",
    snapshot="_current",
)
print(resp)

response = client.snapshot.get(
  repository: 'my_repository',
  snapshot: '_current'
)
puts response

const response = await client.snapshot.get({
  repository: "my_repository",
  snapshot: "_current",
});
console.log(response);

GET _snapshot/my_repository/_current

Чтобы получить полное представление о каждом фрагменте, участвующем в любом текущем выполняемом снимке, используйте API получения статуса снимка.

resp = client.snapshot.status()
print(resp)

response = client.snapshot.status
puts response

const response = await client.snapshot.status();
console.log(response);

GET _snapshot/_status

Чтобы получить больше информации об истории выполнения SLM кластера, включая статистику по каждой политике SLM, используйте API получения статистики SLM. API также возвращает информацию об истории задачи сохранения снимков кластера.

resp = client.slm.get_stats()
print(resp)

response = client.slm.get_stats
puts response

const response = await client.slm.getStats();
console.log(response);

GET _slm/stats

Чтобы получить информацию об истории выполнения определённой политики SLM, используйте API получения политики SLM. Ответ включает:

resp = client.slm.get_lifecycle(
    policy_id="nightly-snapshots",
)
print(resp)

response = client.slm.get_lifecycle(
  policy_id: 'nightly-snapshots'
)
puts response

const response = await client.slm.getLifecycle({
  policy_id: "nightly-snapshots",
});
console.log(response);

GET _slm/policy/nightly-snapshots

Чтобы удалить снимок в Kibana, перейдите на страницу «Снимки» и нажмите значок корзины в столбце «Действия». Вы также можете использовать API удаления снимка.

resp = client.snapshot.delete(
    repository="my_repository",
    snapshot="my_snapshot_2099.05.06",
)
print(resp)

response = client.snapshot.delete(
  repository: 'my_repository',
  snapshot: 'my_snapshot_2099.05.06'
)
puts response

const response = await client.snapshot.delete({
  repository: "my_repository",
  snapshot: "my_snapshot_2099.05.06",
});
console.log(response);

DELETE _snapshot/my_repository/my_snapshot_2099.05.06

Если вы удалите снимок, который находится в процессе создания, Elasticsearch отменит его. Процесс создания снимка остановится, а созданные для него файлы будут удалены. Удаление снимка не удаляет файлы, используемые другими снимками.

Если вы работаете с Elasticsearch на собственном оборудовании, мы рекомендуем, помимо резервного копирования, регулярно создавать резервные копии файлов в каталоге $ES_PATH_CONF каждого узла с помощью программного обеспечения для резервного копирования файлов по вашему выбору. Снимки не создают резервных копий этих файлов. Также обратите внимание, что эти файлы будут отличаться на каждом узле, поэтому файлы каждого узла необходимо резервировать индивидуально.

По умолчанию, снимок, включающий состояние кластера, также включает все состояния компонентов. Аналогично, снимок, исключающий состояние кластера, по умолчанию исключает все состояния компонентов.

Вы также можете настроить снимок так, чтобы он включал только определённые состояния компонентов, независимо от состояния кластера.

Чтобы получить список доступных компонентов, используйте API получения компонентов.

resp = client.features.get_features()
print(resp)

response = client.features.get_features
puts response

const response = await client.features.getFeatures();
console.log(response);

GET _features

API возвращает:

{
  "features": [
    {
      "name": "tasks",
      "description": "Manages task results"
    },
    {
      "name": "kibana",
      "description": "Manages Kibana configuration and reports"
    },
    {
      "name": "security",
      "description": "Manages configuration for Security features, such as users and roles"
    },
    ...
  ]
}

Чтобы включить определённое состояние компонента в снимок, укажите компонент name в массиве feature_states.

Например, следующая политика SLM включает в свои снимки только состояния компонентов для компонентов безопасности Kibana и Elasticsearch.

resp = client.slm.put_lifecycle(
    policy_id="nightly-snapshots",
    schedule="0 30 2 * * ?",
    name="<nightly-snap-{now/d}>",
    repository="my_repository",
    config={
        "indices": "*",
        "include_global_state": True,
        "feature_states": [
            "kibana",
            "security"
        ]
    },
    retention={
        "expire_after": "30d",
        "min_count": 5,
        "max_count": 50
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "nightly-snapshots",
  schedule: "0 30 2 * * ?",
  name: "<nightly-snap-{now/d}>",
  repository: "my_repository",
  config: {
    indices: "*",
    include_global_state: true,
    feature_states: ["kibana", "security"],
  },
  retention: {
    expire_after: "30d",
    min_count: 5,
    max_count: 50,
  },
});
console.log(response);

PUT _slm/policy/nightly-snapshots
{
  "schedule": "0 30 2 * * ?",
  "name": "<nightly-snap-{now/d}>",
  "repository": "my_repository",
  "config": {
    "indices": "*",
    "include_global_state": true,
    "feature_states": [
      "kibana",
      "security"
    ]
  },
  "retention": {
    "expire_after": "30d",
    "min_count": 5,
    "max_count": 50
  }
}

Любой индекс или поток данных, являющийся частью состояния компонента, отобразится в содержимом снимка. Например, если вы создаёте резервную копию состояния компонента security, системные индексы security-* отобразятся в ответе API получения снимка в разделах indices и feature_states.

Некоторые состояния компонентов содержат конфиденциальные данные. Например, состояние компонента security включает системные индексы, которые могут содержать имена пользователей и хеши зашифрованных паролей. Поскольку пароли хранятся с использованием криптографических хешей, разглашение снимка не позволит третьим лицам автоматически аутентифицироваться как один из ваших пользователей или использовать API ключи. Однако это раскроет конфиденциальную информацию, и если у третьих лиц есть возможность изменять снимки, они могут установить бэкдор.

Для лучшей защиты этих данных рекомендуется создать отдельный репозиторий и политику SLM для снимков состояния кластера. Это позволит вам строго ограничить и аудировать доступ к репозиторию.

Например, следующая политика SLM резервирует только состояние кластера. Эта политика сохраняет эти снимки в выделенном репозитории.

resp = client.slm.put_lifecycle(
    policy_id="nightly-cluster-state-snapshots",
    schedule="0 30 2 * * ?",
    name="<nightly-cluster-state-snap-{now/d}>",
    repository="my_secure_repository",
    config={
        "include_global_state": True,
        "indices": "-*"
    },
    retention={
        "expire_after": "30d",
        "min_count": 5,
        "max_count": 50
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "nightly-cluster-state-snapshots",
  schedule: "0 30 2 * * ?",
  name: "<nightly-cluster-state-snap-{now/d}>",
  repository: "my_secure_repository",
  config: {
    include_global_state: true,
    indices: "-*",
  },
  retention: {
    expire_after: "30d",
    min_count: 5,
    max_count: 50,
  },
});
console.log(response);

PUT _slm/policy/nightly-cluster-state-snapshots
{
  "schedule": "0 30 2 * * ?",
  "name": "<nightly-cluster-state-snap-{now/d}>",
  "repository": "my_secure_repository",
  "config": {
    "include_global_state": true,                 
    "indices": "-*"                               
  },
  "retention": {
    "expire_after": "30d",
    "min_count": 5,
    "max_count": 50
  }
}

Если вы создаёте отдельные снимки состояния кластера, вам необходимо исключить состояние кластера из других снимков. Например:

resp = client.slm.put_lifecycle(
    policy_id="nightly-snapshots",
    schedule="0 30 2 * * ?",
    name="<nightly-snap-{now/d}>",
    repository="my_repository",
    config={
        "include_global_state": False,
        "indices": "*"
    },
    retention={
        "expire_after": "30d",
        "min_count": 5,
        "max_count": 50
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "nightly-snapshots",
  schedule: "0 30 2 * * ?",
  name: "<nightly-snap-{now/d}>",
  repository: "my_repository",
  config: {
    include_global_state: false,
    indices: "*",
  },
  retention: {
    expire_after: "30d",
    min_count: 5,
    max_count: 50,
  },
});
console.log(response);

PUT _slm/policy/nightly-snapshots
{
  "schedule": "0 30 2 * * ?",
  "name": "<nightly-snap-{now/d}>",
  "repository": "my_repository",
  "config": {
    "include_global_state": false,    
    "indices": "*"                    
  },
  "retention": {
    "expire_after": "30d",
    "min_count": 5,
    "max_count": 50
  }
}

Если вы используете только одну политику SLM, частое создание снимков и сохранение снимков с более длительными интервалами времени может быть затруднено.

Например, политика, которая создаёт снимки каждые 30 минут с максимальным количеством 100 снимков, будет хранить снимки приблизительно в течение двух дней. Хотя такая настройка отлично подходит для резервного копирования последних изменений, она не позволяет восстановить данные из предыдущей недели или месяца.

Чтобы исправить это, вы можете создать несколько политик SLM с тем же хранилищем снимков, которые работают по разным расписаниям. Поскольку правила хранения политики применяются только к её снимкам, политика не удалит снимок, созданный другой политикой.

Например, следующая политика SLM делает ежечасовые снимки с максимальным количеством 24 снимков. Политика хранит свои снимки в течение одного дня.

resp = client.slm.put_lifecycle(
    policy_id="hourly-snapshots",
    name="<hourly-snapshot-{now/d}>",
    schedule="0 0 * * * ?",
    repository="my_repository",
    config={
        "indices": "*",
        "include_global_state": True
    },
    retention={
        "expire_after": "1d",
        "min_count": 1,
        "max_count": 24
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "hourly-snapshots",
  name: "<hourly-snapshot-{now/d}>",
  schedule: "0 0 * * * ?",
  repository: "my_repository",
  config: {
    indices: "*",
    include_global_state: true,
  },
  retention: {
    expire_after: "1d",
    min_count: 1,
    max_count: 24,
  },
});
console.log(response);

PUT _slm/policy/hourly-snapshots
{
  "name": "<hourly-snapshot-{now/d}>",
  "schedule": "0 0 * * * ?",
  "repository": "my_repository",
  "config": {
    "indices": "*",
    "include_global_state": true
  },
  "retention": {
    "expire_after": "1d",
    "min_count": 1,
    "max_count": 24
  }
}

Следующая политика делает еженочные снимки в том же хранилище снимков. Политика хранит свои снимки в течение одного месяца.

resp = client.slm.put_lifecycle(
    policy_id="daily-snapshots",
    name="<daily-snapshot-{now/d}>",
    schedule="0 45 23 * * ?",
    repository="my_repository",
    config={
        "indices": "*",
        "include_global_state": True
    },
    retention={
        "expire_after": "30d",
        "min_count": 1,
        "max_count": 31
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "daily-snapshots",
  name: "<daily-snapshot-{now/d}>",
  schedule: "0 45 23 * * ?",
  repository: "my_repository",
  config: {
    indices: "*",
    include_global_state: true,
  },
  retention: {
    expire_after: "30d",
    min_count: 1,
    max_count: 31,
  },
});
console.log(response);

PUT _slm/policy/daily-snapshots
{
  "name": "<daily-snapshot-{now/d}>",
  "schedule": "0 45 23 * * ?",          
  "repository": "my_repository",
  "config": {
    "indices": "*",
    "include_global_state": true
  },
  "retention": {
    "expire_after": "30d",
    "min_count": 1,
    "max_count": 31
  }
}

Следующая политика создаёт ежемесячные снимки в том же хранилище. Политика хранит свои снимки в течение одного года.

resp = client.slm.put_lifecycle(
    policy_id="monthly-snapshots",
    name="<monthly-snapshot-{now/d}>",
    schedule="0 56 23 1 * ?",
    repository="my_repository",
    config={
        "indices": "*",
        "include_global_state": True
    },
    retention={
        "expire_after": "366d",
        "min_count": 1,
        "max_count": 12
    },
)
print(resp)

const response = await client.slm.putLifecycle({
  policy_id: "monthly-snapshots",
  name: "<monthly-snapshot-{now/d}>",
  schedule: "0 56 23 1 * ?",
  repository: "my_repository",
  config: {
    indices: "*",
    include_global_state: true,
  },
  retention: {
    expire_after: "366d",
    min_count: 1,
    max_count: 12,
  },
});
console.log(response);

PUT _slm/policy/monthly-snapshots
{
  "name": "<monthly-snapshot-{now/d}>",
  "schedule": "0 56 23 1 * ?",            
  "repository": "my_repository",
  "config": {
    "indices": "*",
    "include_global_state": true
  },
  "retention": {
    "expire_after": "366d",
    "min_count": 1,
    "max_count": 12
  }
}