Limits - Elasticsearch - Alibaba Cloud Documentation Center

Differences from stateful Elasticsearch

The Agent Engine Edition uses a stateless architecture. When you migrate, focus on the following features, index settings, and O&M methods. Use other APIs as described in Versions and compatibility, and refer to the corresponding API Reference for parameter limits.

Stateful Elasticsearch capability or setting	Difference in the Agent Engine Edition	Recommendation
Index Lifecycle Management (ILM), `_ilm/`, and `index.lifecycle.`	ILM policy management and execution are not supported. The related APIs are not registered, `index.lifecycle.name` is an unrecognized setting, and existing ILM policies cannot be migrated directly.	Use Data Stream Lifecycle to manage the retention period of logs and time series data. For regular indexes, call Rollover and Delete Index from an external scheduling task.
The hot, warm, cold, and frozen data tiers, and migration based on `_tier_preference`	The traditional `data_*` data tiers and tier migration model are not used. `_tier_preference` does not apply; do not configure it. Even if the API accepts the setting, no data tier migration occurs.	Use object storage for persistent data, and plan index nodes and query nodes separately. Manage historical data according to your business retention policy.
Watcher	The Watcher trigger, condition, and notification execution chain are not supported. The related APIs are not registered.	Use CloudMonitor, Simple Log Service (SLS) alerts, an enterprise alerting platform, or an external scheduled task.
The legacy Stack Monitoring local collection path	Collection methods that rely on `xpack.monitoring.collection.` and local `.monitoring-` indexes are not supported. The related cluster settings do not apply; do not configure them.	Use console monitoring and logs. When you need application-side observability, use the cluster health and node stats APIs. See API reference.
Rollup jobs and `_rollup_search`	Legacy Rollup jobs and their query API are not supported. The related APIs are not registered.	Choose Downsample, Transform, or an external aggregation task based on your data type.
Searchable Snapshots, snapshot mounting, and frozen phase transitions	The mount semantics of Searchable Snapshots are not supported, the mount API is not registered, and you cannot reuse the frozen tier process.	Online data uses native object storage indexes directly. Backup and restore for all Collections is completed with the assistance of technical support. See Back up and restore Collections.
`index.auto_expand_replicas`	Query replicas are not automatically expanded based on the number of nodes. If it is enabled, setting the number of replicas to `0` is adjusted by the system to `1`. It cannot be used according to traditional cluster rules. Do not configure it.	Explicitly configure `index.number_of_replicas`, and adjust query nodes based on query capacity and high-availability requirements.
`index.translog.durability=async`	Setting translog durability to `async` is not supported, and the modification request is rejected. Write acknowledgment uses request durability.	Optimize write throughput through bulk size, concurrency, refresh frequency, shard planning, and index node capacity.
`index.refresh_interval`	The default in the Agent Engine Edition is `5s`, whereas the default in stateful Elasticsearch is `1s`.	Keep automatic refresh for online workloads, with a recommended interval of no less than `5s`. Disable refresh only for a one-time offline import.
`wait_for_active_shards`	It is not used as a replica-wait condition in the write path. Even if it is set to `all`, it does not mean that all query replicas are already available.	Check the write response, and verify visibility with an actual query after the background refresh. When synchronous waiting is required, use `refresh=wait_for` as described in Refresh and query visibility. Query service readiness still needs to be confirmed with a real query probe.

For index or cluster settings marked as not applicable in the preceding table, a modification request may return HTTP 200 and the new value may be visible when you read it back. Do not use this to conclude that the feature is enabled.

In addition, replicas in the stateless architecture are used mainly for querying and caching, and are not equivalent to the persistent replicas in stateful Elasticsearch that can be promoted to primary shards. The number of query replicas and the query nodes together determine query capacity and availability. Persistent data is stored in object storage, and you cannot use an increased number of replicas as a substitute for a backup strategy.

Indexes and vector fields

The following constraints apply to vector fields in regular indexes and Collections.

Constraint	Limit
`dims` of a `float` vector field	`bbq_disk` supports 1 to 4096; `bbq_hnsw` and `bbq_flat` support 64 to 4096. The dimension cannot be changed after it is set. The dimensions of both the documents you write and the query vector must match the field's `dims`.
`visit_percentage` of DiskBBQ	0 to 100. The query value overrides the mapping default, including when it is explicitly set to `0`. When the effective value is greater than `0`, `num_candidates` no longer determines the visit ratio.

For field configuration and query parameters, see Vector fields and KNN.

Collections and Slices

Naming and batch limits

Constraint	Limit
Collection name	Follows the Elasticsearch index and alias naming rules. It must be lowercase, no longer than 128 bytes, and cannot use the system-reserved `.sc-` prefix.
Slice name	1 to 128 characters. The first and last characters must be a letter or digit. For the characters in between, we recommend letters, digits, `.`, `_`, and `-`. `_all` is a reserved value. Whether other characters are allowed depends on the API validation result.
Number of Slices in a single Search	Up to 1024. When passed as URL parameters, it is also subject to the HTTP request line length limit, which defaults to `4096` bytes and is determined by `http.max_initial_line_length`. When names are long, shorten them or split the request. For Multi Search, you can pass `_slice` in the request header line of each sub-request to avoid putting the name list in the URL.
Number of missing Slices auto-created in a single Bulk	Up to 512. Existing Slices are not counted.
Number of Slices registered in a single batch	Up to 20480, with no duplicate names within the request.
`page_size` of the List Slices API	1 to 10000.
Number of rows returned by the Slice CAT	Up to 10000 rows. Pagination is not provided.
Expansion scope of the Collection and Backing CAT	Returns HTTP 400 when there are more than 10000 Backings.
`master_timeout` for deleting a Slice	Must be a finite value and no more than 5 minutes.
`count` for pre-creating Backings	1 to 99999, and can be provided only once, in either the query parameter or the request body.

The actual processing limit of the Slice CAT is further constrained by index.max_result_window of the system-managed metadata index, and by index.max_terms_count and search.max_buckets of the target Backing. Lowering these settings further narrows the query scope or causes the request to fail.

API support scope

DLS/FLS cannot be used with a Collection. A role with DLS/FLS restrictions can be created successfully, but a user with that role receives HTTP 403 when accessing a Collection.
Collections do not support cross-cluster search (CCS). A target in the remote:collection form is not recognized as a Collection, and usually appears as a non-existent remote index rather than an explicit "CCS not supported" message.
Point in Time (PIT) cannot target a Collection directly; the request returns HTTP 400. This limit is independent of whether Branch is used.
_graph/explore and _termvectors cannot target a Collection, and _mtermvectors cannot include a Collection item.
Collections do not support the deprecated _knn_search. Use knn in a _search request instead.
Explain can specify only a single Slice. It does not support a comma-separated list or _slice=_all, and does not apply to the cluster setting that queries all Slices when _slice is omitted.
You cannot use native Delete Index, Close/Open, Resize, or Index Blocks directly on a Collection or a Backing Index. The Collection lifecycle must be managed with the Collection API.
Collection Reindex does not support script. An explicit ingest pipeline is not supported when a Collection is the target. source._slice is not supported on a remote source.
The Slice CAT does not support counting storage size by Slice or sorting by Slice storage size. When you need to count storage size, use the Backing statistics in CAT observability.

sliced postings

index.sliced_postings.enabled can be configured only when you create a Collection, and cannot be changed afterward. When it is enabled, the completion field and text fields with fielddata: true are not supported; index.codec supports only default, legacy_default, best_compression, or legacy_best_compression. For default values and configuration examples, see Optimize text search within a specified Slice.

Collection Alias

A single alias cannot mix regular indexes and Collections. Collection members must use the same slice_strategy, and members in vector cluster recall mode must also use the same vector dimension.
Alias filter, routing, index_routing, search_routing, is_hidden, and remove_index are not supported.
In single-document GET and MGet, each item must resolve uniquely to one Collection; a multi-member alias cannot be used. is_write_index does not select a member for single-target reads.

For the operations to create an alias, specify the write target, and switch read/write traffic, see Collection Alias.

Copy Slice

Constraint	Limit
`workers` / `batch_size`	1 to 64 and 1 to 10000, respectively. `workers` cannot be adjusted dynamically while the task is running.
Copy scope	The source and target must be in the same Collection. Cross-Collection copy is not supported.
Source data representation	The `_source` that allows documents to be reconstructed must be retained. A source mapping that contains inference fields such as `semantic_text` is not supported. For the full requirements, see Copy data semantics.
Traffic cutover	Copy does not provide atomic traffic switching, and does not continuously sync subsequent writes on the source. When `routing_field` is configured, Copy does not rewrite the routing field inside documents. Before cutover, adjust the target write logic and verify the data as described in Copy data semantics.

Branch Slice (Beta)

The source and target must belong to the same Collection and share the mapping and index settings; the target must use a new name. Both reside in the same shard of the same Backing. index.routing_partition_size of the Backing where the source resides must be 1 (the default); Branch creation is not supported when it is greater than 1.

Branch resource limits

The following are hard limits for Branch. When a limit is reached, only new Branch creation is rejected; reads and writes of existing Branches and their data continue to be served.

Constraint	Limit
Number of inheritance levels in a single branch relationship	Up to 8. A new request that exceeds this returns HTTP 409; retry after the source is converted to a regular Slice.
Number of Branches being prepared concurrently per shard	Up to 2. Exceeding this returns HTTP 429.
Number of active or in-creation Branches per shard	Up to 1024. Exceeding this returns HTTP 429.
Branch metadata size per shard	When a new request is expected to make it exceed 128 MiB, the request returns HTTP 409 and the target is not published.
`timeout` for creating a Branch	Must be a finite value. A timeout does not mean that the creation has been rolled back.

The conditions that trigger automatic conversion to a regular Slice in the background (creation duration, number of shadowed inherited documents, and branch metadata size) are not limits. Reaching a condition does not mean the conversion completes immediately, and not reaching a condition does not affect normal reads and writes of the target.

Currently, there is no separate Branch status query or completion callback, and there is no capability to set an object storage usage quota for an individual Branch.

Before a Branch is converted to a regular Slice, it is called an Active Branch, and single-Slice reads and writes work normally. For query scope, warmup, and statistics behavior, check Behavior differences during the Active period.

Vector cluster recall

The following parameters are used for vector cluster recall mode. They take effect separately from the count limit of the explicit _slice name list, and cannot substitute for each other.

Parameter	Limit
`config.vector_dims`	1 to 4096. Both the registered center vectors and the query vector used for automatic Slice selection must meet this dimension.
`config.default_query_slice_count`	1 to 10000, and cannot be greater than `config.max_query_slice_count`. The default is `128`.
`config.max_query_slice_count`	1 to 10000. The default is `512`.
The `query_slice_count` query parameter	When it is omitted or `0`, the default number of candidates is used. Otherwise, it is 1 to `config.max_query_slice_count`.

Automatic selection of candidate Slices requires an inline query vector in the request. Scripted update is not supported after routing_field is configured. For the specific query vector path, explicit Slice selection, and error handling, see Automatically select candidate Slices.