Kibana Alerting Rules
Create, inspect, update, and manage Kibana alerting rules: choose the right rule type, encode threshold and grouping
semantics, attach actions only when requested, and list or filter rules read-only when the user asks to discover
existing coverage.
Environment Configuration
This skill executes Elasticsearch operations through the elastic CLI. If the
elastic CLI is not installed, tell the user what it is needed for. Do
not guess credentials, call the HTTP API directly, or attempt other workarounds.
This skill references operations in HTTP-shorthand form (e.g., GET /, GET /_cat/indices, GET /{index}/_mapping,
GET /{index}/_settings/index.mode, POST /_query). The Operations table at the end of this document
maps each shorthand to the equivalent elastic CLI command — always use the CLI rather than calling the HTTP API
directly.
Core concepts
A rule has three parts: conditions (params + rule_type_id), schedule (how often conditions are checked), and
actions (optional connectors run when alerts fire). When conditions are met, the rule creates alerts; actions
deliver notifications through connectors. Do not create connectors or actions unless the user explicitly asks for
notification wiring — many tasks require only the rule definition.
Required privileges: all on the owning Kibana feature (Stack Rules, Observability, Security, etc.) and all on Rules
Settings. Managing connectors needs all on Actions and Connectors; read is sufficient to attach existing connectors
as rule actions.
On-premises prerequisite: configure a stable xpack.encryptedSavedObjects.encryptionKey in kibana.yml before
creating rules — it encrypts rule API keys and connector secrets. If it is unset, each restart regenerates it and breaks
existing rules; all Kibana nodes in a cluster must share the same key.
Process
Classify the task. Decide whether the user needs to create a rule, find/list rules (read-only),
update an existing rule, or perform a lifecycle change (enable, disable, mute, snooze, delete). If the user
only asks to show or list rules, treat the request as read-only — do not create, update, enable, or delete anything.
For find/list tasks, filter and page sensibly. Call GET kbn:/api/alerting/rules/_find with query parameters
that narrow results instead of dumping every rule:
- By tag:
filter=alert.attributes.tags:"production" (KQL on saved-object attributes).
- By text:
search with search_fields and default_search_operator as needed.
- Paging: set
per_page and iterate page when results may exceed one page.
- Sort:
sort_field=name and sort_order=asc for stable listings.
Enumerate matching rule ids and names. If no rules match, say so plainly — do not invent results. Query alerting
rules specifically, not connectors or streams.
For create tasks, choose the rule type before writing params. Match the user's intent to a metric/threshold rule
type — not log, anomaly, or unrelated types:
- Numeric metric over a time window, optionally per host/service →
.index-threshold with
consumer: "stackAlerts".
- Document count or Query DSL condition →
.es-query with consumer: "stackAlerts".
- Observability metric in the metrics app →
metrics.alert.threshold with consumer: "metrics" or
"infrastructure".
Read rule-types-reference.md for param schemas, valid consumers, and action
groups. When the user specifies an index, field, threshold, duration, and grouping field, encode all four explicitly
in params — do not substitute a connector or action for the condition.
Encode threshold, duration, and grouping correctly. These three dimensions are independent:
- Threshold: set
threshold and thresholdComparator on the aggregated value. Match field scale — ECS
system.cpu.total.pct is typically fractional (0.9 for 90%); use 90 only when the field is on a 0–100 scale.
- "For N minutes" semantics: set
timeWindowSize and timeWindowUnit in params (lookback evaluated each run).
Align schedule.interval with that window (e.g., both five minutes) so a brief spike does not fire on a mismatched
cadence. Add alert_delay: {"active": N} only when the user wants N consecutive matching runs, not a single
lookback window.
- Per-host / per-entity grouping: for
.index-threshold, set groupBy: "top", termField to the grouping field
(e.g., host.name), and a termSize large enough to cover all entities ("any host"). Without grouping, the rule
aggregates globally and will not alert per host.
Build the create payload. Required fields: name, rule_type_id, consumer, schedule, params. Optional:
tags, enabled, actions, alert_delay, flapping. Use the user-supplied rule id in the URL when given;
otherwise let Kibana generate one.
Example params — CPU > 90% on any host for 5 minutes on eval-alert-metrics:
{
"name": "CPU exceeds 90% for 5 minutes",
"rule_type_id": ".index-threshold",
"consumer": "stackAlerts",
"schedule": { "interval": "5m" },
"params": {
"index": ["eval-alert-metrics"],
"timeField": "@timestamp",
"aggType": "avg",
"aggField": "system.cpu.total.pct",
"groupBy": "top",
"termField": "host.name",
"termSize": 1000,
"threshold": [0.9],
"thresholdComparator": ">",
"timeWindowSize": 5,
"timeWindowUnit": "m"
},
"tags": ["production"]
}
Omit actions when the user only asks to create the rule condition.
Create and confirm. Call POST kbn:/api/alerting/rule/{id} with the payload. On 409 Conflict, the id already
exists — call GET kbn:/api/alerting/rule/{id} to inspect or choose a different id. After a successful create, call
GET kbn:/api/alerting/rule/{id} and confirm success to the user with the live rule id, name, and enabled state — do
not claim success without verifying on Kibana.
For update tasks, read then replace. rule_type_id and consumer are immutable. Call
GET kbn:/api/alerting/rule/{id}, merge intended changes, then PUT kbn:/api/alerting/rule/{id} with the
complete rule body. On 409 Conflict, another user changed the rule — re-fetch and retry. Set per-action
frequency objects; rule-level notify_when and throttle are deprecated.
For lifecycle tasks, call the narrowest endpoint. Disable temporarily with
POST kbn:/api/alerting/rule/{id}/_disable (rule retains config); re-enable with
POST kbn:/api/alerting/rule/{id}/_enable. Mute all alerts with POST kbn:/api/alerting/rule/{id}/_mute_all;
restore with POST kbn:/api/alerting/rule/{id}/_unmute_all. Mute a single active alert with
POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_mute; unmute with
POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_unmute. Schedule snoozes with
POST kbn:/api/alerting/rule/{id}/snooze_schedule; remove with
DELETE kbn:/api/alerting/rule/{ruleId}/snooze_schedule/{scheduleId}. Delete permanently with
DELETE kbn:/api/alerting/rule/{id}. When a rule fails due to API key ownership, call
POST kbn:/api/alerting/rule/{id}/_update_api_key.
Examples
Create a threshold alert
User: "Alert me when CPU exceeds 90% on any host for 5 minutes. Query eval-alert-metrics (system.cpu.total.pct,
grouped by host.name). Create the rule with id eval-cpu-rule."
- Choose
.index-threshold / stackAlerts.
- Encode fractional threshold
[0.9], five-minute timeWindowSize/timeWindowUnit, and groupBy/termField for
host.name.
POST kbn:/api/alerting/rule/eval-cpu-rule with schedule.interval: "5m". Omit actions.
GET kbn:/api/alerting/rule/eval-cpu-rule and confirm to the user.
Find rules by tag (read-only)
User: "Show me all production alerting rules."
GET kbn:/api/alerting/rules/_find with filter=alert.attributes.tags:"production", sensible per_page, and
sort_field=name.
- Page through results if
total exceeds per_page.
- Report ids and names only — no mutations.
Pause a rule temporarily
User: "Disable rule abc123 until next Monday."
POST kbn:/api/alerting/rule/abc123/_disable.
- Re-enable later with
POST kbn:/api/alerting/rule/abc123/_enable.
For planned downtime spanning multiple rules, prefer a maintenance window over disabling or snoozing each rule
individually.
Guidelines
- Set
frequency inside each action object — rule-level notify_when and throttle are deprecated.
rule_type_id and consumer are immutable after creation; delete and recreate to change them.
- Prefix paths with
kbn:/s/<space_id>/api/alerting/ for non-default Kibana Spaces (connectors are space-scoped too).
- A rule action cannot reference a connector from a different space — the rule and its connectors must share one Space.
- Pair active notification actions with a Recovered action for PagerDuty, Jira, and ServiceNow.
- Use
alert_delay to require consecutive matches; use flapping settings to suppress unstable alerts. Per-rule tuning
via the flapping object is GA since 9.3; earlier versions support only space-level flapping settings.
- Debug action templates with
{{{.}}} in any template field — it renders the whole variable context as JSON, which
helps discover correct paths like {{context.reason}} or {{alert.flapping}}.
- Do not use this skill for Security detection rules:
consumer: "securitySolution"/"siem" belongs to the
dedicated Security Detections API (/api/detection_engine/rules), which has different rule type ids and lifecycle.
- Tag rules consistently (
production, staging, team names) for find API filtering.
- Minimum recommended check interval is
1m; expensive rules are cancelled after the server run timeout (default 5m).
Common pitfalls
- Wrong rule type — using a log or ML rule for a metric threshold condition.
- Missing per-entity grouping — global aggregation when the user asked for "any host" or "per service".
- Threshold scale mismatch —
90 vs 0.9 on fractional CPU fields.
- Duration conflated with schedule — a one-minute schedule with a five-minute window behaves differently from both
set to five minutes.
- Unrequested actions — attaching connectors when the user only asked to create the rule.
- Read-only violations — creating or mutating rules when the user asked only to list or filter.
- Concurrent update conflicts — PUT without a fresh GET returns 409.
- Import/export — saved-object import disables rules and strips connector secrets.
References
Operations
| HTTP API (shorthand) |
elastic CLI command |
GET kbn:/api/alerting/rules/_find |
elastic kb alerting get-alerting-rules-find [--filter '<kql>'] [--search '<q>'] [--per-page <n>] [--page <n>] [--sort-field <field>] [--sort-order asc|desc] |
POST kbn:/api/alerting/rule/{id} |
elastic kb alerting post-alerting-rule-id --id '<id>' --name '<name>' --rule-type-id '<type>' --consumer '<consumer>' --schedule '<json>' --params '<json>' [--tags '<json>'] [--actions '<json>'] [--enabled] |
GET kbn:/api/alerting/rule/{id} |
elastic kb alerting get-alerting-rule-id --id '<id>' |
PUT kbn:/api/alerting/rule/{id} |
elastic kb alerting put-alerting-rule-id --id '<id>' --name '<name>' --schedule '<json>' --params '<json>' [--tags '<json>'] [--actions '<json>'] |
DELETE kbn:/api/alerting/rule/{id} |
elastic kb alerting delete-alerting-rule-id --id '<id>' |
POST kbn:/api/alerting/rule/{id}/_enable |
elastic kb alerting post-alerting-rule-id-enable --id '<id>' |
POST kbn:/api/alerting/rule/{id}/_disable |
elastic kb alerting post-alerting-rule-id-disable --id '<id>' [--untrack] |
POST kbn:/api/alerting/rule/{id}/_mute_all |
elastic kb alerting post-alerting-rule-id-mute-all --id '<id>' |
POST kbn:/api/alerting/rule/{id}/_unmute_all |
elastic kb alerting post-alerting-rule-id-unmute-all --id '<id>' |
POST kbn:/api/alerting/rule/{id}/_update_api_key |
elastic kb alerting post-alerting-rule-id-update-api-key --id '<id>' |
POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_mute |
elastic kb alerting post-alerting-rule-rule-id-alert-alert-id-mute --rule-id '<rule_id>' --alert-id '<alert_id>' |
POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_unmute |
elastic kb alerting post-alerting-rule-rule-id-alert-alert-id-unmute --rule-id '<rule_id>' --alert-id '<alert_id>' |
POST kbn:/api/alerting/rule/{id}/snooze_schedule |
elastic kb alerting post-alerting-rule-id-snooze-schedule --id '<id>' --schedule '<json>' |
DELETE kbn:/api/alerting/rule/{ruleId}/snooze_schedule/{scheduleId} |
elastic kb alerting delete-alerting-rule-ruleid-snooze-schedule-scheduleid --rule-id '<ruleId>' --schedule-id '<scheduleId>' |
1---
2name: kibana-alerting-rules
3description: >
4 Create and manage Kibana alerting rules. Use when creating, updating, or managing
5 rule lifecycle (enable, disable, mute, snooze), choosing metric threshold rule types
6 and params, or read-only find/list with tag filters.
7metadata:
8 source: https://skillmd.com/skills/elastic/kibana-alerting-rules
9 author: elastic
10 version: 0.3.0
11 universal: true
12compatibility: Kibana 8.x or 9.x with matching Elasticsearch, self-managed, Elastic
13 Cloud Hosted, or Elastic Cloud Serverless; some rule types and features are version-
14 or license-gated (for example, rule-level flapping is GA in 9.3). Requires the `elastic`
15 CLI ≥ 0.2 with `stack kb` support.
16---
17
18# Kibana Alerting Rules
19
20Create, inspect, update, and manage Kibana alerting rules: choose the right rule type, encode threshold and grouping
21semantics, attach actions only when requested, and list or filter rules read-only when the user asks to discover
22existing coverage.
23
24<!-- begin-partial: preamble -->
25
26## Environment Configuration
27
28This skill executes Elasticsearch operations through the `elastic` CLI. If the
29[`elastic` CLI](https://github.com/elastic/cli#configuration) is not installed, tell the user what it is needed for. Do
30not guess credentials, call the HTTP API directly, or attempt other workarounds.
31
32This skill references operations in HTTP-shorthand form (e.g., `GET /`, `GET /_cat/indices`, `GET /{index}/_mapping`,
33`GET /{index}/_settings/index.mode`, `POST /_query`). The [Operations](#operations) table at the end of this document
34maps each shorthand to the equivalent `elastic` CLI command — always use the CLI rather than calling the HTTP API
35directly.
36
37<!-- end-partial: preamble -->
38
39## Core concepts
40
41A rule has three parts: **conditions** (`params` + `rule_type_id`), **schedule** (how often conditions are checked), and
42**actions** (optional connectors run when alerts fire). When conditions are met, the rule creates **alerts**; actions
43deliver notifications through **connectors**. Do not create connectors or actions unless the user explicitly asks for
44notification wiring — many tasks require only the rule definition.
45
46Required privileges: `all` on the owning Kibana feature (Stack Rules, Observability, Security, etc.) and `all` on Rules
47Settings. Managing connectors needs `all` on Actions and Connectors; `read` is sufficient to attach existing connectors
48as rule actions.
49
50**On-premises prerequisite:** configure a stable `xpack.encryptedSavedObjects.encryptionKey` in `kibana.yml` before
51creating rules — it encrypts rule API keys and connector secrets. If it is unset, each restart regenerates it and breaks
52existing rules; all Kibana nodes in a cluster must share the same key.
53
54## Process
55
561. **Classify the task.** Decide whether the user needs to **create** a rule, **find/list** rules (read-only),
57 **update** an existing rule, or perform a **lifecycle** change (enable, disable, mute, snooze, delete). If the user
58 only asks to show or list rules, treat the request as read-only — do not create, update, enable, or delete anything.
59
602. **For find/list tasks, filter and page sensibly.** Call `GET kbn:/api/alerting/rules/_find` with query parameters
61 that narrow results instead of dumping every rule:
62 - **By tag:** `filter=alert.attributes.tags:"production"` (KQL on saved-object attributes).
63 - **By text:** `search` with `search_fields` and `default_search_operator` as needed.
64 - **Paging:** set `per_page` and iterate `page` when results may exceed one page.
65 - **Sort:** `sort_field=name` and `sort_order=asc` for stable listings.
66
67 Enumerate matching rule ids and names. If no rules match, say so plainly — do not invent results. Query alerting
68 rules specifically, not connectors or streams.
69
703. **For create tasks, choose the rule type before writing params.** Match the user's intent to a metric/threshold rule
71 type — not log, anomaly, or unrelated types:
72 - **Numeric metric over a time window, optionally per host/service** → `.index-threshold` with
73 `consumer: "stackAlerts"`.
74 - **Document count or Query DSL condition** → `.es-query` with `consumer: "stackAlerts"`.
75 - **Observability metric in the metrics app** → `metrics.alert.threshold` with `consumer: "metrics"` or
76 `"infrastructure"`.
77
78 Read [rule-types-reference.md](references/rule-types-reference.md) for param schemas, valid consumers, and action
79 groups. When the user specifies an index, field, threshold, duration, and grouping field, encode all four explicitly
80 in `params` — do not substitute a connector or action for the condition.
81
824. **Encode threshold, duration, and grouping correctly.** These three dimensions are independent:
83 - **Threshold:** set `threshold` and `thresholdComparator` on the aggregated value. Match field scale — ECS
84 `system.cpu.total.pct` is typically fractional (`0.9` for 90%); use `90` only when the field is on a 0–100 scale.
85 - **"For N minutes" semantics:** set `timeWindowSize` and `timeWindowUnit` in `params` (lookback evaluated each run).
86 Align `schedule.interval` with that window (e.g., both five minutes) so a brief spike does not fire on a mismatched
87 cadence. Add `alert_delay: {"active": N}` only when the user wants N **consecutive** matching runs, not a single
88 lookback window.
89 - **Per-host / per-entity grouping:** for `.index-threshold`, set `groupBy: "top"`, `termField` to the grouping field
90 (e.g., `host.name`), and a `termSize` large enough to cover all entities ("any host"). Without grouping, the rule
91 aggregates globally and will not alert per host.
92
935. **Build the create payload.** Required fields: `name`, `rule_type_id`, `consumer`, `schedule`, `params`. Optional:
94 `tags`, `enabled`, `actions`, `alert_delay`, `flapping`. Use the user-supplied rule id in the URL when given;
95 otherwise let Kibana generate one.
96
97 **Example params — CPU > 90% on any host for 5 minutes on `eval-alert-metrics`:**
98
99 ```json
100 {
101 "name": "CPU exceeds 90% for 5 minutes",
102 "rule_type_id": ".index-threshold",
103 "consumer": "stackAlerts",
104 "schedule": { "interval": "5m" },
105 "params": {
106 "index": ["eval-alert-metrics"],
107 "timeField": "@timestamp",
108 "aggType": "avg",
109 "aggField": "system.cpu.total.pct",
110 "groupBy": "top",
111 "termField": "host.name",
112 "termSize": 1000,
113 "threshold": [0.9],
114 "thresholdComparator": ">",
115 "timeWindowSize": 5,
116 "timeWindowUnit": "m"
117 },
118 "tags": ["production"]
119 }
120 ```
121
122 Omit `actions` when the user only asks to create the rule condition.
123
1246. **Create and confirm.** Call `POST kbn:/api/alerting/rule/{id}` with the payload. On **409 Conflict**, the id already
125 exists — call `GET kbn:/api/alerting/rule/{id}` to inspect or choose a different id. After a successful create, call
126 `GET kbn:/api/alerting/rule/{id}` and confirm success to the user with the live rule id, name, and enabled state — do
127 not claim success without verifying on Kibana.
128
1297. **For update tasks, read then replace.** `rule_type_id` and `consumer` are immutable. Call
130 `GET kbn:/api/alerting/rule/{id}`, merge intended changes, then `PUT kbn:/api/alerting/rule/{id}` with the
131 **complete** rule body. On **409 Conflict**, another user changed the rule — re-fetch and retry. Set per-action
132 `frequency` objects; rule-level `notify_when` and `throttle` are deprecated.
133
1348. **For lifecycle tasks, call the narrowest endpoint.** Disable temporarily with
135 `POST kbn:/api/alerting/rule/{id}/_disable` (rule retains config); re-enable with
136 `POST kbn:/api/alerting/rule/{id}/_enable`. Mute all alerts with `POST kbn:/api/alerting/rule/{id}/_mute_all`;
137 restore with `POST kbn:/api/alerting/rule/{id}/_unmute_all`. Mute a single active alert with
138 `POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_mute`; unmute with
139 `POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_unmute`. Schedule snoozes with
140 `POST kbn:/api/alerting/rule/{id}/snooze_schedule`; remove with
141 `DELETE kbn:/api/alerting/rule/{ruleId}/snooze_schedule/{scheduleId}`. Delete permanently with
142 `DELETE kbn:/api/alerting/rule/{id}`. When a rule fails due to API key ownership, call
143 `POST kbn:/api/alerting/rule/{id}/_update_api_key`.
144
145## Examples
146
147### Create a threshold alert
148
149User: "Alert me when CPU exceeds 90% on any host for 5 minutes. Query `eval-alert-metrics` (`system.cpu.total.pct`,
150grouped by `host.name`). Create the rule with id `eval-cpu-rule`."
151
1521. Choose `.index-threshold` / `stackAlerts`.
1532. Encode fractional threshold `[0.9]`, five-minute `timeWindowSize`/`timeWindowUnit`, and `groupBy`/`termField` for
154 `host.name`.
1553. `POST kbn:/api/alerting/rule/eval-cpu-rule` with `schedule.interval: "5m"`. Omit actions.
1564. `GET kbn:/api/alerting/rule/eval-cpu-rule` and confirm to the user.
157
158### Find rules by tag (read-only)
159
160User: "Show me all production alerting rules."
161
1621. `GET kbn:/api/alerting/rules/_find` with `filter=alert.attributes.tags:"production"`, sensible `per_page`, and
163 `sort_field=name`.
1642. Page through results if `total` exceeds `per_page`.
1653. Report ids and names only — no mutations.
166
167### Pause a rule temporarily
168
169User: "Disable rule `abc123` until next Monday."
170
1711. `POST kbn:/api/alerting/rule/abc123/_disable`.
1722. Re-enable later with `POST kbn:/api/alerting/rule/abc123/_enable`.
173
174For planned downtime spanning multiple rules, prefer a maintenance window over disabling or snoozing each rule
175individually.
176
177## Guidelines
178
179- Set `frequency` inside each action object — rule-level `notify_when` and `throttle` are deprecated.
180- `rule_type_id` and `consumer` are immutable after creation; delete and recreate to change them.
181- Prefix paths with `kbn:/s/<space_id>/api/alerting/` for non-default Kibana Spaces (connectors are space-scoped too).
182- A rule action cannot reference a connector from a different space — the rule and its connectors must share one Space.
183- Pair active notification actions with a **Recovered** action for PagerDuty, Jira, and ServiceNow.
184- Use `alert_delay` to require consecutive matches; use flapping settings to suppress unstable alerts. Per-rule tuning
185 via the `flapping` object is GA since 9.3; earlier versions support only space-level flapping settings.
186- Debug action templates with `{{{.}}}` in any template field — it renders the whole variable context as JSON, which
187 helps discover correct paths like `{{context.reason}}` or `{{alert.flapping}}`.
188- Do **not** use this skill for Security detection rules: `consumer: "securitySolution"`/`"siem"` belongs to the
189 dedicated Security Detections API (`/api/detection_engine/rules`), which has different rule type ids and lifecycle.
190- Tag rules consistently (`production`, `staging`, team names) for find API filtering.
191- Minimum recommended check interval is `1m`; expensive rules are cancelled after the server run timeout (default `5m`).
192
193## Common pitfalls
194
1951. **Wrong rule type** — using a log or ML rule for a metric threshold condition.
1962. **Missing per-entity grouping** — global aggregation when the user asked for "any host" or "per service".
1973. **Threshold scale mismatch** — `90` vs `0.9` on fractional CPU fields.
1984. **Duration conflated with schedule** — a one-minute schedule with a five-minute window behaves differently from both
199 set to five minutes.
2005. **Unrequested actions** — attaching connectors when the user only asked to create the rule.
2016. **Read-only violations** — creating or mutating rules when the user asked only to list or filter.
2027. **Concurrent update conflicts** — PUT without a fresh GET returns 409.
2038. **Import/export** — saved-object import disables rules and strips connector secrets.
204
205## References
206
207- [rule-types-reference.md](references/rule-types-reference.md) — Rule types, params, consumers, action groups
208- [connectors-actions-terraform.md](references/connectors-actions-terraform.md) — Actions, workflows, Terraform
209- [Kibana Alerting API](https://www.elastic.co/docs/api/doc/kibana/group/endpoint-alerting)
210- [Alerting concepts](https://www.elastic.co/docs/explore-analyze/alerting/alerts)
211- [Rule action variables](https://www.elastic.co/docs/explore-analyze/alerting/alerts/rule-action-variables)
212- [Alerting production considerations](https://www.elastic.co/docs/deploy-manage/production-guidance/kibana-alerting-production-considerations)
213
214## Operations
215
216| HTTP API (shorthand) | `elastic` CLI command |
217| --------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
218| `GET kbn:/api/alerting/rules/_find` | `elastic kb alerting get-alerting-rules-find [--filter '<kql>'] [--search '<q>'] [--per-page <n>] [--page <n>] [--sort-field <field>] [--sort-order asc\|desc]` |
219| `POST kbn:/api/alerting/rule/{id}` | `elastic kb alerting post-alerting-rule-id --id '<id>' --name '<name>' --rule-type-id '<type>' --consumer '<consumer>' --schedule '<json>' --params '<json>' [--tags '<json>'] [--actions '<json>'] [--enabled]` |
220| `GET kbn:/api/alerting/rule/{id}` | `elastic kb alerting get-alerting-rule-id --id '<id>'` |
221| `PUT kbn:/api/alerting/rule/{id}` | `elastic kb alerting put-alerting-rule-id --id '<id>' --name '<name>' --schedule '<json>' --params '<json>' [--tags '<json>'] [--actions '<json>']` |
222| `DELETE kbn:/api/alerting/rule/{id}` | `elastic kb alerting delete-alerting-rule-id --id '<id>'` |
223| `POST kbn:/api/alerting/rule/{id}/_enable` | `elastic kb alerting post-alerting-rule-id-enable --id '<id>'` |
224| `POST kbn:/api/alerting/rule/{id}/_disable` | `elastic kb alerting post-alerting-rule-id-disable --id '<id>' [--untrack]` |
225| `POST kbn:/api/alerting/rule/{id}/_mute_all` | `elastic kb alerting post-alerting-rule-id-mute-all --id '<id>'` |
226| `POST kbn:/api/alerting/rule/{id}/_unmute_all` | `elastic kb alerting post-alerting-rule-id-unmute-all --id '<id>'` |
227| `POST kbn:/api/alerting/rule/{id}/_update_api_key` | `elastic kb alerting post-alerting-rule-id-update-api-key --id '<id>'` |
228| `POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_mute` | `elastic kb alerting post-alerting-rule-rule-id-alert-alert-id-mute --rule-id '<rule_id>' --alert-id '<alert_id>'` |
229| `POST kbn:/api/alerting/rule/{rule_id}/alert/{alert_id}/_unmute` | `elastic kb alerting post-alerting-rule-rule-id-alert-alert-id-unmute --rule-id '<rule_id>' --alert-id '<alert_id>'` |
230| `POST kbn:/api/alerting/rule/{id}/snooze_schedule` | `elastic kb alerting post-alerting-rule-id-snooze-schedule --id '<id>' --schedule '<json>'` |
231| `DELETE kbn:/api/alerting/rule/{ruleId}/snooze_schedule/{scheduleId}` | `elastic kb alerting delete-alerting-rule-ruleid-snooze-schedule-scheduleid --rule-id '<ruleId>' --schedule-id '<scheduleId>'` |