› › ›

Перенос индекса

Разрешенные фазы: hot.

Переносит целевой индекс в новый индекс, когда существующий индекс удовлетворяет указанным условиям переноса.

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

Если действие переноса используется для индекса-последователя, выполнение политики ждёт, пока индекс-лидер не перенесёт (или иначе не будет помечен как завершённый) перенос, а затем преобразует индекс-последователь в обычный индекс с помощью действия Отслеживание.

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

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

Имя индекса должно соответствовать шаблону ^.*-\d+$, например (my-index-000001).
index.lifecycle.rollover_alias должен быть настроен как псевдоним для переноса.
Индекс должен быть индексом записи для псевдонима.

Например, если у my-index-000001 есть псевдоним my_data, должны быть настроены следующие параметры.

resp = client.indices.create(
    index="my-index-000001",
    settings={
        "index.lifecycle.name": "my_policy",
        "index.lifecycle.rollover_alias": "my_data"
    },
    aliases={
        "my_data": {
            "is_write_index": True
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my-index-000001',
  body: {
    settings: {
      'index.lifecycle.name' => 'my_policy',
      'index.lifecycle.rollover_alias' => 'my_data'
    },
    aliases: {
      my_data: {
        is_write_index: true
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-index-000001",
  settings: {
    "index.lifecycle.name": "my_policy",
    "index.lifecycle.rollover_alias": "my_data",
  },
  aliases: {
    my_data: {
      is_write_index: true,
    },
  },
});
console.log(response);

PUT my-index-000001
{
  "settings": {
    "index.lifecycle.name": "my_policy",
    "index.lifecycle.rollover_alias": "my_data"
  },
  "aliases": {
    "my_data": {
      "is_write_index": true
    }
  }
}

Параметры

Действие переноса должно указывать по крайней мере одно условие max_*, оно может включать ноль или более условий min_*. Пустое действие переноса недействительно.

Индекс будет перенесён, как только будет выполнено любое условие max_* и все условия min_* будут выполнены. Однако следует учитывать, что пустые индексы по умолчанию не переносятся.

max_age: (Необязательно, единицы измерения времени) Вызывает перенос после достижения максимального времени, прошедшего с момента создания индекса. Время всегда рассчитывается с момента создания индекса, даже если дата происхождения индекса настроена на пользовательскую дату, например, при использовании параметров index.lifecycle.parse_origination_date или index.lifecycle.origination_date.
max_docs: (Необязательно, целое число) Вызывает перенос после достижения указанного максимального количества документов. Добавленные документы с момента последней синхронизации не учитываются при подсчёте документов. Подсчёт документов не включает документы в реплицируемых фрагментах.
max_size: (Необязательно, единицы измерения размера в байтах) Вызывает перенос, когда индекс достигает определённого размера. Это общий размер всех первичных фрагментов в индексе. Реплики не учитываются при определении максимального размера индекса.

Чтобы увидеть текущий размер индекса, используйте API _cat indices. Значение pri.store.size показывает общий размер всех первичных фрагментов.
max_primary_shard_size: (Необязательно, единицы измерения размера в байтах) Вызывает перенос, когда наибольший первичный фрагмент в индексе достигает определённого размера. Это максимальный размер первичных фрагментов в индексе. Как и в случае с max_size, реплики игнорируются.

Чтобы увидеть текущий размер фрагмента, используйте API _cat shards. Значение store показывает размер каждого фрагмента, а prirep указывает, является ли фрагмент первичным (p) или репликацией (r).
max_primary_shard_docs: (Необязательно, целое число) Вызывает перенос, когда наибольший первичный фрагмент в индексе достигает определённого количества документов. Это максимальное количество документов в первичных фрагментах индекса. Как и в случае с max_docs, реплики игнорируются.

Чтобы увидеть текущее количество документов фрагмента, используйте API _cat shards. Значение docs показывает количество документов в каждом фрагменте.
min_age: (Необязательно, единицы измерения времени) Запрещает перенос, пока не будет достигнуто минимальное время с момента создания индекса. См. примечания к max_age.
min_docs: (Необязательно, целое число) Запрещает перенос, пока не будет достигнуто минимальное количество документов. См. примечания к max_docs.
min_size: (Необязательно, единицы измерения размера в байтах) Запрещает перенос, пока индекс не достигнет определённого размера. См. примечания к max_size.
min_primary_shard_size: (Необязательно, единицы измерения размера в байтах) Запрещает перенос, пока наибольший первичный фрагмент в индексе не достигнет определённого размера. См. примечания к max_primary_shard_size.
min_primary_shard_docs: (Необязательно, целое число) Запрещает перенос, пока наибольший первичный фрагмент в индексе не достигнет определённого количества документов. См. примечания к max_primary_shard_docs.

Пустые индексы не будут перенесены, даже если у них есть связанное max_age, которое в противном случае привело бы к переносу. Политика может переопределить это поведение и явно включить перенос пустых индексов, добавив условие "min_docs": 0. Это также можно отключить на уровне кластера, установив indices.lifecycle.rollover.only_if_has_documents на false.

Действие переноса неявно всегда переносит поток данных или псевдоним, если один или несколько фрагментов содержат 200000000 или более документов. Обычно фрагмент достигнет 50 ГБ задолго до того, как он достигнет 200 млн документов, но это не так для пространственно эффективных наборов данных. Производительность поиска, скорее всего, пострадает, если фрагмент содержит более 200 млн документов. Это причина встроенного ограничения.

Пример

Перенос индекса на основе размера самого большого первичного фрагмента

В этом примере индекс переносится, когда его самый большой первичный фрагмент достигает размера не менее 50 гигабайт.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_primary_shard_size": "50gb"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_primary_shard_size: '50gb'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_primary_shard_size: "50gb",
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_primary_shard_size": "50gb"
          }
        }
      }
    }
  }
}

Перенос индекса на основе размера индекса

В этом примере индекс переносится, когда его размер достигает не менее 100 гигабайт.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_size": "100gb"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_size: '100gb'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_size: "100gb",
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_size": "100gb"
          }
        }
      }
    }
  }
}

Перенос индекса на основе количества документов

В этом примере индекс переносится, когда он содержит не менее ста миллионов документов.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_docs": 100000000
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_docs: 100_000_000
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_docs: 100000000,
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_docs": 100000000
          }
        }
      }
    }
  }
}

Перенос индекса на основе количества документов самого большого первичного фрагмента

В этом примере индекс переносится, когда в самом большом первичном фрагменте содержится не менее десяти миллионов документов.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_primary_shard_docs": 10000000
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_primary_shard_docs: 10_000_000
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_primary_shard_docs: 10000000,
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_primary_shard_docs": 10000000
          }
        }
      }
    }
  }
}

Перенос индекса на основе возраста индекса

В этом примере индекс переносится, если он был создан не менее 7 дней назад.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_age": "7d"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_age: '7d'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_age: "7d",
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_age": "7d"
          }
        }
      }
    }
  }
}

Перенос индекса с использованием нескольких условий

При указании нескольких условий переноса индекса, перенос происходит, когда любое из max_* и все из min_* условий выполнены. В этом примере индекс переносится, если его возраст составляет не менее 7 дней или его размер составляет не менее 100 гигабайт, но только в том случае, если индекс содержит не менее 1000 документов.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_age": "7d",
                        "max_size": "100gb",
                        "min_docs": 1000
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_age: '7d',
              max_size: '100gb',
              min_docs: 1000
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_age: "7d",
            max_size: "100gb",
            min_docs: 1000,
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_age": "7d",
            "max_size": "100gb",
            "min_docs": 1000
          }
        }
      }
    }
  }
}

Перенос индекса, сохраняя размер фрагментов

В этом примере индекс переносится, когда размер первичного фрагмента достигает не менее 50 ГБ или когда возраст индекса составляет не менее 30 дней, но только в том случае, если размер первичного фрагмента составляет не менее 1 ГБ. Для индексов с низким объемом данных это предотвращает создание большого количества небольших фрагментов.

resp = client.ilm.put_lifecycle(
    name="my_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_primary_shard_size": "50gb",
                        "max_age": "30d",
                        "min_primary_shard_size": "1gb"
                    }
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'my_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_primary_shard_size: '50gb',
              max_age: '30d',
              min_primary_shard_size: '1gb'
            }
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "my_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_primary_shard_size: "50gb",
            max_age: "30d",
            min_primary_shard_size: "1gb",
          },
        },
      },
    },
  },
});
console.log(response);

PUT _ilm/policy/my_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover" : {
            "max_primary_shard_size": "50gb",
            "max_age": "30d",
            "min_primary_shard_size": "1gb"
          }
        }
      }
    }
  }
}

Блокировка перехода фазы по условию переноса

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

Например, следующая политика удаляет индекс через один день после переноса. Она не удаляет индекс через один день после его создания.

resp = client.ilm.put_lifecycle(
    name="rollover_policy",
    policy={
        "phases": {
            "hot": {
                "actions": {
                    "rollover": {
                        "max_size": "50gb"
                    }
                }
            },
            "delete": {
                "min_age": "1d",
                "actions": {
                    "delete": {}
                }
            }
        }
    },
)
print(resp)

response = client.ilm.put_lifecycle(
  policy: 'rollover_policy',
  body: {
    policy: {
      phases: {
        hot: {
          actions: {
            rollover: {
              max_size: '50gb'
            }
          }
        },
        delete: {
          min_age: '1d',
          actions: {
            delete: {}
          }
        }
      }
    }
  }
)
puts response

const response = await client.ilm.putLifecycle({
  name: "rollover_policy",
  policy: {
    phases: {
      hot: {
        actions: {
          rollover: {
            max_size: "50gb",
          },
        },
      },
      delete: {
        min_age: "1d",
        actions: {
          delete: {},
        },
      },
    },
  },
});
console.log(response);

PUT /_ilm/policy/rollover_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": {
            "max_size": "50gb"
          }
        }
      },
      "delete": {
        "min_age": "1d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/ilm-rollover.html