elasticsearch flush에 대한 설명.

flush

The flush API allows to flush one or more indices through an API. The flush process of an index basically frees memory from the index by flushing data to the index storage and clearing the internal transaction log. By default, Elasticsearch uses memory heuristics in order to automatically trigger flush operations as required in order to clear memory.

POST /twitter/_flush

VIEW IN SENSE 

Request Parametersedit

The flush API accepts the following request parameters:

wait_if_ongoing	If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is false and will cause an exception to be thrown on the shard level if another flush operation is already running.
force	Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)

Multi Indexedit

The flush API can be applied to more than one index with a single call, or even on _all the indices.

POST /kimchy,elasticsearch/_flush

POST /_flush

(위에서 셋째줄 transaction log에 대한 설명)

Translog

Changes to Lucene are only persisted to disk during a Lucene commit, which is a relatively heavy operation and so cannot be performed after every index or delete operation. Changes that happen after one commit and before another will be lost in the event of process exit or HW failure.

To prevent this data loss, each shard has a transaction log or write ahead log associated with it. Any index or delete operation is written to the translog after being processed by the internal Lucene index.

In the event of a crash, recent transactions can be replayed from the transaction log when the shard recovers.

An Elasticsearch flush is the process of performing a Lucene commit and starting a new translog. It is done automatically in the background in order to make sure the transaction log doesn’t grow too large, which would make replaying its operations take a considerable amount of time during recovery. It is also exposed through an API, though its rarely needed to be performed manually.

Flush settingsedit

The following dynamically updatable settings control how often the in-memory buffer is flushed to disk:

index.translog.flush_threshold_size

Once the translog hits this size, a flush will happen. Defaults to 512mb.

index.translog.flush_threshold_ops

After how many operations to flush. Defaults to unlimited.

index.translog.flush_threshold_period

How long to wait before triggering a flush regardless of translog size. Defaults to 30m.

index.translog.interval

How often to check if a flush is needed, randomized between the interval value and 2x the interval value. Defaults to 5s.

Translog settingsedit

The data in the transaction log is only persisted to disk when the translog is fsynced and committed. In the event of hardware failure, any data written since the previous translog commit will be lost.

By default, Elasticsearch commits the translog at the end of every index, delete, update, or bulk request. In fact, Elasticsearch will only report success of an index, delete, update, or bulk request to the client after the transaction log has been successfully fsynced and committed on the primary and on every allocated replica.

The following dynamically updatable per-index settings control the behaviour of the transaction log:

index.translog.sync_interval

How often the translog is fsynced to disk and committed, regardless of write operations. Defaults to5s.

index.translog.durability

Whether or not to fsync and commit the translog after every index, delete, update, or bulk request. This setting accepts the following parameters:

request

(default) fsync and commit after every request. In the event of hardware failure, all acknowledged writes will already have been committed to disk.

async

fsync and commit in the background every sync_interval. In the event of hardware failure, all acknowledged writes since the last automatic commit will be discarded.

index.translog.fs.type

Whether to buffer writes to the transaction log in memory or not. This setting accepts the following parameters:

buffered

(default) Translog writes first go to a 64kB buffer in memory, and are only written to the disk when the buffer is full, or when an fsync is triggered by a write request or the sync_interval.

simple

Translog writes are written to the file system immediately, without buffering. However, these writes will only be persisted to disk when an fsync and commit is triggered by a write request or thesync_interval.