OpenSearch Sizing Calculator
Storage for Amazon OpenSearch Service or self-managed OpenSearch: replicas, UltraWarm and cold tiers, shard planning, and the assumptions behind each number.
Conservative for Amazon OpenSearch Service. The service reserves 20% of each instance’s storage, but capped at 20 GiB per instance. Because ObservKit does not size nodes, applying 20% to the whole cluster can overestimate, most when instances have large volumes.
Show math
Amazon OpenSearch Service: source × (1 + replicas) × (1 + indexing overhead) ÷ (1 − Linux reserved) ÷ (1 − service overhead), which AWS simplifies to source × (1 + replicas) × 1.45. The 20% service overhead is capped at 20 GiB per instance, so this is a worst-case estimate.
Assumptions & sources
| Assumption | Source | Limitation | Confidence |
|---|---|---|---|
| Hot storage formula with 5% Linux reserved and 20% service overhead applies to Amazon OpenSearch Service only. | AWS: Calculating storage requirements. | The 20% overhead is capped at 20 GiB per instance, so the formula overestimates when per-node storage is large. | High |
| Index / source factor 1.1 (indexing overhead 10%): an editable ObservKit planning assumption. | AWS: Calculating storage requirements: source plus index is often 110% of the source (an Amazon OpenSearch Service guideline). | Not an OpenSearch recommendation for self-managed clusters, where the ratio depends on mappings, codecs and data; measure pri.store.size with _cat/indices?v. The same default is applied to both deployments so they can be compared. | Medium |
| Replica count defaults to 1. | AWS: one replica by default, at least one recommended. OpenSearch: a replica per primary by default. | Zero replicas risks data loss; more replicas help read-heavy workloads. | High |
| UltraWarm and cold storage count primary shards only. | AWS: UltraWarm and cold storage: backed by S3, no replicas and none of the hot-storage overhead. | UltraWarm needs dedicated master nodes, indexes are read-only, and warm node counts are not modeled. | High |
| Self-managed planning utilization target 85%. | OpenSearch cluster settings: low watermark 85%, high 90%, flood stage 95%. | Watermarks apply per node; an aggregate target is a planning estimate, and the low watermark does not stop primaries of new indexes. | Medium |
| Shard size rule of thumb 10–50 GB (default target 30 GB). | OpenSearch: limit shard size to 10–50 GB. AWS: 10–30 GiB for latency-sensitive search, 30–50 GiB for write-heavy workloads such as log analytics. | A starting point; performance testing decides the real size. | Medium |
| Shard limit per data node: self-managed 1,000 by default (configurable); Amazon OpenSearch Service 1,000 up to 2.15 and, from 2.17, 1,000 per 16 GiB of JVM heap up to 4,000. | OpenSearch cluster settings: cluster.max_shards_per_node. AWS: Choosing the number of shards. | For Amazon OpenSearch Service the limit needs engine version and heap per node; without them no node estimate is shown. AWS also suggests at most 25 shards per GiB of heap, which is not modeled. | High |
| Growth buffer 25%, applied to source data before overhead. | ObservKit planning assumption. | AWS's formula takes source data at any given time; set the buffer from your forecast. | n/a |
Not modeled: node counts and instance types, EBS volume types and IOPS, UltraWarm node counts, OpenSearch Optimized instances, self-managed warm or searchable-snapshot tiers, snapshots and backups, and the AWS guideline of at most 25 shards per GiB of JVM heap.
Planning estimates only. Actual OpenSearch capacity depends on mappings, query load, shard strategy, node hardware and operational requirements. OpenSearch and Amazon OpenSearch Service are different products; the deployment switch shows which model applies.
Worked example: Amazon OpenSearch Service, hot only
Reference scenario the calculator's defaults: 250 GB/day of source data, 90 days kept hot, 1 replica, index / source factor 1.1 and 25% growth. Open this scenario.
| Step | Formula | Result |
|---|---|---|
| Source over retention | 250 GB/day × 90 days | 22.5 TB |
| With growth buffer | × 1.25 | 28.1 TB |
| Stored on nodes | × (1 + 1 replica) × index factor 1.1 | 61.9 TB |
| Reserved space and service overhead | ÷ 0.95 ÷ 0.80 (AWS worst case) | 19.5 TB |
| Hot storage to provision | 2.9× the growth-adjusted source | 81.4 TB |
AWS simplifies the same formula to source × (1 + replicas) × 1.45. The exact terms give a multiplier of 2.9 for one replica.
Reference scenarios
Reference scenario comparison points, not recommended layouts. Index / source factor 1.1, 1 replica, 25% growth, 85% planning target for the self-managed row.
| Scenario | Deployment | Tier days | Hot to provision | UltraWarm | Cold | Total | Link |
|---|---|---|---|---|---|---|---|
| Hot only, 250 GB/day · 90 days | Amazon service | 90 hot | 81.4 TB | 0 MB | 0 MB | 81.4 TB | Open this scenario |
| Self-managed, same data | Self-managed | 90 hot | 72.8 TB | 0 MB | 0 MB | 72.8 TB | Open this scenario |
| One year, all hot | Amazon service | 365 hot | 330.2 TB | 0 MB | 0 MB | 330.2 TB | Open this scenario |
| One year, tiered | Amazon service | 14 hot · 76 UltraWarm · 275 cold | 12.7 TB | 26.1 TB | 94.5 TB | 133.3 TB | Open this scenario |
Keeping a year hot needs 330.2 TB; moving 351 days to S3-backed tiers needs 133.3 TB, 2.48× less, because warm and cold data carry no replicas and none of the hot-storage overhead. The same 90 days on a self-managed cluster need 72.8 TB: the AWS service overhead does not apply there, but a planning utilization target does.
Shard planning example
OpenSearch documents 10–50 GB per shard as the rule of thumb (AWS: 10–30 GiB for latency-sensitive search, 30–50 GiB for write-heavy log analytics). The per-node shard limit depends on deployment and version. The planner divides the indexed data of each rollover by a target shard size and rounds up.
| Step | Formula | Result |
|---|---|---|
| Indexed data per rollover | 250 GB/day × 1.1 × 1 day | 275 GB |
| Primary shards per rollover | ceil(275 ÷ 30) | 10 |
| Estimated shard size | 275 ÷ 10 | 27.5 GB |
| Primary shards retained | 10 × 90 rollovers | 900 |
| Total shards on data nodes | retained × (1 + 1 replica) | 1,800 |
| Data nodes needed by the shard limit alone, self-managed | ceil(total ÷ cluster.max_shards_per_node), default 1,000 | 2 |
| Same on Amazon OpenSearch Service | Depends on engine version: 1,000 per node up to 2.15; 1,000 per 16 GiB of JVM heap (max 4,000) from 2.17 | Not estimated until you set the engine version in Expert mode |
Illustrative example 2 GB/day with daily rollover indexes 2.2 GB per rollover, so each shard is about 2.2 GB, below the 10 GB rule of thumb, and 90 days produce 180 shards on data nodes. Rolling over every 14 days gives shards of about 15.4 GB and 28 shards. Open the 14-day rollover.
Common mistakes
- Applying the Amazon formula to a self-managed cluster, or the reverse. The 5% Linux and 20% service overhead terms are AWS's. On the 250 GB/day scenario the Amazon service model gives 81.4 TB and the self-managed model 72.8 TB. Pick the deployment that matches yours.
- Giving UltraWarm and cold storage replicas. They are backed by S3 and count primary shards only. For the one-year tiered scenario, UltraWarm needs 26.1 TB; counting a replica would show 52.3 TB.
- Keeping a year of rarely searched data hot. All hot, a year needs 330.2 TB; tiered it needs 133.3 TB.
- Planning with zero replicas. Hypothetical example with no replica the 250 GB/day scenario needs 40.7 TB instead of 81.4 TB, but a node loss then loses data. AWS recommends at least one replica.
- Assuming no indexing overhead. Hypothetical example with a factor of 1.0 instead of the documented 1.1 the 250 GB/day scenario shrinks to 74 TB, 10% short of the AWS guidance. Measure your own factor.
- Daily indexes for small volumes. Many small shards add per-shard overhead: 180 shards of about 2.2 GB, against 28 with a 14-day rollover.
- Mixing open source and Amazon service defaults. Open source OpenSearch creates one primary and one replica by default; AWS documents that the Amazon service divides an index into five primary shards by default. Set the shard count explicitly before indexing.
How OpenSearch sizing is calculated
Amazon OpenSearch Service
source(tier) = daily ingest × tier days × (1 + growth)
hot to provision = source(hot) × (1 + replicas) × index factor ÷ 0.95 ÷ 0.80
UltraWarm = source(warm) × index factor primary shards only
cold storage = source(cold) × index factor primary shards only
Self-managed OpenSearch (hot only)
disk to provision = source × (1 + replicas) × index factor ÷ utilization target (85%)
shards per rollover = ceil(daily ingest × index factor × rollover days ÷ target shard size)
- Decimal units: 1,000 GB = 1 TB.
- The 0.95 and 0.80 terms are Linux reserved space and the service's reserved storage, applied as AWS's worst case.
- Not modeled: node and instance counts, EBS volume types, UltraWarm node counts, the 25-shards-per-GiB-of-heap guideline and self-managed warm tiers.
The common model behind every calculator is in the methodology.
Sources
- Calculating storage requirements — Amazon OpenSearch Service documentation. The storage formula, indexing overhead, Linux and service reserved space.
- Choosing the number of shards — Amazon OpenSearch Service documentation. Shard size by workload, the primary-shard formula, shard limits and the Amazon service's default of five primaries.
- UltraWarm storage — Amazon OpenSearch Service documentation. Primary-only storage requirements, prerequisites, read-only indexes.
- Cold storage — Amazon OpenSearch Service documentation. S3-backed storage without replicas or hot-storage overhead.
- Cluster management settings — OpenSearch documentation (latest). Disk watermarks and
cluster.max_shards_per_node. - Introduction to OpenSearch — OpenSearch documentation (latest). Default replicas and the 10–50 GB shard rule of thumb.
- Optimize OpenSearch index shard sizes — OpenSearch blog. Shard sizes by workload and the default of one primary and one replica.
Last reviewed: · Related: OpenSearch sizing guide · Capacity Planning · Methodology