« 只读降采样 »

› › ›

滚动更新

编辑

滚动更新

编辑

允许的阶段：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: （可选，字节大小单位）当索引达到一定大小时触发滚动更新。这是索引中所有主分片的总大小。副本不计入最大索引大小。

要查看当前索引大小，请使用 _cat indices API。 pri.store.size 值显示所有主分片的组合大小。
max_primary_shard_size: （可选，字节大小单位）当索引中最大的主分片达到一定大小时触发滚动更新。这是索引中主分片的最大大小。与 max_size 一样，副本将被忽略。

要查看当前分片大小，请使用 _cat shards API。 store 值显示每个分片的大小，prirep 表示分片是主分片 (p) 还是副本分片 (r)。
max_primary_shard_docs: （可选，整数）当索引中最大的主分片达到一定文档数时触发滚动更新。这是索引中主分片的最大文档数。与 max_docs 一样，副本将被忽略。

要查看当前分片文档，请使用 _cat shards API。 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 个或更多文档，则滚动更新操作会隐式地始终滚动更新数据流或别名。通常，一个分片会在达到 2 亿个文档之前很久达到 50GB，但对于节省空间的数据集来说并非如此。如果一个分片包含超过 2 亿个文档，搜索性能很可能会受到影响。这是内置限制的原因。

示例

编辑

基于最大主分片大小滚动更新

编辑

此示例在索引的最大主分片至少为 50 GB 时滚动更新索引。

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 GB 时滚动更新索引。

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"
          }
        }
      }
    }
  }
}

基于文档计数滚动更新

编辑

此示例在索引包含至少 1 亿个文档时滚动更新索引。

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
          }
        }
      }
    }
  }
}

基于最大主分片的文档计数滚动更新

编辑

此示例在索引的最大主分片包含至少 1 千万个文档时滚动更新索引。

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 GB 时滚动更新索引，但前提是索引包含至少 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 GB 或索引至少 30 天时滚动更新索引，但前提是主分片至少为 1 GB。对于低容量索引，这可以防止创建许多小分片。

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": {}
        }
      }
    }
  }
}

« 只读降采样 »