Elasticsearch frozen tier: the real cost of searchable snapshots

Elasticsearch frozen tier: what searchable snapshots really cost, the latency to expect and the ILM policy to write, per the Elastic documentation.
Elasticsearch frozen tier : coût réel des snapshots consultables

The Elasticsearch frozen tier keeps old data searchable at a lower cost by leaving it in a snapshot repository instead of on local disks. SRE teams that retain logs for months find the promise attractive. The useful question is a precise one: what do you actually pay, and how much latency must you accept?

This article draws on the official Elastic documentation (pages read on 30 October 2026) and on a benchmark Elastic published in January 2025. Vendor figures are attributed as such: span.observer measured nothing. The feature applies to Elasticsearch, not to Dynatrace Managed or Dynatrace SaaS, which have their own storage.

In brief

  • The frozen tier holds only partially mounted indices (partial- prefix), backed by a snapshot.
  • Searchable snapshots need an Enterprise licence, according to the documentation.
  • The saving is on disks and nodes. You pay for it in latency on queries that miss the cache.
  • The snapshot repository becomes the only copy of the data, so it must be protected.

Elasticsearch frozen tier: what it is

According to the data tiers page, frozen nodes hold time series data that is rarely read and never updated. It usually arrives from the cold tier and stays until deletion. Elastic recommends dedicated nodes with the data_frozen role.

The searchable snapshots page describes two modes:

  • Fully mounted (restored-): shards are cached in the cluster. The documentation says performance is normally comparable to a regular index. ILM uses it in the hot or cold phase.
  • Partially mounted (partial-): a fixed-size local cache keeps only recently searched data. On a cache miss the node reads the repository, so the search is slower. ILM uses it in the frozen phase.

What you really pay for

Cost splits into four items. The first two go down; the other two are easy to forget.

What goes down

  • Disks and nodes. Per Elastic, a fully mounted cold tier with no replicas needs half the nodes and disk of a tier with regular indices. Frozen needs even fewer. The data tiers page claims up to 20 times the capacity of the warm tier, according to Elastic.
  • Node-to-node copies. Mounts and shard moves copy from the repository, which the documentation generally calls much cheaper than copying between nodes.

What stays or appears

  • Object storage. The repository (S3, Google Cloud Storage, Azure Blob Storage, HDFS, a shared file system) holds the data. Its price depends on your provider: check its official price list, as no tariff is quoted here.
  • Network egress. The documentation warns that cloud egress fees can be significant. Mount snapshots in a cluster in the same region as the repository; for cross-region search it suggests cross-cluster search or replication.
  • The licence. The feature needs an Enterprise licence, per the same page.

Elastic’s benchmark puts a number on the gap using an example. It compares an all-hot 90 TB deployment on Elastic Cloud with one day of hot and the rest in frozen. The price ratio, about 16 times, comes from dividing the article’s two amounts (the currency is not stated). The prices date from when Elastic wrote the post and may have changed: redo the sum with the current price list. Against the dense all-hot option, the gap drops to about 8.6 times, from the same amounts.

The latency to expect

The benchmark, published by Elastic in January 2025, covers 105 TB of logs spanning more than 90 days. The cluster has six nodes on Google Cloud (three hot, three frozen), driven with Rally. Queries imitate Kibana Discover searches on logs; other workloads may behave differently. The post does not state the Elasticsearch version.

Table of p99.9 latencies published by Elastic: hot, frozen uncached and frozen cached for 1, 14, 30 and 90 days

Three readings stand out:

  1. A query that hits the repository costs several seconds, sometimes far more. For 90 days, Elastic reports a maximum of 5 minutes uncached, against about 1.6 minutes cached.
  2. Once the cache is warm, frozen gets close to hot on some windows, such as 14 days.
  3. The cache is cleared when a node restarts, according to the documentation. After maintenance, the first searches will be slow.

For an SRE the consequence is clear: frozen suits after-the-fact incident investigation or audit, not a dashboard refreshed every ten seconds. If a response-time SLO covers these searches, measure it on your own queries.

Set up an ILM policy with a frozen phase

Here is the minimal walkthrough. Prerequisites: an Enterprise licence, data_frozen nodes and a registered snapshot repository (here backing_repo, the name used in the documentation).

  1. Register the repository, either object storage or a shared file system.
  2. Create the ILM policy. The searchable_snapshot action is allowed in the hot, cold and frozen phases. In frozen it mounts a partial- index. The 30-day min_age and the deletion at 365 days below are example values to adapt.
ILM policy in JSON with hot, frozen (searchable_snapshot action to backing_repo) and delete phases
PUT _ilm/policy/logs-frozen
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": { "max_primary_shard_size": "50gb" }
        }
      },
      "frozen": {
        "min_age": "30d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "backing_repo"
          }
        }
      },
      "delete": {
        "min_age": "365d",
        "actions": { "delete": {} }
      }
    }
  }
}
  1. Size the cache. On a dedicated frozen node, xpack.searchable.snapshot.shared_cache.size defaults to 90% of the disk, otherwise 0b. Per the docs, a 4,000 GB disk gives a 3,900 GB cache and a 400 GB disk a 360 GB cache. The max_headroom setting defaults to 100 GB when the size is not set.
elasticsearch.yml file: data_frozen role and the xpack.searchable.snapshot.shared_cache.size setting at 4TB

Points of attention from the docs

  • By default force_merge_index is true: the index is merged to one segment before the snapshot, which cuts repository reads.
  • The action does not run on a data stream’s write index: plan a rollover.
  • The delete action also removes the snapshot by default; delete_searchable_snapshot: false keeps it.

How to check that it works

After an index moves, list indices: the name should start with partial- and the index should sit on a frozen node. Then run the same query twice and compare durations: the first fills the cache, the second should be faster. Also watch cluster health: without replicas, losing a node can return partial results during reallocation.

Best practices

  • Never delete the snapshot or the repository while indices are mounted from it: it is the only copy.
  • Keep the repository and the cluster in the same region.
  • Disable allocation before a planned restart to avoid a full re-download.
  • Reserve frozen for data you rarely search.

Where OpenTelemetry and Dynatrace fit

The frozen tier solves a retention problem, not a collection problem. If your logs arrive through a collector, see our guide to the OpenTelemetry Collector on Kubernetes and the difference between OpenTelemetry and Prometheus. To place the tool choice, read the Dynatrace and Datadog comparison. No integration between the frozen tier and Dynatrace is documented here.

Frequently asked questions

Is the frozen tier available without an Enterprise licence?

According to the Elastic documentation consulted, searchable snapshots require an Enterprise licence. Check your subscription before designing around it.

What is the difference between cold and frozen?

Cold can use fully mounted indices, with a local copy and no replicas. Frozen uses only partially mounted indices with a limited local cache: less disk, more latency.

Is the “16 times cheaper” figure guaranteed?

No. It is an example priced by Elastic, on Elastic Cloud prices of the time and a specific workload. Redo the sum with your storage provider and your volume.

Conclusion

The frozen tier sharply reduces the hardware needed to keep old logs, at the price of variable latency and a snapshot repository that becomes critical. Test it on your real queries before sending it data that an SLO depends on.

Independent blog, not affiliated with Dynatrace LLC or Elastic N.V. Vendor figures come from Elastic’s documentation and benchmark, not from span.observer measurements.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
EDOT Kubernetes : déployer avec l'OpenTelemetry Operator

EDOT Kubernetes: deploy with the OpenTelemetry Operator

Next Post
Métriques de trace Datadog : RED sans échantillonnage

Datadog trace metrics: RED without depending on sampling

Related Posts