elasticsearch/docs/reference/snapshot-restore/index.asciidoc

[[snapshot-restore]]
= Snapshot and restore

A snapshot is a backup of a running {es} cluster. You can use snapshots to:

* Regularly back up a cluster with no downtime
* Recover data after deletion or a hardware failure
* Transfer data between clusters
* Reduce your storage costs by using <<searchable-snapshots,searchable
  snapshots>> in the cold and frozen data tiers

[discrete]
[[snapshot-workflow]]
== The snapshot workflow

{es} stores snapshots in an off-cluster storage location called a snapshot
repository. Before you can take or restore snapshots, you must
<<snapshots-register-repository,register a snapshot repository>> on the cluster.
{es} supports several repository types with cloud storage options, including:

* AWS S3
* Google Cloud Storage (GCS)
* Microsoft Azure

After you register a snapshot repository, you can use
<<snapshot-lifecycle-management,{slm} ({slm-init})>> to automatically take and
manage snapshots. You can then <<snapshots-restore-snapshot,restore a snapshot>>
to recover or transfer its data.

[discrete]
[[snapshot-contents]]
== Snapshot contents

By default, a snapshot of a cluster contains the cluster state, all data
streams, and all indices, including system indices. The cluster state includes:

include::apis/restore-snapshot-api.asciidoc[tag=cluster-state-contents]

You can also take snapshots of only specific data streams or indices in the
cluster. A snapshot that includes a data stream or index automatically includes
its aliases. When you restore a snapshot, you can choose whether to restore
these aliases.

Snapshots don't contain or back up:

* Transient cluster settings
* Registered snapshot repositories
* Node configuration files

[discrete]
[[feature-state]]
=== Feature states

A feature state contains the indices and data streams used to store
configurations, history, and other data for an Elastic feature, such as {es}
security or {kib}.

A feature state typically includes one or more <<system-indices,system indices
or system data streams>>. It may also include regular indices and data streams
used by the feature. For example, a feature state may include a regular index
that contains the feature's execution history. Storing this history in a regular
index lets you more easily search it.

[discrete]
[[how-snapshots-work]]
== How snapshots work

Snapshots are automatically deduplicated to save storage space and reduce network
transfer costs. To back up an index, a snapshot makes a copy of the index's
<<near-real-time,segments>> and stores them in the snapshot repository. Since
segments are immutable, the snapshot only needs to copy any new segments created
since the repository's last snapshot.

Each snapshot is also logically independent. When you delete a snapshot, {es}
only deletes the segments used exclusively by that snapshot. {es} doesn't delete
segments used by other snapshots in the repository.

[discrete]
[[snapshots-shard-allocation]]
=== Snapshots and shard allocation

A snapshot copies segments from an index's primary shards. When you start a
snapshot, {es} immediately starts copying the segments of any available primary
shards. If a shard is starting or relocating, {es} will wait for these processes
to complete before copying the shard's segments. If one or more primary shards
aren't available, the snapshot attempt fails.

Once a snapshot begins copying a shard's segments, {es} won't move the shard to
another node, even if rebalancing or shard allocation settings would typically
trigger reallocation. {es} will only move the shard after the snapshot finishes
copying the shard's data.

[discrete]
[[snapshot-start-stop-times]]
=== Snapshot start and stop times

A snapshot doesn't represent a cluster at a precise point in time. Instead, each
snapshot includes a start and end time. The snapshot represents a view of each
shard's data at some point between these two times.

[discrete]
[[snapshot-restore-version-compatibility]]
== Snapshot compatibility

To restore a snapshot to a cluster, the versions for the snapshot, cluster, and
any restored indices must be compatible.

[discrete]
[[snapshot-cluster-compatibility]]
=== Snapshot version compatibility

[cols="6"]
|===
| 5+^h| Cluster version
^h| Snapshot version ^| 2.x ^| 5.x ^| 6.x ^| 7.x ^| 8.x
^| *1.x* -> ^|{yes-icon} ^|{no-icon}  ^|{no-icon}  ^|{no-icon}  ^|{no-icon}
^| *2.x* -> ^|{yes-icon} ^|{yes-icon} ^|{no-icon}  ^|{no-icon}  ^|{no-icon}
^| *5.x* -> ^|{no-icon}  ^|{yes-icon} ^|{yes-icon} ^|{no-icon}  ^|{no-icon}
^| *6.x* -> ^|{no-icon}  ^|{no-icon}  ^|{yes-icon} ^|{yes-icon} ^|{no-icon}
^| *7.x* -> ^|{no-icon}  ^|{no-icon}  ^|{no-icon}  ^|{yes-icon} ^|{yes-icon}
|===

You can't restore a snapshot to an earlier version of {es}. For example, you
can't restore a snapshot taken in 7.6.0 to a cluster running 7.5.0.

ifeval::["{release-state}"!="released"]
[[snapshot-prerelease-build-compatibility]]
NOTE: This documentation is for {es} version {version}, which is not yet
released. The compatibility table above applies only to snapshots taken in a
released version of {es}. If you're testing a pre-release build of {es} then you
can still restore snapshots taken in earlier released builds as permitted by
this compatibility table. You can also take snapshots using your pre-release
build, and restore them using the same build. However once a pre-release build
of {es} has written to a snapshot repository you must not use the same
repository with other builds of {es}, even if the builds have the same version.
Different pre-release builds of {es} may use different and incompatible
repository layouts. If the repository layout is incompatible with the {es} build
in use then taking and restoring snapshots may result in errors or may appear to
succeed having silently lost some data. You should discard your repository
before using a different build.
endif::[]

[discrete]
[[snapshot-index-compatibility]]
=== Index compatibility

A cluster is only compatible with indices created in the previous major version
of {es}. Any data stream or index you restore from a snapshot must be compatible
with the current cluster's version. If you try to restore an index created in an
incompatible version, the restore attempt will fail.

A snapshot can contain indices created in a previous major version. For example,
a snapshot of a 6.x cluster can contain an index created in 5.x. If you try to
restore the 5.x index to a 7.x cluster, the restore attempt will fail. Keep this
in mind if you take a snapshot before upgrading a cluster.

As a workaround, you can first restore the data stream or index to another
cluster running the latest version of {es} that's compatible with both the index
and your current cluster. You can then use
<<reindex-from-remote,reindex-from-remote>> to rebuild the data stream or index
on your current cluster. Reindex from remote is only possible if the index's
<<mapping-source-field,`_source`>> is enabled.

Reindexing from remote can take significantly longer than restoring a snapshot.
Before you start, test the reindex from remote process with a subset of the data
to estimate your time requirements.

[discrete]
[[other-backup-methods]]
== Other backup methods

// tag::backup-warning[]
**Taking a snapshot is the only reliable and supported way to back up a
cluster.** You cannot back up an {es} cluster by making copies of the data
directories of its nodes. There are no supported methods to restore any data
from a filesystem-level backup. If you try to restore a cluster from such a
backup, it may fail with reports of corruption or missing files or other data
inconsistencies, or it may appear to have succeeded having silently lost some of
your data.
// end::backup-warning[]

A copy of the data directories of a cluster's nodes does not work as a backup
because it is not a consistent representation of their contents at a single
point in time. You cannot fix this by shutting down nodes while making the
copies, nor by taking atomic filesystem-level snapshots, because {es} has
consistency requirements that span the whole cluster. You must use the built-in
snapshot functionality for cluster backups.

include::register-repository.asciidoc[]
include::take-snapshot.asciidoc[]
include::restore-snapshot.asciidoc[]
include::../searchable-snapshots/index.asciidoc[]