How to use the AutoOps Operator

Quick links:

Overview

Every job is triggered by posting a REST request defining the job and its configuration as the body. For every successful request, a response with the taskId will be returned to the client.

Example response for delete empty indices task:

delete-empty-index-6d377563-4243-4b6f-b26f-cc31799547e6

Index management API

Delete index

Delete index job deletes existing indices that match the index prefix. When the job finds candidate indices that are older then the retention, it deletes them. The job can be triggered for several clusters on a single REST request.

Path: POST operator/delete-index Query params: scheduled (Optional. Default is false), interval (Optional. Default is 10 sec)

Example request body:

{
   "indexPrefix": "acc-*",
   "retention": "14d",
   "timeField": "timestamp",
   "backends": [1, 2]
}
ParameterTypeRequired?Description
indexPrefixstringrequiredPattern for matching index names:
With a trailing `*`, all indices with names matching the prefix will be targeted for the operation.
Without a trailing `*`, the index with the exact name will be targeted for the operation.
retentionstringrequiredThe minimum required age for an index to be targeted for deletion
Index age is determined by the most recent value in the `timeField` field of any document in the index.
Allowed values are any number + `s` - SECONDS, `h` - HOURS, `m` - MINUTES, `d` - DAYS.
timeFieldstringoptionalThe field representing the relevance time of a document in an index, the default is timestamp.
backendsarrayoptionalOn which backend clusters (configured Elasticsearch clusters) the task should operate.
The default is all configured backend clusters.
intervalintoptionalTask interval in seconds, the default is 10
excludeIndicesmapoptionalMap of cluster id to indices list. For example: {“1”: [“acc-1”, “index-2”]}

Delete empty index

The delete empty index job deletes indices (using the alias) that are empty, meaning that the number of documents on these indices is zero.

The job currently supports 2 different strategies:

  1. Delete indices matching the index pattern with creation date older than today, meaning created 24H ago and older.
  2. Delete indices matching the index pattern that are not the current write index for the alias defined for them.

Path: POST operator/delete-empty-index Query params: scheduled (Optional. Default is false), interval (Optional. Default is 10)

Example for by date delete request body:

{
 "indexPatterns": ["*some_string*"],
 "indexPatternStrategy" : "BY_DATE",
 "datePatternGroup": 1,
 "backends": [1],
 "deletionStrategy": "BY_CREATION_DATE",
 "datePattern": ".*(\\d{4}.\\d{2}.\\d{2})",
 "dateFormat": "yyyy.MM.dd"
}

Example for by attribute delete request body:

{
 "indexPatterns": ["*benign*", "*000001*"],
 "backends": [
   1
 ],
 "deletionStrategy": "BY_WRITE_ATTRIBUTE"
}
ParameterTypeRequired?Description
indexPatternsarrayrequiredList of strings that should appear in the index name or used as separated patterns (if usePatternsAsSeparate is true):
- If start and ends with * we check that the index name contains benign.
- If ends with * we check that index start with benign
- No * check for perfect match
List of index name matching patterns:
- `*example*`: Matches any index name containing `example`.
- `example*`: Matches any index name starting with `example`.
- `example`: Matches an index named exactly `example`.
usePatternsAsSeparatebooleanoptionalSpecifies how the patterns in `indexPatterns` should be applied.
- `true`: an index name matching any entry in the list will be a target for deletion.
- `false`: an index name matching every entry in the list will be a target for deletion.
indexPatternStrategystringoptionalCan be one of:
- BY_DATE - Any index with a name that matches the `datePattern` parameter is a candidate for deletion
datePatternGroupstringoptionalUsed by the internal date pattern parsing to extract the date - default is 1
backendsarrayoptionalOn which backends (configured Elasticsearch clusters) the task should operate.
The default is all.
intervalintoptionalTask interval in seconds, the default is 10
deletionStrategystringrequiredCan be one of:
- BY_CREATION_DATE - The index will be deleted if the index creation date is older than today
- BY_WRITE_ATTRIBUTE - The index will be deleted if there is no alias with is_write_index set as true.
retentionstringoptionalUsed only when deletionStrategy is BY_CREATION_DATE.
When retention is set, the operation will only be applied to indices older than the configured retention. Index age is based on index creation date.
Values can be in days, hours, minutes, or seconds.
Default:1d (not deleting today index)
Examples: 1d, 5h, 300s.
datePatternstringoptionalThe date pattern to match against the index name when `indexPatternStrategy` is `BY_DATE`
dateFormatstringoptionalA list of indices we should not delete
deleteTodayIndexbooleanoptionalFOR TESTING ONLY
- `false` (default): indices with creation date of today are excluded from deletion
- `true`: indices with creation date of today are not excluded from deletion

Rollover index

The rollover job performs rollovers for existing indices that match certain conditions. The conditions are size, max documents and index age. This job can be triggered to rollover 1 index (by alias) or as a scan job for all the indices on the cluster.

Rollover single index

Path: POST operator/rollover Query params: scheduled (Optional. Default is false) interval (Optional. Default is 10)

Example request body:

{
   "indexAlias": ["alias-acc-39"],
   "sizeThreshold": 10240,
   "maxDocsThreshold":10000,
   "indexRetentionInHours":24,
   "indexCreationStrategies": "TAKE_FROM_CONFIG",
   "shardsConfig": {
       "primaryShards": 2,
       "replicaShards": 1,
       "refreshInterval":1
   },
   "shardCreateExpressions": {
       "primary": "data_node / 2",
       "replica": "1",
       "refreshInterval": "3"
   },
   "desireDigitsCount": 4,
   "postRolloverActions": {
       "force-merge": {
           "maxSegments": 4
       },
       "time-range-filter": {}
   },
   "timeField": "timestamp",
   "clusterDestinationId": 1,
   "shouldCopyMapping": "true"
}

 

ParameterTypeRequired?Description
indexAliasarrayrequiredAn alias of the desired index to roll. Must match only one writing index
sizeThresholdintoptionalSize in bytes onced reached index should be rollover
indexRetentionInHoursintoptionalTime in hours past from index creation time
maxDocsThresholdintoptionalNumber of documents in index
indexCreationStrategiesenumoptionalValid values

TAKE_FROM_CONFIG - if this parameter configure shardsConfig object is mandatory
BY_EXPRESSION - if this parameter configure shardCreateExpressions object is mandatory
COPY_FROM_EXISTING (default)
shardsConfig primaryShardsintoptionalDefault is supplied by Elasticsearch
shardsConfig replicaShardsintoptionalDefault is supplied by Elasticsearch
shardsConfigref reshIntervalintoptionalValue is in Seconds, Default is supplied by Elasticsearch
shardCreateExpressions primaryintoptionalAllowed param is ‘data_node’, Default is supplied by Elasticsearch
shardCreateExpressions replicaintoptionalAllowed param is ‘data_node’, Default is supplied by Elasticsearch
shardCreateExpressions refreshIntervalintoptionalValue is in Seconds, Default is supplied by Elasticsearch
desireDigitsCountintoptionalHow many digits to add after the name
postRolloverActionsenumoptionalAction to apply after completion of rollover.
Valid values:

  • None (default)

  • force-merge - once supplied a maxSegments param is required

  • time-range-filter - if supplied a time range filter with first and last document will be applied on the old index

timeFieldstringoptionalThe field representing the relevance time of a document in an index, the default is timestamp
clusterDestinationIdintoptionalOn which backend should the task operate on, the default is all
shouldCopyMappingbooloptionalIf the cluster version is before 5.0.0 this will occur on the creation of the index. otherwise it will occur as a post action, the default is false
intervalInSecondsintoptionalTask interval in seconds, the default is 10

Rollover index scan

The job will scan the cluster/s and create a list of all indices to rollover, then generate and execute jobs for every index.

Path: POST operator/rollover/scan

QueryParams: scheduled (Optional. Default is false), interval (Optional. Default is 10)

Example request body:

{
   "ignoreAliasPatterns": {
       "1": [
           "sample-index"
       ],
       "100": [
           ".kibana",
           ".kibana_task_manager",
           ".slm-history-1",
           ".opster-operator"
       ],
       "200": [
           ".kibana",
           ".kibana_task_manager",
           ".slm-history-1",
           ".opster-operator"
       ]
   },
   "rolloverRequest": {
       "shouldCopyMapping": false,
       "sizeThreshold": 10474825485,
       "indexCreationStrategies": "BY_EXPRESSION",
       "shardCreateExpressions": {
           "primary": "(data_node / 2)",
           "replica": "1"
       },
       "postRolloverActions": {
           "time-range-filter": {}
       },
       "timeField": "timestamp"
   },
   "rolloverIndexScheduled": false,
   "rolloverIndexIntervalInSeconds": 10
}
ParameterTypeRequired?Description
ignoreAliasPatternsmapoptionalA map of backend ID to aliases to ignore (ignores exact match only), the default is none
rolloverRequestmaprequiredSame as a rollover request. This will apply on each new task that will be created
rolloverIndexScheduledbooloptionalShould the rollover task that will be created should be a scheduled task, the default is false
rolloverIndexIntervalInSecondsintoptionalRollover task that will be created interval in seconds, the default is 10

Reindex

Reindex is a process that reads data from a certain index and writes it to a new index. There are various reasons why a reindex would be required/recommended, but a few possible reasons would be: changes in templates, a move to a new index with more primary shards, and more.

The job uses multiple sub processes to parallelize the work as much as possible in order to speed up the process.

Path: POST operator/reindex Example request body:

{
   "indexNamesList": [
       "acc-44-00001",
       "acc-42-00001"
   ],
   "targetIndexName": "acct-1",
   "numberOfConcurrentProcessedIndices": 2,
   "threadsPerIndex": 10,
   "continueOnFailure": true,
   "retriesOnFailedTasks": 10,
   "timeFrameInMinutes": 10,
   "dateField": "timestamp",
   "clusterDestinationId": 1,
   "useNewIndexOnly": false,
   "indexCreationStrategy": “TAKE_FROM_CONFIG”,
   "shardsConfig": {
       "primaryShards": 2,
       "replicaShards": 1,
       "refreshInterval":1
   },
   "shardCreateExpressions": {
       "primary": "data_node / 2",
       "replica": "1",
       "refreshInterval": "3"
   }
}
ParameterTypeRequired?DescriptionDefault
indexNamesListarrayrequiredNames of source indices which need to be reindexed-
targetIndexNamestringrequiredName for target index-
useNewIndexOnlybooloptionalReindex to a new index only. Do not update if the index exists.false
numberOfConcurrentProcessedIndicesintoptionalDesired number of source indices to be processed concurrently.1
threadsPerIndexintoptionalDesired number of threads for single index processing1
continueOnFailurebooloptionalStop reindexing process on failed task or continue anywaytrue
retriesOnFailedTasksintoptionalNumber of attempts to retry failed tasks5
timeFrameInMinutesintoptionalTime interval which is used to split indexes for processing tasks.
Example:
If in index there are 10000 docs, it will be split for tasks to reindex by creation timestamp within a 60 min time period.
60
dateFieldstringoptionalTime field which indicates doc creation time.timestamp
clusterDestinationIdintoptionalCluster ID1
indexCreationStrategyenumoptionalIndex settings strategy:
TAKE_FROM_CONFIG,
BY_EXPRESSION
TAKE_FROM_CONFIG
shardsConfig primaryShards

Relevant only when “TAKE_FROM_CONFIG” is set
intoptionalDefault is supplied by ElasticsearchPrimary : 1,
Replica : 1,
RefreshIntervalInSeconds: 10
shardsConfig replicaShards

Relevant only when “TAKE_FROM_CONFIG” is set
intoptionalDefault is supplied by ElasticsearchPrimary : 1,
Replica : 1,
RefreshIntervalInSeconds: 10
shardsConfig refreshInterval

Relevant only when “TAKE_FROM_CONFIG” is set
intoptionalValue is in seconds, default is supplied by Elasticsearch-
shardCreateExpressions primary

Relevant only when “BY_EXPRESSION” is set
intoptionalAllowed param is ‘data_node’, Default is supplied by Elasticsearch-
shardCreateExpressions replica

Relevant only when “BY_EXPRESSION” is set
intoptionalAllowed param is ‘data_node’, Default is supplied by Elasticsearch-
shardCreateExpressions refreshInterval

Relevant only when “BY_EXPRESSION” is set
intoptionalValue is in seconds, default is supplied by Elasticsearch-

Shrink index

The shrink job allows you to shrink an existing index into a new index with fewer primary shards. This is usually a good solution when the shards of such an index are small in size (for example, an index with 8 primary shards with 1GB of size per shard). The shrink job can shrink this index to 1 primary shard with 8GB. This operation will reduce the management overhead on the cluster.

Note: This operation can add load on the cluster so it’s recommended to run it when the cluster is less loaded. Also, make sure you have enough disk space before running the Operation (At least the side of the source index)

Single run

Path: POST operator/shrink Example request body:

{  
   "indexPattern": "acc-13-00002",
   "maxShardSizeInGbBeforeShrink": 1,
   "maxShardSizeInGbAfterShrink": 20,
   "desiredNumberOfShardsAfterShrink": 1,
   "clusterDestinationId" : 1,
   "sleepBetweenShrinksInSec": 0,
   "datePattern": ".*(\\d{4}.\\d{2}.\\d{2})",
   "dateFormat": "yyyy.MM.dd",
   "datePatternGroup": 1,
   "timeField": "timestamp",
   "noWritesToIndexThresholdInMinutes": 5,
   "indexDesiredDigitsCount": 5,
   "shrinkTodayIndex": false
}
ParameterTypeRequired?Description
indexPatternstringrequiredThe index pattern to use with searching for matching indices to shrink. The pattern support “*”, in case the “*” is used the job will search all indices starting with prefix, for example: acc-1* return all indices starting with acc-1.
maxShardSizeInGbBeforeShrinkintrequiredMaximum shard size to consider as shrink candidate The default is 1gb
maxShardSizeInGbAfterShrinkintrequiredMax shard size of the index after the shrink The default to 20gb
desiredNumberOfShardsAfterShrinkintrequiredDesired number of shards The default to 1
sleepBetweenShrinksInSecintrequiredIf set to 0 the Operator will execute the task every 10 seconds
datePatternstringrequiredDate pattern used on the alias and index name
datePatternGroupintrequiredThe matching group number of the pattern
dateFormatstringrequiredFormat to parse extracted date by
timeFieldstringoptionalTime field on the index documents for example, we are using it for taking the last doc time on the index
noWritesToIndexThresholdInMinutesintOptionalThe last document time should be no later than `now` minus this. Expected to be in millis. By default this will not be tested
indexDesiredDigitsCountintrequiredThe number of zeros to use for the new index for example on “acc-13-00002” the indexDesiredDigitsCount is 4
shrinkTodayIndexbooloptionalIndicate if to shrink an index created today. Default is false

Shrink index scan

The job will scan the cluster/s and create a list of all indices to rollover, then generate and execute jobs for every index.

Path: POST operator/shrink/scan QueryParams: scheduled (Optional. Default is false) , interval (Optional. Default is 10 second) Example request body:

{  
"indexPattern": {"1": ["acc-1-*"]},
"excludeIndices": {"1": ["acc-1001"]},
"maxTaskIsParallel": {"1": 1},
"shrinkRequest": {
   "maxShardSizeInGbBeforeShrink": 1,
   "maxShardSizeInGbAfterShrink": 20,
   "desiredNumberOfShardsAfterShrink": 1,
   "sleepBetweenShrinksInSec": 0,
   "datePattern": ".*(\\d{4}.\\d{2}.\\d{2})",
   "dateFormat": "yyyy.MM.dd",
   "datePatternGroup": 1,
   "timeField": "timestamp",
   "noWritesToIndexThresholdInMinutes": 5,
   "indexDesiredDigitsCount": 5
}
}
ParameterTypeRequired?Description
indexPatternmaprequiredMap of cluster ID to index patterns to run (if ends with * prefix will be matched)
excludeIndicesmaprequiredMap of cluster ID to indices to be ignored ( * is not allowed)
maxTaskIsParallelmaprequiredMap of cluster ID to number of allowed concurrent running tasks

Optimize indices

One important task for an Elasticsearch master is to manage the cluster state which holds all the information about the indices, including their mapping, size, data location and more. As the number of indices increases, the cluster state becomes bigger and the overhead on the cluster can harm the cluster integrity and performance. When there are a lot of small indices, the job will reindex them to one index according to their size and reduce the overhead on the cluster.

Path: POST operator/shards/optimizer

Example request body:

{
   "indexPattern": "*acc*",
   "indexReplicas": 0,
   "reindexMaxSize": 30720,
   "maxWritesPerIndex": 5,
   "maxWritesPerIndexIntervalInSec": 10,
   "reindexWaitForCompletion": false,
   "retainExistingAliases": false,
   "sleepBetweenMergesInSec": 15,
   "noOptimizePattern": true,
   "indexDesiredDigitsCount" : 6,
   "clusterDestinationId": 1,
   "optimizeTodayIndex": true,
   "preTaskFilters": [{"type": "EXISTS", "modal": "must_exists", "fields": ["tenant"]}],
   "postReIndexActions": [{"type": "create_alias", "filters": [{"FilterType": "field", "field":"tenant"}]}]
}
ParameterTypeRequired?Description
indexPatternstringrequiredList of strings that should appear on the index name or used as separated patterns (if usePatternsAsSeparate is true) and it works like this for the example above:
- If start and ends with * we check that the index name contains acc.
- If ends with * we check that index start with acc
- No * check for perfect match
indexReplicasintoptionalNumber of replica shards for created target index
reindexMaxSizeintrequiredMax size in megabytes for indices to optimize
maxWritesPerIndexintoptionalThe maximum number of writes per interval at which optimization is allowed. Default value - 10
maxWritesPerIndexIntervalInSecintoptionalInterval in seconds to calculate the maximum number of writes. Default value - 15
reindexWaitForCompletionbooleanoptionalIf true, the task is waiting for completion of reindexing
If false, the task isn’t waiting for completion of reindexing. Default value - false
retainExistingAliasesstringoptionalIf true, aliases from indices for optimizing will be copied to the target index
If false, aliases from indices for optimizing won’t be copied to the target index. Default value - true
sleepBetweenMergesInSecintoptionalInterval is seconds between merges. Default value - 0
noOptimizePatternbooleanrequiredIf true, the task skips already optimized indices
If false, the task optimizes already optimized indices.
indexDesiredDigitsCountintoptionalThe number of digits to use for the numeric suffix on the new index name.
For example on “acc-1-00001” the indexDesiredDigitsCount is 5.
clusterDestinationIdintrequiredOn which backend the task should operate.
optimizeTodayIndexbooleanoptionalTo optimize today's index or not. Default value - false
preTaskFiltersList < Map < String, Object >>optionalFilters to select desired indices. Default value - no filters
postReIndexActionsList < Map < String, Object >>optionalActions to execute after reindexing.
Possible actions:
- сreate_alias: create new alias for optimized index. Possible filter types for created alias:
* field - add field filter to alias
* timestamp - add timestamp filter to alias
retryIntervalOnFailedIndexOptimizationAttemptInMinutesintoptionalInterval in minutes to restart optimization on a failed index. Default value - 60
reindexRequestPerSecondintoptionalThe number of requests per seconds. Default value - -1
reindexTimeoutStringoptionalTimeout for reindex. Default value - 5m

Split index

Splits an existing index into a new index with more primary shards. This job is used when an index has a number of primaries that are big in size (more than 50GB). The management for such an index in Elasticsearch can cause overhead on the cluster state and can be problematic when the shard needs to move to another node as part of the regular Elasticsearch operations. The split process improves indexing performance by creating a new index with more primary shards.

Note: This operation can add load on the cluster so it’s recommended to run it when the cluster is less loaded. Also, make sure you have enough disk space before running the Operation (At least the side of the source index)

Path: POST operator/split QueryParams: scheduled (Optional. Default is false)

Example request body:

{
   "sourceIndex" : "src-index-00001",
   "targetIndex": "src-index-split-00001",
   "sourceIndexIsReadOnly": true,
   "clusterDestinationId" : 1,
   "sleepBetweenSplitsInSec": 10,
   "splitTodayIndex": false,
   "desiredNumberOfShardsAfterSplit": 4,
   "shouldDeleteSourceIndex": false,
   "retryIntervalOnSplitFailedAttemptString": "15s"
}
ParameterTypeRequired?Description
sourceIndexstringrequiredThe index to split
targetIndexstringoptionalThe name of the new index after split, if not provided, will be the next incremental value. For example: if src-index-00001 -> src-index-00002, if src-index -> src-index-00001
sourceIndexIsReadOnlybooleanrequiredWhen settings this value as true you are confirming that the source index in read-only (hance eo writes to the index)
splitTodayIndexbooleanoptionalFor splitting today's index.(USE FOR TESTING)
desiredNumberOfShardsAfterSplitintoptionalSets the number of primary shard to set on the target index
desiredShardSizeAfterSplitInGBintoptionalThe average primary shard size target, this value will determine how many primary shards the target index will have. For example on 200G of index with 1 primary:
Setting desiredShardSizeAfterSplitInGB as 25, the target index will be created with 8 primary shards
shouldDeleteSourceIndexbooleanoptionalWhen set as true, the source index will be deleted after a successful split
retryIntervalOnSplitFailedAttemptStringstringoptionalWhen postponing a split task during its execution, it will be invoked again after this interval. Default: 10h (possible values, amount + type of unit: 1d, 8h, 300s, 60m)
forceMergeMaxNumSegmentsintoptionalSets the segments to merge during force marge operation . Default to 0
performForceMergebooleanoptionalWhether to execute force merge API call after successful split
datePatternstringrequiredDate pattern used on the alias and index name
datePatternGroupintrequiredThe matching group number of the pattern
dateFormatstringrequiredFormat to parse extracted date by

Job management API

Get list of jobs

Gets the list of jobs currently configured for the Operator to execute.

Path: GET /operator/jobs Query params (all are optional): status – can be one of: (SCHEDULED,IN_PROGRESS,RUNNING,CANCELED,DONE,ERROR,NOT_FOUND) strategy – can be one of: (EXECUTE_ONCE,SCHEDULED) IncludeCancelled – boolean. Default is false. Example request body: None Response:

[
  {
    "jobId": "-",
    "status": status,
    "createdOn": datetime,
    "lastExecutionTime": datetime,
    "interval": 0,
    "strategy": strategy,
    "jobConfig": escaped JSON string
  },
  ...
]

Get a single job

Gets a particular job (by its ID) currently configured for the Operator to execute. Path: GET /operator/jobs/ Example request body: None Response:

 {
    "jobId": "-",
    "status": status,
    "createdOn": datetime,
    "lastExecutionTime": datetime,
    "interval": 0,
    "strategy": strategy,
    "jobConfig": escaped JSON string
  }

Delete job

Deletes a particular job (by its job ID)

Path: DELETE /operator/jobs/{jobId} Example request body: None Response:

{
  "jobId": jobId,
  "status": "CANCELED",
  "interval": 0
}

Operator Management API

Get configuration

Path: GET /operator/config Example request body: NoneResponse: JSON representation of full configuration, example:

{
    "restServer": {
        "port": 5530
    },
    "shardOptimization": {
        "sleepBetweenMergesInSec": 0,
        "retryIntervalOnFailedIndexOptimizationAttemptInMinutes": 60,
        "retryIntervalOnFailedIndexOptimizationAttemptAfterThreeTriesInHours": 11,
        "indexPattern": null,
        "maxWritesPerIndex": 10,
        "targetIndexShardsCount": 2,
        "reindexMaxSize": 0,
        "reindexRequestPerSecond": -1.0,
        "reindexWaitForCompletion": false,
        "retainExistingAliases": true,
        "reindexTimeout": "5m",
        "indexReplicas": 2,
        "noOptimizePattern": true,
        "optimizeTodayIndex": false,
        "maxWritesPerIndexIntervalInSec": 15,
        "numOfConcurrentIndicesToOptimize": 1,
        "indexDesiredDigitsCount": 4,
        "retryTimesForOperation": 3
    },
    "jobScheduler": {
        "jobExecutionIntervalInSec": 10,
        "poolSize": 1,
        "timeFromLastSchedulerExecutionTimeThresholdInSec": 60,
        "jobToConcurrentExecutions": {
            "com.opster.operator.optimizers.shrink.SplitIndexTask": 1,
            "com.opster.operator.optimizers.shard.jobs.ShardOptimizerTask": 1,
            "com.opster.operator.optimizers.shrink.ShrinkIndexTask": 1,
            "com.opster.operator.reindex.SplitIndexTask": 1
        }
    },
    "jobStore": {
        "url": "$ES_URL",
        "indexName": ".opster-operator",
        "logsTemplateName": "operator-template-logs",
        "templateName": "operator",
        "cancelableJobsIndex": ".cancelable-tasks",
        "connectRetries": 5,
        "connectRetriesIntervalInMilli": 1000,
        "authInfo": {
            "type": "NONE",
            "credentials": {}
        }
    },
    "jobExecutor": {
        "poolSize": 5
    },
    "esClusters": [
        {
            "url": "$ES_URL",
            "id": 1,
            "authInfo": {
                "type": "NONE",
                "credentials": {}
            }
        },
        {
            "url": "http://localhost:9200",
            "id": 2,
            "authInfo": {
                "type": "BASIC",
                "credentials": {
                    "user": "user1",
                    "password": "userPass1"
                }
            }
        },
        {
            "url": "http://localhost:9201",
            "id": 3,
            "authInfo": {
                "type": "BASIC",
                "credentials": {
                    "user": "user2",
                    "password": "userPass2"
                }
            }
        }
    ],
    "esClient": {
        "readTimeout": 12000,
        "connTimeout": 30000,
        "maxConnections": 30
    },
    "rollover": {
        "indexAliases": null,
        "searchAliases": null,
        "desireDigitsCount": 4,
        "indexCreationStrategies": null,
        "shardCreateExpressions": null,
        "shardsConfig": {
            "primaryShards": 1,
            "replicaShards": 1,
            "refreshInterval": null,
            "indexName": null
        },
        "sizeThreshold": -1,
        "postRolloverActions": null,
        "timeField": null,
        "retryTimesAllowed": 0,
        "forceMergeMaxNumSegments": 30,
        "clusterDestinationId": -1,
        "shouldCopyMapping": false,
        "maxDocsThreshold": -1,
        "indexRetentionInHours": -1
    },
    "shrink": {
        "indexPattern": null,
        "operatorIndexPattern": null,
        "maxShardSizeInGbBeforeShrink": 0,
        "maxShardSizeInGbAfterShrink": 0,
        "desiredNumberOfShardsAfterShrink": 0,
        "desiredNumberOfReplicasAfterShrink": 0,
        "minimumIndexAgeInMinutesBeforeShrink": 5,
        "dryRun": false,
        "clusterDestinationId": 0,
        "retryTimesForOperation": 3,
        "datePattern": null,
        "timeField": null,
        "noWritesToIndexThresholdInMinutes": 5,
        "indexDesiredDigitsCount": 3,
        "maxRetries": 0,
        "waitForPrerequisites": [],
        "dateFormat": null,
        "datePatternGroup": 0,
        "shrinkTodayIndex": false,
        "scanTask": false
    },
    "split": {
        "datePattern": null,
        "dateFormat": null,
        "datePatternGroup": 0,
        "sourceIndex": null,
        "targetIndex": null,
        "targetIndexSuffix": null,
        "dryRun": false,
        "clusterDestinationId": 0,
        "splitTodayIndex": false,
        "desiredNumberOfShardsAfterSplit": 0,
        "desiredShardSizeAfterSplitInGB": 10,
        "shouldDeleteSourceIndex": false,
        "retryIntervalOnSplitFailedAttemptString": "10h",
        "forceMergeMaxNumSegments": 0,
        "performForceMerge": false,
        "scanTask": false
    },
    "clusterIdIndexStoreConfiguration": {
        "expireAfterWriteInSeconds": 600
    }
}

Get health

Path: GET /health, /operator/health Example request body: None Response: OK

Skip to content