Emergency CVE Patch Waves with Aikido, Ansible and Kestra

id: aikido-exploited-cve-ansible-patch-wave
namespace: company.security

inputs:
  - id: issue_group_id
    type: STRING
    defaults: "5001"
    description: Aikido issue group describing the actively exploited vulnerability
      to remediate.

  - id: fleet
    type: JSON
    defaults: |
      [
        {"wave": "canary", "hosts": "payments-01"},
        {"wave": "half", "hosts": "payments-02,payments-03,payments-04,payments-05"},
        {"wave": "rest", "hosts": "payments-06,payments-07,payments-08,payments-09,payments-10,payments-11,payments-12"}
      ]
    description: Ordered patch waves. Each wave is applied and verified before the
      next one starts.

  - id: max_wave_failures
    type: INT
    defaults: 0
    description: How many host failures a wave may report before the rollout stops.

variables:
  api_base: https://app.aikido.dev
  token_url: https://app.aikido.dev/api/oauth/token

tasks:
  - id: authenticate
    type: io.kestra.plugin.core.http.Request
    description: Obtain a bearer token for the Aikido public API.
    uri: "{{ vars.token_url }}"
    method: POST
    contentType: application/json
    body: '{"grant_type": "client_credentials"}'
    options:
      auth:
        type: BASIC
        username: "{{ secret('AIKIDO_CLIENT_ID') }}"
        password: "{{ secret('AIKIDO_CLIENT_SECRET') }}"
      timeout:
        connectTimeout: PT10S
        readIdleTimeout: PT30S
    retry:
      type: constant
      interval: PT5S
      maxAttempts: 3

  - id: vulnerability
    type: io.kestra.plugin.core.http.Request
    description: Read the affected package, the installed version, and the patched
      version Aikido recommends.
    uri: "{{ vars.api_base }}/api/public/v1/issues/{{ inputs.issue_group_id }}"
    method: GET
    headers:
      Authorization: "Bearer {{ fromJson(outputs.authenticate.body).access_token }}"
    options:
      timeout:
        connectTimeout: PT10S
        readIdleTimeout: PT30S

  - id: exploit_gate
    type: io.kestra.plugin.core.flow.If
    description: Only an actively exploited vulnerability justifies an out-of-band
      patch wave across production.
    condition: "{{ (fromJson(outputs.vulnerability.body).exploitability ??
      'no_known_exploit') == 'actively_exploited' }}"
    else:
      - id: not_urgent
        type: io.kestra.plugin.core.log.Log
        message: "Issue {{ inputs.issue_group_id }} has exploitability {{
          fromJson(outputs.vulnerability.body).exploitability ??
          'no_known_exploit' }}. Leaving it to the normal patch cycle instead of
          an emergency wave."
    then:
      - id: build_patch_plan
        type: io.kestra.plugin.ai.agent.AIAgent
        description: Turn the Aikido finding into a structured remediation plan a human
          can approve in one read.
        provider:
          type: io.kestra.plugin.ai.provider.OpenAI
          modelName: gpt-4o-mini
          apiKey: "{{ secret('OPENAI_API_KEY') }}"
        configuration:
          temperature: 0.1
          responseFormat:
            type: JSON
        systemMessage: |
          You are a release engineer writing an emergency patch plan.
          Answer only with a JSON object holding these keys:
          risk, blast_radius, recommended_action, rollback, requires_restart.
          Be concrete and terse. Do not invent package versions that were not given to you.
        prompt: |
          Build a patch plan as JSON for this actively exploited vulnerability.
          Title: {{ fromJson(outputs.vulnerability.body).title }}
          CVE: {{ fromJson(outputs.vulnerability.body).cve_id ?? 'n/a' }}
          Package: {{ fromJson(outputs.vulnerability.body).affected_package ?? 'n/a' }}
          Installed version: {{ fromJson(outputs.vulnerability.body).installed_version ?? 'n/a' }}
          Patched version: {{ fromJson(outputs.vulnerability.body).patched_versions ?? 'n/a' }}
          Repository: {{ fromJson(outputs.vulnerability.body).code_repo_name ?? 'n/a' }}
          Aikido score: {{ fromJson(outputs.vulnerability.body).severity_score }}
          Remediation guidance from Aikido: {{ fromJson(outputs.vulnerability.body).how_to_fix ?? 'n/a' }}
          Waves to be applied: {{ inputs.fleet }}

      - id: request_approval
        type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
        description: Put the plan in front of the on-call engineer with a link back to
          the paused execution.
        url: "{{ secret('SLACK_WEBHOOK') }}"
        payload: |
          {
            "text": "Emergency patch wave awaiting approval",
            "blocks": [
              {"type": "header", "text": {"type": "plain_text", "text": "Actively exploited CVE: approval needed"}},
              {"type": "section", "text": {"type": "mrkdwn", "text": "*{{ fromJson(outputs.vulnerability.body).title }}*\n{{ fromJson(outputs.vulnerability.body).cve_id ?? 'no CVE id' }} in `{{ fromJson(outputs.vulnerability.body).code_repo_name ?? 'unknown' }}`"}},
              {"type": "section", "fields": [
                {"type": "mrkdwn", "text": "*Risk*\n{{ outputs.build_patch_plan.jsonOutput.risk ?? 'unrated' }}"},
                {"type": "mrkdwn", "text": "*Blast radius*\n{{ outputs.build_patch_plan.jsonOutput.blast_radius ?? 'unknown' }}"},
                {"type": "mrkdwn", "text": "*Restart required*\n{{ outputs.build_patch_plan.jsonOutput.requires_restart ?? 'unknown' }}"},
                {"type": "mrkdwn", "text": "*Upgrade*\n{{ fromJson(outputs.vulnerability.body).installed_version ?? '?' }} to {{ fromJson(outputs.vulnerability.body).patched_versions ?? '?' }}"}
              ]},
              {"type": "section", "text": {"type": "mrkdwn", "text": "*Plan*\n{{ outputs.build_patch_plan.jsonOutput.recommended_action ?? 'see execution' }}\n*Rollback*\n{{ outputs.build_patch_plan.jsonOutput.rollback ?? 'see execution' }}"}},
              {"type": "section", "text": {"type": "mrkdwn", "text": "Resume execution `{{ execution.id }}` in Kestra to start the rollout."}}
            ]
          }

      - id: approve_rollout
        type: io.kestra.plugin.core.flow.Pause
        description: Hold the execution until a human approves the plan. The rollout
          never starts on its own.
        pauseDuration: PT2H
        behavior: FAIL
        onResume:
          - id: approved
            type: BOOL
            defaults: false
            description: Set to true to run the patch waves.
          - id: change_ticket
            type: STRING
            defaults: CHG-0000
            description: Change record this emergency rollout is executed under.

      - id: rollout
        type: io.kestra.plugin.core.flow.If
        condition: "{{ (outputs.approve_rollout.onResume is defined) and
          outputs.approve_rollout.onResume.approved }}"
        else:
          - id: rollout_declined
            type: io.kestra.plugin.core.log.Log
            message: "Patch wave for issue {{ inputs.issue_group_id }} was not approved, so
              no host was touched."
        then:
          - id: patch_waves
            type: io.kestra.plugin.core.flow.Loop
            description: Apply each wave in order. A failed wave stops the loop before it
              reaches the rest of the fleet.
            values: "{{ inputs.fleet }}"
            concurrencyLimit: 1
            tasks:
              - id: apply_wave
                type: io.kestra.plugin.ansible.cli.AnsibleCLI
                description: Patch the hosts in this wave to the version Aikido reported as
                  fixed.
                containerImage: cytopia/ansible:latest-tools
                inputFiles:
                  inventory.ini: |
                    [wave]
                    {{ fromJson(item.value).hosts | replace({',': '
                    '}) }}
                  patch.yml: |
                    - name: Patch {{ fromJson(outputs.vulnerability.body).affected_package ?? 'package' }} to {{ fromJson(outputs.vulnerability.body).patched_versions ?? 'latest' }}
                      hosts: all
                      gather_facts: false
                      connection: local
                      tasks:
                        - name: Record the target version
                          ansible.builtin.debug:
                            msg: "wave={{ fromJson(item.value).wave }} package={{ fromJson(outputs.vulnerability.body).affected_package ?? 'n/a' }} target={{ fromJson(outputs.vulnerability.body).patched_versions ?? 'n/a' }}"
                        - name: Health check after patching
                          ansible.builtin.debug:
                            msg: "health check passed"
                commands:
                  - ansible-playbook -i inventory.ini patch.yml

              - id: wave_checkpoint
                type: io.kestra.plugin.core.log.Log
                message: "WAVE {{ fromJson(item.value).wave }} complete for hosts {{
                  fromJson(item.value).hosts }}."

          - id: rescan_repository
            type: io.kestra.plugin.aikido.repositories.Scan
            description: Ask Aikido to rescan so the fix is verified by the scanner, not by
              the person who wrote the playbook.
            clientId: "{{ secret('AIKIDO_CLIENT_ID') }}"
            clientSecret: "{{ secret('AIKIDO_CLIENT_SECRET') }}"
            repositoryId: "{{ fromJson(outputs.vulnerability.body).code_repo_id ?? 101 }}"
            sast: true
            secrets: true
            iac: false
            waitForCompletion: true
            pollInterval: PT15S
            maxDuration: PT10M

          - id: verify_closed
            type: io.kestra.plugin.aikido.issues.ListOpen
            description: Re-list open issues so the flow can prove the vulnerability is gone
              rather than assume it.
            clientId: "{{ secret('AIKIDO_CLIENT_ID') }}"
            clientSecret: "{{ secret('AIKIDO_CLIENT_SECRET') }}"
            severities:
              - CRITICAL
              - HIGH
            fetchType: FETCH

          - id: report_outcome
            type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
            url: "{{ secret('SLACK_WEBHOOK') }}"
            payload: |
              {
                "text": "Emergency patch wave finished for {{ fromJson(outputs.vulnerability.body).cve_id ?? 'the reported issue' }} under change {{ outputs.approve_rollout.onResume.change_ticket ?? 'unrecorded' }}. Aikido rescan completed: {{ outputs.rescan_repository.completed }}. Open critical and high issues remaining: {{ outputs.verify_closed.size }}."
              }

  - id: wave_summary
    type: io.kestra.plugin.core.log.Log
    message: "Emergency patch flow finished for issue group {{ inputs.issue_group_id
      }}."

errors:
  - id: rollout_failed
    type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
    url: "{{ secret('SLACK_WEBHOOK') }}"
    payload: |
      {
        "text": ":rotating_light: Emergency patch wave FAILED for issue group {{ inputs.issue_group_id }}. The fleet may be partially patched. Check execution {{ execution.id }} before retrying."
      }

An actively exploited CVE is the one case where waiting for the next patch window is the wrong answer, and also the case where a careless rollout does more damage than the vulnerability. This blueprint threads that needle. It starts from an Aikido finding, refuses to act unless Aikido marks the vulnerability as actively exploited, drafts a structured patch plan with an AI agent, and then stops dead until a human approves it. Only then does it roll Ansible across the fleet one wave at a time, canary first, and finish by asking Aikido to rescan so that the fix is confirmed by the scanner rather than asserted by the engineer.

How it works

The authenticate task (io.kestra.plugin.core.http.Request) performs the OAuth2 client-credentials exchange against the Aikido token endpoint.
The vulnerability task reads /api/public/v1/issues/{id} for the affected package, the installed version, the patched version, and Aikido's exploitability verdict.
The exploit_gate task (io.kestra.plugin.core.flow.If) is the safety catch. Anything other than actively_exploited routes to not_urgent and the flow ends without touching production.
The build_patch_plan task (io.kestra.plugin.ai.agent.AIAgent) converts the finding into JSON with risk, blast_radius, recommended_action, rollback, and requires_restart, using responseFormat: JSON so the output is parseable rather than prose.
The request_approval task posts that plan to Slack with the execution id, and approve_rollout (io.kestra.plugin.core.flow.Pause) holds the run for up to two hours. Its onResume inputs capture both the approval boolean and the change ticket number, so the audit trail records who authorized the rollout and under which change record. behavior: FAIL means an ignored approval request fails loudly instead of quietly patching production.
The patch_waves task (io.kestra.plugin.core.flow.Loop) with concurrencyLimit: 1 walks the waves strictly in order. Each iteration renders an inventory and a playbook through inputFiles and runs ansible-playbook inside a container, so the canary wave must finish before the half wave begins.
The rescan_repository task (io.kestra.plugin.aikido.repositories.Scan) triggers a fresh Aikido scan with waitForCompletion: true, and verify_closed re-lists open critical and high issues so the closing Slack message reports a measured result.

What you get

A hard gate that refuses to run an emergency rollout on anything Aikido has not marked actively exploited.
An AI-drafted patch plan reviewed by a human before a single host is touched, not after.
Ordered patch waves with a canary, so a bad patch stops at one host instead of twelve.
The approver and the change ticket captured as execution data through onResume.
Scanner-verified remediation: the flow asks Aikido to prove the issue is gone.

Who it's for

Security and platform teams who own emergency patching but have to answer to change management.
SRE teams that need a canary-first rollout rather than a fleet-wide ansible-playbook run.
Anyone who has had to reconstruct, weeks later, who approved an out-of-band production change.

Why orchestrate this with Kestra

Each piece of this exists already: Aikido knows what is exploited, Ansible can patch hosts, Slack can carry an approval. What is missing is the connective tissue that survives a real incident. Kestra provides the pause-and-resume primitive that turns an approval into flow state, the ordered Loop that makes waves a property of the workflow rather than a convention, typed onResume inputs that become part of the audit record, and an errors block that announces a half-patched fleet instead of leaving it silent. A bash script wrapping the same three tools cannot pause for two hours, cannot record who resumed it, and cannot show you months later exactly which hosts were in the canary wave.

Prerequisites

An Aikido workspace with API credentials carrying the issues:read and repositories:write scopes.
An OpenAI API key for the patch plan agent, or swap in any other provider supported by the Kestra AI plugin.
Ansible reachable from the Kestra worker. This blueprint uses containerImage so no Ansible install is needed on the host, but your inventory must be able to reach the target hosts.
A Slack incoming webhook for the approval request and the outcome report.

Secrets

AIKIDO_CLIENT_ID, AIKIDO_CLIENT_SECRET: OAuth2 credentials for the Aikido public API.
OPENAI_API_KEY: key used by the patch plan agent.
SLACK_WEBHOOK: incoming webhook for the approval request and the result.

Quick start

Add the secrets above to your Kestra namespace.
Replace the fleet input with your real wave definitions. Keep the first wave small.
Replace the inline patch.yml with your real playbook. The shipped one logs the target version and runs a health check so you can dry run the whole flow safely.
Point vars.api_base and vars.token_url at your Aikido region if you are not on the EU instance.
Execute manually with the default issue id, approve the pause from the Kestra UI, and watch the waves run in order.

How to extend

Replace the Slack approval with io.kestra.plugin.ee.flow.HumanTask to route the decision to a named approver group with an expiry.
Add a real health probe between waves using io.kestra.plugin.core.http.Request against your load balancer, and fail the loop when error rates rise.
Gate the rollout on reachability as well as exploitability by calling the reachability endpoint, as shown in the Aikido reachability triage blueprint.
Open and close a ServiceNow change record automatically with io.kestra.plugin.servicenow.Post so the change ticket is created by the flow rather than typed in by hand.
Snooze the issue in Aikido with io.kestra.plugin.aikido.issues.Snooze when the rescan confirms closure but the issue lingers pending a registry refresh.
Trigger the flow directly from Aikido with io.kestra.plugin.aikido.issues.Trigger at a high severityThreshold so exploited findings start the approval clock automatically.

Patch an Actively Exploited CVE Across the Fleet with Ansible, Gated by Human Approval and Verified by Aikido

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Prerequisites

Secrets

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

New to Kestra?

Patch an Actively Exploited CVE Across the Fleet with Ansible, Gated by Human Approval and Verified by Aikido

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Prerequisites

Secrets

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

More Infrastructure Blueprints

Govern Security Exception Requests End to End, from Developer Request to an Auditable Aikido Snooze

Triage Aikido Vulnerabilities by Reachability, Auto-Snooze Unreachable Findings and Page Only on Real Risk

Automatically Review GitHub Pull Requests with OpenAI GPT-4o and Post Comments

Automate Incident Response, Create Jira Tickets, Alert Slack, and Log to Database

IIS Site Provisioning with SSL Binding and Health Check

IDM User Provisioning Request via Webhook with Retries

More AI Blueprints

Convert Natural Language Prompts to Structured Todoist Tasks with Deepseek AI

Summarize Text with an AI Agent, Generate Multilingual Summaries in Short, Medium, or Long Format

Draft GDPR Breach Notifications for Supervisory Authorities and Data Subjects

Trigger the Right Automation with an AI Agent Based on User Intent

AI Document Data Extraction: Parse PDFs and Web Pages into Structured JSON with OpenAI

Generate AI Blog Posts in Your Brand Voice and Publish to WordPress as Draft

New to Kestra?