Cancel Camunda Instances Stuck on an Incident with Kestra

id: camunda-incident-stuck-process-instance-cancel-guard
namespace: company.team
description: |
  Find Camunda 8 process instances parked on an unresolvable incident, then cancel
  them behind an approval gate and prove from the engine that they are gone.

  An instance whose job has burned every retry raises a JOB_NO_RETRIES incident and
  then stops moving. The engine stays healthy, so nothing alerts, while the instance
  keeps its job, its variables and its row in the runtime tables. The process
  definition cannot be cleanly retired while instances still reference it.

  Cancelling destroys in-flight business state. Four controls stand in front of the
  write: a grace window, a process-definition allowlist, a per-run ceiling, plus a
  live re-read of the job's own retries so an instance that still has retries left is
  refused rather than cancelled. Read-only by default.

triggers:
  - id: hourly_stuck_instance_sweep
    type: io.kestra.plugin.core.trigger.Schedule
    description: Sweep for stuck instances every hour. Shipped disabled. Enable it
      once camunda_rest_address plus allowed_process_definition_ids point at a
      real cluster and one manual run has been checked. Its own inputs force
      report-only mode whatever this flow's defaults say.
    cron: "17 * * * *"
    disabled: true
    inputs:
      auto_remediate: "false"
      dry_run: "true"

inputs:
  - id: camunda_rest_address
    type: STRING
    displayName: "Camunda REST API Base URL"
    defaults: "http://localhost:8080"
    description: Base URL of the Camunda 8 Orchestration Cluster REST API. Used for
      the v2 search reads and passed as restAddress to the CancelProcessInstance
      task.

  - id: allowed_process_definition_ids
    type: STRING
    displayName: "Cancellable Process Definition IDs (JSON array)"
    defaults: "[\"order-fulfillment\"]"
    description: >-
      JSON array of BPMN process IDs (Camunda's processDefinitionId) whose
      instances may be cancelled. The list is pushed into the incident search as
      an $in filter, so a definition that is not named here is never even a
      candidate. Keep it short. Only put a definition here once someone has
      agreed that abandoning an in-flight instance of it is acceptable.

  - id: grace_minutes
    type: INT
    displayName: "Incident Grace Window (minutes)"
    defaults: 120
    description: An incident must have been open at least this long before its
      instance counts as stuck. Protects an incident someone is working on right
      now. It also spares one a worker is about to clear.

  - id: max_cancellations
    type: INT
    displayName: "Cancellations Per Run Ceiling"
    defaults: 5
    description: If a run finds more cancellable instances than this, it cancels
      nothing and alerts instead. A sudden large finding count usually means a
      bad deployment or a dead worker pool, not a backlog to delete.

  - id: auto_remediate
    type: SELECT
    displayName: "Auto Remediate"
    defaults: "false"
    values:
      - "false"
      - "true"
    description: Set to "true" to allow cancellation at all. With "false" the run
      reports what it found.

  - id: dry_run
    type: SELECT
    displayName: "Dry Run"
    defaults: "true"
    values:
      - "true"
      - "false"
    description: Must be explicitly "false", together with auto_remediate "true",
      before any instance is cancelled. Either gate alone keeps the run
      read-only.

tasks:
  - id: read_stuck_incidents
    type: io.kestra.plugin.core.http.Request
    description: >-
      Active JOB_NO_RETRIES incidents older than the grace window, restricted to
      the allowed definitions. Camunda's v2 search API does the grace window
      with a creationTime $lt filter and the allowlist with a
      processDefinitionId $in filter, so neither control depends on this flow
      filtering correctly afterwards.
    uri: "{{ inputs.camunda_rest_address }}/v2/incidents/search"
    method: POST
    contentType: application/json
    body: |
      {
        "filter": {
          "state": "ACTIVE",
          "errorType": "JOB_NO_RETRIES",
          "processDefinitionId": {"$in": {{ inputs.allowed_process_definition_ids }} },
          "creationTime": {"$lt": "{{ execution.startDate | dateAdd(0 - inputs.grace_minutes, 'MINUTES') | date("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", timeZone="UTC") }}"}
        },
        "page": {"limit": 1000}
      }

  - id: read_exhausted_jobs
    type: io.kestra.plugin.core.http.Request
    description: >-
      Jobs that are FAILED with retries at exactly 0. An incident's errorType
      records why the incident was raised, not what the job looks like now: a
      job whose retries were pushed back up keeps an open JOB_NO_RETRIES
      incident. So retries are read from the job itself, live. Only an instance
      that appears in both reads is treated as stuck.
    uri: "{{ inputs.camunda_rest_address }}/v2/jobs/search"
    method: POST
    contentType: application/json
    body: |
      {
        "filter": {"state": "FAILED", "retries": 0},
        "page": {"limit": 1000}
      }

  - id: read_active_before
    type: io.kestra.plugin.core.http.Request
    description: Count of every ACTIVE process instance on the cluster before
      anything changes. The headline number the audit line compares against.
    uri: "{{ inputs.camunda_rest_address }}/v2/process-instances/search"
    method: POST
    contentType: application/json
    body: |
      {
        "filter": {"state": "ACTIVE"},
        "page": {"limit": 1}
      }

  - id: classify_findings
    type: io.kestra.plugin.core.output.OutputValues
    description: >-
      Intersect the two reads on processInstanceKey, then pick one decision for
      the whole run. NO_FINDINGS, OVER_CEILING, REPORT_ONLY or CANCEL.
      Everything numeric happens inside the single jq program, so no count is
      retyped between tasks.
    values:
      result: >-
        {{ {'incidents': outputs.read_stuck_incidents.body, 'jobs':
        outputs.read_exhausted_jobs.body, 'ceiling': inputs.max_cancellations,
        'auto_remediate': inputs.auto_remediate, 'dry_run': inputs.dry_run} |
        toJson
           | jq('. as $r | ($r.incidents | fromjson) as $i | ($r.jobs | fromjson) as $j | [$j.items[] | .processInstanceKey | tostring] as $ex | [$i.items[] | . as $inc | select(([$ex[] | select(. == ($inc.processInstanceKey | tostring))] | length) > 0)] as $hits | ($hits | length) as $n | {count: $n, keys: [$hits[] | .processInstanceKey | tostring], detail: ([$hits[] | ((.processInstanceKey | tostring) + " " + (.processDefinitionId | tostring) + " incident=" + (.incidentKey | tostring) + " opened=" + (.creationTime | tostring))] | join("; ")), ceiling: $r.ceiling, decision: (if $n == 0 then "NO_FINDINGS" elif $n > $r.ceiling then "OVER_CEILING" elif ($r.auto_remediate == "true" and $r.dry_run == "false") then "CANCEL" else "REPORT_ONLY" end)} | tojson')
           | first }}

  - id: log_findings
    type: io.kestra.plugin.core.log.Log
    description: One line carrying the detector's own numbers, so the execution list
      shows what each run saw without opening a task output.
    message: >-
      Stuck instance scan on {{ inputs.camunda_rest_address }}:
      active_instances={{ outputs.read_active_before.body |
      jq('.page.totalItems') | first }} incidents_past_grace={{
      outputs.read_stuck_incidents.body | jq('.page.totalItems') | first }}
      jobs_retries_zero={{ outputs.read_exhausted_jobs.body |
      jq('.page.totalItems') | first }} cancellable={{
      outputs.classify_findings.values.result | jq('.count') | first }}
      ceiling={{ inputs.max_cancellations }} grace_minutes={{
      inputs.grace_minutes }} decision={{
      outputs.classify_findings.values.result | jq('.decision') | first }}
      detail=[{{ outputs.classify_findings.values.result | jq('.detail') | first
      }}]

  - id: route_decision
    type: io.kestra.plugin.core.flow.Switch
    description: >-
      One branch per decision. The defaults branch exists because a jq program
      that errors yields nothing, which would otherwise read as a healthy
      cluster: an unreadable detector result fails the run instead of passing
      it.
    value: "{{ (outputs.classify_findings.values.result | jq('.decision') | first)
      ?? 'UNREADABLE' }}"
    cases:
      "NO_FINDINGS":
        - id: log_no_findings
          type: io.kestra.plugin.core.log.Log
          message: "No cancellable instances. Nothing on {{
            inputs.allowed_process_definition_ids }} has an open JOB_NO_RETRIES
            incident older than {{ inputs.grace_minutes }} minutes whose job is
            also sitting at 0 retries."

      "OVER_CEILING":
        - id: alert_over_ceiling
          type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
          description: A finding count over the ceiling is its own alert. Nothing is
            cancelled, because a spike like this is usually one broken
            deployment rather than a backlog worth deleting.
          url: "{{ secret('SLACK_WEBHOOK_URL') }}"
          payload: |
            {
              "text": "Camunda stuck instance guard REFUSED to cancel: {{ outputs.classify_findings.values.result | jq('.count') | first }} cancellable instances exceeds the per-run ceiling of {{ inputs.max_cancellations }}. Nothing was cancelled. Check whether a worker pool is down or a bad definition was deployed before raising the ceiling. Execution {{ execution.id }}."
            }
        - id: log_over_ceiling
          type: io.kestra.plugin.core.log.Log
          message: "REFUSED: {{ outputs.classify_findings.values.result | jq('.count') |
            first }} cancellable instances is over the ceiling of {{
            inputs.max_cancellations }}. No instance was cancelled. Candidates:
            {{ outputs.classify_findings.values.result | jq('.detail') | first
            }}"

      "REPORT_ONLY":
        - id: log_report_only
          type: io.kestra.plugin.core.log.Log
          message: "Would cancel {{ outputs.classify_findings.values.result | jq('.count')
            | first }} instance(s) and did not, because auto_remediate={{
            inputs.auto_remediate }} dry_run={{ inputs.dry_run }}. Candidates:
            {{ outputs.classify_findings.values.result | jq('.detail') | first
            }}"

      "CANCEL":
        - id: confirm_cancellation
          type: io.kestra.plugin.core.flow.Pause
          description: >-
            Cancelling ends the instance where it stands. Its variables go, its
            token position goes, whatever the process was doing in the real
            world is abandoned. Read the candidate list in log_findings before
            answering. An instance whose job still has retries belongs in a
            retry, not here. The detector already refused those.
          onResume:
            - id: approved
              type: BOOL
              defaults: false
              description: Answer true to cancel the listed instances. Anything else,
                including resuming with no answer, cancels nothing.

        - id: check_approval
          type: io.kestra.plugin.core.flow.If
          description: An unanswered Pause leaves approved null, which is why the
            condition defaults it to false rather than testing whether onResume
            is defined.
          condition: "{{ outputs.confirm_cancellation.onResume.approved ?? false }}"
          then:
            - id: cancel_stuck_instances
              type: io.kestra.plugin.core.flow.Loop
              description: >-
                One CancelProcessInstance per approved key. concurrencyLimit 1
                because these are writes against the same engine. allowFailure
                is on deliberately: Camunda refuses to cancel an instance that a
                call activity created. One refusal must not stop the re-read
                below from reporting the truth about the rest.
              concurrencyLimit: 1
              values: "{{ outputs.classify_findings.values.result | jq('.keys | tojson') |
                first }}"
              tasks:
                - id: cancel_one_instance
                  type: io.kestra.plugin.camunda.CancelProcessInstance
                  description: Terminates one process instance by key through the typed Camunda
                    plugin.
                  allowFailure: true
                  restAddress: "{{ inputs.camunda_rest_address }}"
                  processInstanceKey: "{{ item.value }}"

            - id: settle_secondary_storage
              type: io.kestra.plugin.core.flow.Sleep
              description: Camunda's v2 search API reads secondary storage, which an exporter
                fills asynchronously. Reading it the instant a command returns
                can still show the pre-cancel world, so the re-verify waits
                first.
              duration: PT6S

            - id: reverify_cancelled_keys
              type: io.kestra.plugin.core.http.Request
              description: Ask the engine which of the approved keys are STILL ACTIVE. This
                read, not the cancel task going green, is what decides whether
                the run succeeded.
              uri: "{{ inputs.camunda_rest_address }}/v2/process-instances/search"
              method: POST
              contentType: application/json
              body: |
                {
                  "filter": {
                    "state": "ACTIVE",
                    "processInstanceKey": {"$in": {{ outputs.classify_findings.values.result | jq('.keys | tojson') | first }} }
                  },
                  "page": {"limit": 1000}
                }

            - id: read_active_after
              type: io.kestra.plugin.core.http.Request
              description: Cluster-wide ACTIVE count after the cancellations, for the audit
                line to sit beside read_active_before.
              uri: "{{ inputs.camunda_rest_address }}/v2/process-instances/search"
              method: POST
              contentType: application/json
              body: |
                {
                  "filter": {"state": "ACTIVE"},
                  "page": {"limit": 1}
                }

            - id: guard_reverify
              type: io.kestra.plugin.core.flow.If
              description: >-
                A cancel command Camunda refused still leaves the task green
                under allowFailure, so the only trustworthy signal is this
                count. Anything but zero fails the run.
              condition: "{{ (outputs.reverify_cancelled_keys.body | jq('.page.totalItems') |
                first) != 0 }}"
              then:
                - id: fail_reverify
                  type: io.kestra.plugin.core.execution.Fail
                  errorMessage: >-
                    Re-verify failed. {{ outputs.reverify_cancelled_keys.body |
                    jq('.page.totalItems') | first }} of {{
                    outputs.classify_findings.values.result | jq('.count') |
                    first }} approved instance(s) are still ACTIVE after
                    CancelProcessInstance returned: {{
                    outputs.reverify_cancelled_keys.body | jq('[.items[] |
                    ((.processInstanceKey | tostring) + " (" +
                    (.processDefinitionId | tostring) + ", parent=" +
                    ((.parentProcessInstanceKey | tostring) // "none") + ")")] |
                    join(", ")') | first }}. Camunda refuses to cancel an
                    instance a call activity created, cancel the root instance
                    instead.
              else:
                - id: log_cancellation_verified
                  type: io.kestra.plugin.core.log.Log
                  message: >-
                    Cancelled and verified {{
                    outputs.classify_findings.values.result | jq('.count') |
                    first }} instance(s). None of the approved keys is ACTIVE
                    any more. Cluster ACTIVE instances {{
                    outputs.read_active_before.body | jq('.page.totalItems') |
                    first }} before, {{ outputs.read_active_after.body |
                    jq('.page.totalItems') | first }} after. Keys: {{
                    outputs.classify_findings.values.result | jq('.keys |
                    join(", ")') | first }}

          else:
            - id: log_cancellation_declined
              type: io.kestra.plugin.core.log.Log
              message: "Cancellation declined at the approval gate. {{
                outputs.classify_findings.values.result | jq('.count') | first
                }} instance(s) left exactly as they were: {{
                outputs.classify_findings.values.result | jq('.detail') | first
                }}"

    defaults:
      - id: fail_unreadable_detector
        type: io.kestra.plugin.core.execution.Fail
        errorMessage: "The detector produced no readable decision, so this run cannot
          tell a clean cluster from a stuck one. Raw result: {{
          outputs.classify_findings.values.result }}"

  - id: log_audit_complete
    type: io.kestra.plugin.core.log.Log
    description: Runs on every path so the execution history doubles as a record of
      how many instances were parked on an incident over time.
    message: "Stuck instance guard complete. decision={{
      outputs.classify_findings.values.result | jq('.decision') | first }}
      cancellable={{ outputs.classify_findings.values.result | jq('.count') |
      first }} grace_minutes={{ inputs.grace_minutes }} ceiling={{
      inputs.max_cancellations }} auto_remediate={{ inputs.auto_remediate }}
      dry_run={{ inputs.dry_run }} allowlist={{
      inputs.allowed_process_definition_ids }}"

errors:
  - id: alert_guard_failure
    type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
    description: Fires when the run itself fails, which includes the re-verify
      refusing to accept a cancellation that did not land. A failed sweep must
      never read as a clean cluster.
    url: "{{ secret('SLACK_WEBHOOK_URL') }}"
    payload: |
      {
        "text": "Camunda stuck instance guard FAILED in execution {{ execution.id }} against {{ inputs.camunda_rest_address }}. Either the cluster could not be read or an approved cancellation did not land and the re-verify refused it. Check the execution before assuming no instance is parked on an incident."
      }

Safety

Cancelling a process instance is destructive in a way that deleting a stale row is not. The instance loses its variables, it loses its token position, it never reaches an end event, so whatever real-world process it represented is abandoned. Nothing brings it back. An incident with retries left should be retried, not cancelled, which is why this flow reads the job's live retry count and refuses any instance that still has one.

Four controls stand between a finding and a cancellation, each one checkable on its own:

a grace window, so an incident someone is working on right now is not a candidate;
a process definition allowlist, so only definitions somebody approved can ever be cancelled;
a per-run ceiling, so a spike cancels nothing at all and alerts instead;
retries at exactly 0, read from the job rather than inferred from the incident.

Then auto_remediate and dry_run and the Pause must all agree. A re-read of the engine decides whether the run passed.

How it works

A Camunda 8 job that burns every retry raises a JOB_NO_RETRIES incident. The instance stops there. Nothing retries it, because there are no retries left. Nothing alerts, because the cluster is healthy. The instance keeps its job, its variables and its row in the runtime tables. The definition it references cannot be cleanly retired while instances still point at it. Teams find hundreds of these months later.

read_stuck_incidents (io.kestra.plugin.core.http.Request) posts to /v2/incidents/search for state: ACTIVE, errorType: JOB_NO_RETRIES, a processDefinitionId $in the allowlist and a creationTime $lt the grace cutoff. Both the grace window and the allowlist are server-side filters, so neither depends on this flow filtering correctly afterwards.
read_exhausted_jobs posts to /v2/jobs/search for state: FAILED with retries: 0. This read is the point of the flow. An incident's errorType records why it was raised, not what the job looks like now, so a job whose retries were pushed back up keeps an open JOB_NO_RETRIES incident while it is perfectly retryable.
read_active_before records the cluster-wide ACTIVE instance count before anything changes.
classify_findings (io.kestra.plugin.core.output.OutputValues) intersects the two reads on processInstanceKey in one jq program and picks a single decision: NO_FINDINGS, OVER_CEILING, REPORT_ONLY or CANCEL. Every number stays inside that one program, so no count is retyped between tasks.
log_findings prints the detector's own numbers, so the execution list shows what the run saw.
route_decision (io.kestra.plugin.core.flow.Switch) takes one branch per decision. Its defaults branch fails the run, because a jq program that errors yields nothing, which would otherwise read as a clean cluster.
On CANCEL, confirm_cancellation (io.kestra.plugin.core.flow.Pause) holds the run until a human answers approved. The condition reads approved ?? false, so resuming with no answer cancels nothing.
cancel_stuck_instances (io.kestra.plugin.core.flow.Loop, concurrencyLimit: 1) runs io.kestra.plugin.camunda.CancelProcessInstance once per approved key.
settle_secondary_storage waits, then reverify_cancelled_keys asks the engine which approved keys are still ACTIVE. guard_reverify fails the run on anything but zero. A cancel command Camunda refused still leaves its task green, so this count is the only trustworthy signal.
The errors block alerts Slack whenever the run fails, which includes a refused cancellation caught by the re-verify.

What you get

A detector for a failure mode no Camunda dashboard raises, because the cluster really is healthy: the instance is simply parked forever.
Live retry state read from the job, not inferred from the incident, so an instance that should be retried is refused instead of destroyed.
Four independent controls (grace window, definition allowlist, per-run ceiling, retries at 0) plus auto_remediate, dry_run and a Pause in front of one destructive command.
A re-read of the engine that fails the run when a cancellation did not land, which is what catches Camunda refusing to cancel an instance a call activity created.
A per-run audit line, so the execution history becomes the record of how many instances were parked on an incident over time.

Who it's for

Platform teams running Camunda 8 who need stuck instances found before a definition cleanup or a cluster migration trips over them.
Operations teams who want cancellation to be an approved, auditable act rather than a click in Operate.
Anyone who has tried to retire a BPMN definition and discovered that instances nobody owns still reference it.

Why orchestrate this with Kestra

Camunda Operate can list incidents and cancel an instance, one click at a time, with no record of who decided what. The decision here is the hard part, not the command. Kestra supplies the cadence, joins the incident read to the live job read so retryable instances are excluded, holds the allowlist and the ceiling as inputs an operator can review, parks the destructive step on an approval gate, then fails the run when the engine says a cancellation did not land. The execution history is the audit trail.

Tested end to end

Built and run against a real single-node Camunda 8.9.19 Orchestration Cluster with RDBMS secondary storage. Four BPMN definitions were deployed, then instances were seeded through Camunda's own REST API into these states: a job failed with retries: 0 to raise a real JOB_NO_RETRIES incident, the same state with the job's retries pushed back up to 2, an identical incident on a definition outside the allowlist, a healthy ACTIVE instance with no incident, then a child instance created by a call activity.

Every path was run for real. A clean cluster returned zero findings. With three active incidents on the cluster the detector reported exactly one cancellable instance, refusing the retries-remaining instance and the non-allowlisted one. Raising the grace window to 60 minutes returned zero findings from the same cluster state. dry_run: true named the candidate without touching it. An approved run cancelled it, the re-verify confirmed the key was gone. The untouched controls were still ACTIVE in Camunda's own API. A declined Pause cancelled nothing. A finding count over the ceiling cancelled nothing and alerted. The call-activity child reproduced a real refused cancellation: the plugin task went green, the re-verify found the instance still ACTIVE, the run failed, the Slack errors block fired.

Prerequisites

Secrets

SLACK_WEBHOOK_URL: Slack incoming webhook for the failure alert and the ceiling alert.
Add CAMUNDA_USERNAME and CAMUNDA_PASSWORD to the CancelProcessInstance task if your cluster has API protection enabled. The v2 search reads then need an Authorization header on the Request tasks.

Inputs

camunda_rest_address: base URL of the Camunda 8 Orchestration Cluster REST API.
allowed_process_definition_ids: JSON array of BPMN process IDs whose instances may be cancelled.
grace_minutes: how long an incident must have been open to count. Default 120.
max_cancellations: per-run ceiling. Above it the run cancels nothing and alerts. Default 5.
auto_remediate: "false" by default. Must be "true" for any cancellation.
dry_run: "true" by default. Must be "false" for any cancellation.

The cluster needs secondary storage (Elasticsearch, OpenSearch or RDBMS) because the v2 search endpoints read from it. A broker started with CAMUNDA_DATA_SECONDARYSTORAGE_TYPE: none serves the commands but not the searches.

Quick start

Add the SLACK_WEBHOOK_URL secret.
Run with the defaults. auto_remediate: "false" and dry_run: "true" make it read-only, so the first run only tells you how many instances are parked.
Read log_findings. It prints the candidate keys, their definitions, their incident keys and how long each incident has been open.
Put only the definitions you are willing to abandon into allowed_process_definition_ids.
To cancel, run with auto_remediate: "true" and dry_run: "false", then answer approved: true on the Pause. Answer anything else to walk away.
Enable hourly_stuck_instance_sweep once a manual run looks right. The trigger forces report-only mode on its own inputs.

How to extend

Resolve instead of cancel. Swap the Loop body for a POST /v2/incidents/{incidentKey}/resolution request to retry the job, then keep the same re-verify shape for instances that genuinely deserve a retry.
Cancel the root instead of the child. Group findings by parentProcessInstanceKey and cancel the root once, which is what Camunda asks for when a call activity created the instance.
Capture the variables first. Add a /v2/process-instances/{key}/variables/search read before the Loop and archive the result, so a cancelled instance leaves a record of what it was carrying.
Widen the detector. Drop the errorType filter to catch UNHANDLED_ERROR_EVENT and CALLED_ELEMENT_ERROR incidents, which park an instance just as hard.
Narrow the window. Add a MULTISELECT of error messages so only known-unrecoverable failures qualify.

Cancel Camunda Process Instances Stuck on an Unresolvable Incident

Safety

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Tested end to end

Prerequisites

Secrets

Inputs

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

New to Kestra?

Cancel Camunda Process Instances Stuck on an Unresolvable Incident

Safety

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Tested end to end

Prerequisites

Secrets

Inputs

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

More Infrastructure Blueprints

Couchbase TTL expiry triage sentinel

Cancel runaway Couchbase N1QL queries that starve the query service

Apache CouchDB Database Compaction and Conflict Resolution Gate

Create Jira Issues Automatically for Incident Management

Create HubSpot Tickets Automatically for Incident Management

CrateDB Shard Allocation and Cluster Reroute Sentinel

New to Kestra?