AWS DevOps Agent のインシデント調査に Lambda durable functions で時間の上限を設けてみた

AWS DevOps Agent のインシデント調査に Lambda durable functions で時間の上限を設けてみた

Lambda durable functions の関数 1 個で、調査の開始から上限時間を過ぎた調査の取り消しまでを行えました。
2026.11.17

こんにちは、製造ビジネステクノロジー部 モビリティチーム の若槻です。

前回の記事では、AWS DevOps Agent のインシデント調査に時間の上限を設けるため、CloudWatch アラームをきっかけに Step Functions から調査を開始し、上限時間を過ぎても終わっていない調査を取り消す、サーキットブレーカーの仕組みを作りました。この構成では、待機と判定をステートマシンの定義(JSONata)で書き、DevOps Agent の API は Step Functions の AWS SDK 統合で呼び出しました。

同様の仕組みは、Lambda durable functions でも作ることができます。durable functions では、処理の途中で待機している間は関数が停止するため、待機している時間には Lambda の実行時間の課金がされません。そこで今回は、同じ仕組みを、ステートマシンの代わりに durable functions の関数 1 個で作ってみました。

構成

CloudWatch アラーム(ALARM に変化)
  → EventBridge ルール(CloudWatch Alarm State Change)
  → durable function(エイリアス live)
      1. step: 調査を開始する(CreateBacklogTask)
      2. waitForCondition: 10 秒ごとに調査の状態を確認する(GetBacklogTask)
           - 調査が終わっていれば終了する
           - IN_PROGRESS になってから上限時間を過ぎていれば 3 へ
      3. step: 調査を取り消す(UpdateBacklogTask で CANCELED を指定)

前回の記事のステートマシンで行っていた待機と判定を、関数の中のコードで行います。

durable functions では、待機した後に処理を再開するとき、関数が先頭から実行し直され(replay)、完了済みの step は記録された結果が使われます。step の外で Date.now() を呼ぶと、実行し直すたびに値が変わってしまうため、時刻の取得は waitForCondition の確認処理の中で行い、その結果として記録するようにしました。

実装

AWS CDK で実装しました。Agent Space と障害を起こす Lambda 関数は前回の記事と同じものを使い、障害を起こす関数の名前だけを変えています。

スタック

lib/devops-agent-durable-timeout-verification-stack.ts
import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";

import { AppParameter } from "../bin/parameter";
import { DurableInvestigationTimeoutConstruct } from "./constructs/devops-agent-timeout-verification/durable-investigation-timeout";
import { SlowTaskFunctionConstruct } from "./constructs/devops-agent-timeout-verification/slow-task-function";

/**
 * DevOps Agent の調査時間の上限の検証用スタック(Lambda durable functions 版)
 *
 * 意図的にタイムアウトする Lambda 関数のエラーアラームをきっかけに、durable function から
 * DevOps Agent の調査を開始する。上限の時間を過ぎても調査が終わっていなければ取り消す。
 */
export class DevOpsAgentDurableTimeoutVerificationStack extends cdk.Stack {
  constructor(
    scope: Construct,
    id: string,
    props: AppParameter & cdk.StackProps,
  ) {
    super(scope, id, props);

    const { agentSpaceId, timeoutSeconds, pollIntervalSeconds } =
      props.devOpsAgentTimeoutVerification;

    // 意図的にタイムアウトする Lambda 関数とエラーアラームを作成
    const slowTaskFunction = new SlowTaskFunctionConstruct(
      this,
      "SlowTaskFunction",
      { functionName: "devops-agent-durable-timeout-verification-slow-task" },
    );

    // アラームをきっかけに調査を開始し、上限の時間を過ぎたら取り消す
    new DurableInvestigationTimeoutConstruct(
      this,
      "DurableInvestigationTimeout",
      {
        agentSpaceId,
        alarm: slowTaskFunction.alarm,
        timeoutSeconds,
        pollIntervalSeconds,
      },
    );
  }
}

上限時間(timeoutSeconds)は 60 秒、状態を確認する間隔(pollIntervalSeconds)は 10 秒で検証しました。前回の記事の Step Functions 版では、確認の間隔を 1 分にしています。

durable function

durableConfig を指定すると、durable function として作成されます。durableConfig では、次の 2 項目を指定します。

  • executionTimeout:待機している時間を含む、durable execution 全体の実行時間の上限です。この時間を過ぎると、Lambda は実行を停止します。1 秒から 366 日の範囲で指定できます。今回は、調査の状態が変わらないまま確認を続けてしまう場合に備えて 3 時間にしました。前回の記事の Step Functions 版で、ステートマシンに指定した timeout と同じ役割です
  • retentionPeriod:実行が終了した後に、実行の履歴(イベント履歴や step の結果)を保持する日数です。1 日から 90 日の範囲で指定でき、省略すると 14 日になります。保持している履歴のデータ量も課金の対象になるため、検証用の今回は 1 日にしました

なお、関数の timeout は 1 回の呼び出し(待機の後の再開を含む)の上限で、executionTimeout とは別のものです。待機している間は関数が動いていないため、待機の時間は timeout に含まれません。

durable functions のチェックポイントの記録に必要な権限は、durableConfig を指定すると、AWS CDK がマネージドポリシー AWSLambdaBasicDurableExecutionRolePolicy を実行ロールに自動で追加します。

durable function は、バージョンかエイリアスを指定して呼び出す必要があります。そのため、currentVersion を指すエイリアス live を作成し、EventBridge ルールのターゲットにはエイリアスを指定しました。

lib/constructs/devops-agent-timeout-verification/durable-investigation-timeout/index.ts
import * as cdk from "aws-cdk-lib";
import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
import * as events from "aws-cdk-lib/aws-events";
import * as targets from "aws-cdk-lib/aws-events-targets";
import * as iam from "aws-cdk-lib/aws-iam";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as nodejs from "aws-cdk-lib/aws-lambda-nodejs";
import * as logs from "aws-cdk-lib/aws-logs";
import { Construct } from "constructs";

export interface DurableInvestigationTimeoutConstructProps {
  agentSpaceId: string; // 調査を開始する Agent Space の ID
  alarm: cloudwatch.IAlarm; // 調査のきっかけにするアラーム
  timeoutSeconds: number; // 調査が IN_PROGRESS になってから取り消すまでの秒数
  pollIntervalSeconds: number; // 調査の状態を確認する間隔(秒)
}

/**
 * 調査に時間の上限を設ける実装(Lambda durable functions 版)
 *
 * CloudWatch アラームをきっかけに durable function から DevOps Agent の調査を開始し、
 * 上限の時間を過ぎても調査が終わっていなければ取り消す。
 */
export class DurableInvestigationTimeoutConstruct extends Construct {
  public readonly function: nodejs.NodejsFunction;

  constructor(
    scope: Construct,
    id: string,
    props: DurableInvestigationTimeoutConstructProps,
  ) {
    super(scope, id);

    const { agentSpaceId, alarm, timeoutSeconds, pollIntervalSeconds } = props;
    const stack = cdk.Stack.of(this);

    this.function = new nodejs.NodejsFunction(this, "Function", {
      entry:
        "lib/constructs/devops-agent-timeout-verification/durable-investigation-timeout/function.ts",
      handler: "handler",
      runtime: lambda.Runtime.NODEJS_24_X,
      timeout: cdk.Duration.seconds(30), // 1 回の呼び出し(再開を含む)の上限
      durableConfig: {
        executionTimeout: cdk.Duration.hours(3), // 調査の状態が変わらない場合に備えた、実行全体の上限
        retentionPeriod: cdk.Duration.days(1),
      },
      logGroup: new logs.LogGroup(this, "FunctionLogGroup", {
        retention: logs.RetentionDays.ONE_WEEK,
        removalPolicy: cdk.RemovalPolicy.DESTROY, // 検証用のため、スタック削除時に削除する
      }),
      environment: {
        AGENT_SPACE_ID: agentSpaceId,
        POLL_INTERVAL_SECONDS: String(pollIntervalSeconds),
      },
      bundling: {
        // ランタイムに含まれる AWS SDK に DevOps Agent のクライアントが含まれるとは限らないため、
        // 関数のコードにバンドルする
        externalModules: [],
      },
    });
    this.function.addToRolePolicy(
      new iam.PolicyStatement({
        actions: [
          "aidevops:CreateBacklogTask",
          "aidevops:GetBacklogTask",
          "aidevops:UpdateBacklogTask",
        ],
        resources: [
          stack.formatArn({
            service: "aidevops",
            resource: "agentspace",
            resourceName: agentSpaceId,
          }),
        ],
      }),
    );

    /**
     * durable function はバージョンかエイリアスを指定して呼び出す必要があるため、エイリアスを作成する
     */
    const alias = new lambda.Alias(this, "Alias", {
      aliasName: "live",
      version: this.function.currentVersion,
    });

    /**
     * アラームが ALARM になったら durable function を呼び出す
     */
    new events.Rule(this, "AlarmRule", {
      eventPattern: {
        source: ["aws.cloudwatch"],
        detailType: ["CloudWatch Alarm State Change"],
        resources: [alarm.alarmArn],
        detail: {
          state: { value: ["ALARM"] },
        },
      },
      targets: [
        new targets.LambdaFunction(alias, {
          event: events.RuleTargetInput.fromObject({
            alarmName: events.EventField.fromPath("$.detail.alarmName"),
            reason: events.EventField.fromPath("$.detail.state.reason"),
            time: events.EventField.time,
            timeoutSeconds,
          }),
        }),
      ],
    });
  }
}

ハンドラー

AWS Durable Execution SDK for JavaScript(@aws/durable-execution-sdk-js)を使い、ハンドラーを withDurableExecution で囲みます。

一定間隔の確認には context.waitForCondition を使いました。第 2 引数の確認処理で調査の状態を取得し、waitStrategy で確認を続けるかどうかと、次の確認までの待機時間を返します。調査が終わっているか、IN_PROGRESS を初めて確認した時刻(startedAt)から上限時間を過ぎていれば、確認を終了します。

lib/constructs/devops-agent-timeout-verification/durable-investigation-timeout/function.ts
import {
  DurableContext,
  withDurableExecution,
} from "@aws/durable-execution-sdk-js";
import {
  ConflictException,
  CreateBacklogTaskCommand,
  DevOpsAgentClient,
  GetBacklogTaskCommand,
  UpdateBacklogTaskCommand,
} from "@aws-sdk/client-devops-agent";

const client = new DevOpsAgentClient({});
const agentSpaceId = process.env.AGENT_SPACE_ID!;
const pollIntervalSeconds = Number(process.env.POLL_INTERVAL_SECONDS);

/**
 * 調査が終わったとみなす状態
 *
 * PENDING_CUSTOMER_APPROVAL は緩和策の承認待ちで、根本原因の分析は終わっているため含める。
 */
const FINISHED_STATUSES = [
  "COMPLETED",
  "FAILED",
  "TIMED_OUT",
  "CANCELED",
  "SKIPPED",
  "LINKED",
  "PENDING_CUSTOMER_APPROVAL",
];

interface AlarmEvent {
  alarmName: string;
  reason: string;
  time: string;
  timeoutSeconds: number; // 調査が IN_PROGRESS になってから取り消すまでの秒数
}

interface PollState {
  status: string;
  startedAt: number | null; // IN_PROGRESS を初めて確認した時刻(ミリ秒)
  checkedAt: number; // 最後に状態を確認した時刻(ミリ秒)
}

/**
 * アラームをきっかけに DevOps Agent の調査を開始し、上限の時間を過ぎたら取り消すハンドラー
 *
 * 待っている間は関数が停止するため、実行時間の課金がない。
 * 再開時は先頭から処理がやり直され(replay)、完了済みの step は記録された結果が使われる。
 * そのため、時刻の取得は step(waitForCondition の確認処理)の中で行う。
 */
const durableHandler = async (event: AlarmEvent, context: DurableContext) => {
  // 調査を開始する
  const taskId = await context.step("create-investigation", async () => {
    const { task } = await client.send(
      new CreateBacklogTaskCommand({
        agentSpaceId,
        taskType: "INVESTIGATION",
        priority: "HIGH",
        title: `CloudWatch アラーム ${event.alarmName}`,
        description: `CloudWatch アラーム ${event.alarmName} が ${event.time} に ALARM になりました。理由: ${event.reason} 原因を調査してください。`,
      }),
    );
    return task!.taskId!;
  });

  // 調査が終わるか、上限の時間を過ぎるまで、一定間隔で状態を確認する
  const finalState = await context.waitForCondition<PollState>(
    "wait-for-investigation",
    async (state) => {
      const { task } = await client.send(
        new GetBacklogTaskCommand({ agentSpaceId, taskId }),
      );
      const status = task!.status!;
      const now = Date.now();
      return {
        status,
        // PENDING_START の間は経過時間に数えない
        startedAt: state.startedAt ?? (status === "IN_PROGRESS" ? now : null),
        checkedAt: now,
      };
    },
    {
      initialState: { status: "PENDING_START", startedAt: null, checkedAt: 0 },
      waitStrategy: (state) => {
        const finished = FINISHED_STATUSES.includes(state.status);
        const timedOut =
          state.startedAt !== null &&
          (state.checkedAt - state.startedAt) / 1000 >= event.timeoutSeconds;
        return finished || timedOut
          ? { shouldContinue: false }
          : { shouldContinue: true, delay: { seconds: pollIntervalSeconds } };
      },
    },
  );

  if (FINISHED_STATUSES.includes(finalState.status)) {
    return { taskId, status: finalState.status };
  }

  // 上限の時間を過ぎたため、調査を取り消す
  return await context.step("cancel-investigation", async () => {
    try {
      const { task } = await client.send(
        new UpdateBacklogTaskCommand({
          agentSpaceId,
          taskId,
          taskStatus: "CANCELED",
        }),
      );
      return { canceled: true, taskId, status: task?.status };
    } catch (error) {
      // 判定から取り消しまでの間に調査が完了した場合は ConflictException になる
      if (error instanceof ConflictException) {
        return { canceled: false, taskId, reason: error.message };
      }
      throw error;
    }
  });
};

export const handler = withDurableExecution(durableHandler);

動作確認

上限時間を超過した調査

上限時間を過ぎても調査が終わっていない場合に、調査が取り消されることを確認しました。デプロイ後に、障害を起こす Lambda 関数を 3 回実行しました。アラームが ALARM になると、durable function の実行(durable execution)が始まりました。

Lambda コンソールでは、関数の「永続実行」タブに実行の一覧が表示されます。


Lambda コンソールの永続実行の一覧

AWS CLI では、list-durable-executions-by-function で実行の一覧を確認できます。関数名にはエイリアスを付けずに指定します。エイリアスを付けた場合や --qualifier でエイリアスを指定した場合は、エラーになりました。

aws lambda list-durable-executions-by-function \
  --region ap-northeast-1 \
  --function-name <FUNCTION_NAME>
{
    "DurableExecutions": [
        {
            "DurableExecutionArn": "arn:aws:lambda:ap-northeast-1:<ACCOUNT_ID>:function:<FUNCTION_NAME>:1/durable-execution/<EXECUTION_NAME>/<EXECUTION_ID>",
            "DurableExecutionName": "<EXECUTION_NAME>",
            "FunctionArn": "arn:aws:lambda:ap-northeast-1:<ACCOUNT_ID>:function:<FUNCTION_NAME>:1",
            "Status": "SUCCEEDED",
            "StartTimestamp": "2026-11-17T15:41:58.084000+09:00",
            "EndTimestamp": "2026-11-17T15:43:33.713000+09:00"
        }
    ]
}

実行の履歴は、コンソールの実行の詳細画面の「イベント履歴」に表示されます。StepStarted・StepSucceeded・InvocationCompleted のイベントが、確認の間隔の 10 秒ごとに記録されていました。


永続実行のイベント履歴(開始から IN_PROGRESS を確認するまで)

最後の確認で上限を超えたと判定されると、続けて cancel-investigation の step が実行され、実行が終了しました。


永続実行のイベント履歴(最後の確認から取り消しまで)

AWS CLI では、get-durable-execution-history で実行の履歴を確認できます。

aws lambda get-durable-execution-history \
  --region ap-northeast-1 \
  --durable-execution-arn <DURABLE_EXECUTION_ARN> \
  --include-execution-data

履歴から、step の結果と関数の呼び出しを時系列で並べると次のようになりました。

時刻 処理 結果
15:42:00 create-investigation 調査を作成
15:42:01 wait-for-investigation(1 回目) PENDING_START
15:42:11〜15:42:21 wait-for-investigation(2〜3 回目) PENDING_START
15:42:31 wait-for-investigation(4 回目) IN_PROGRESS(startedAt に記録)
15:42:42〜15:43:23 wait-for-investigation(5〜9 回目) IN_PROGRESS
15:43:33 wait-for-investigation(10 回目) IN_PROGRESS(上限を超えたため確認を終了)
15:43:33 cancel-investigation CANCELED

IN_PROGRESS を初めて確認した 15:42:31 から 61 秒後の 15:43:33 に、調査が取り消されました。想定どおりの動作です。

コンソールの実行の詳細画面では、永続オペレーションの一覧に 3 個の処理が表示されました。wait-for-investigation のタイムラインには 10 回の確認が並び、出力には最後に確認した状態が表示されています。


永続オペレーションの一覧と wait-for-investigation の出力

waitForCondition の確認処理は 1 回ごとに結果が記録され、履歴には次のように記録されていました。NextAttemptDelaySeconds が、waitStrategy で返した待機時間です。

{
    "EventType": "StepSucceeded",
    "Name": "wait-for-investigation",
    "StepSucceededDetails": {
        "Result": {
            "Payload": "{\"status\":\"IN_PROGRESS\",\"startedAt\":1794897751967,\"checkedAt\":1794897751967}",
            "Truncated": false
        },
        "RetryDetails": {
            "CurrentAttempt": 4,
            "NextAttemptDelaySeconds": 10
        }
    }
}

実行の結果は次のとおりです。

{"canceled":true,"taskId":"<TASK_ID>","status":"CANCELED"}

get-backlog-task で確認した調査のステータスは CANCELED、metadata.canceledReason は USER_CANCELED で、前回の記事の Step Functions から取り消した場合と同じでした。

上限時間内に完了した調査

上限時間内に調査が終わった場合に、調査が取り消されずに処理が終了することを確認しました。timeoutSeconds を 600 にして、durable function を非同期で呼び出しました。

aws lambda invoke \
  --region ap-northeast-1 \
  --function-name <FUNCTION_NAME> \
  --qualifier live \
  --invocation-type Event \
  --durable-execution-name long-timeout-1 \
  --cli-binary-format raw-in-base64-out \
  --payload file://input.json \
  /dev/null

なお、--qualifier を使わずに --function-name <FUNCTION_NAME>:live と指定した場合は、Function not found のエラーになりました。エラーメッセージの関数名が小文字に変わっていたため、AWS CLI が関数名を正しく扱えていない可能性があります。

調査は 15:44:36 に IN_PROGRESS になり、15:48:11 に COMPLETED になりました。想定どおり取り消しは行われず、実行は次の結果で終了しました。

{"taskId":"<TASK_ID>","status":"COMPLETED"}

コンソールの実行の詳細画面では、永続オペレーションは create-investigation と wait-for-investigation の 2 個だけで、cancel-investigation は実行されていませんでした。wait-for-investigation の出力には、最後に確認した状態 COMPLETED が表示されています。


上限時間内に調査が完了した実行の永続オペレーションと wait-for-investigation の出力

イベント履歴でも、最後の wait-for-investigation の確認の後に、cancel-investigation の step を挟まずに実行が終了していました。


上限時間内に調査が完了した実行のイベント履歴(最後の確認から終了まで)

Step Functions 版との比較

前回の記事の Step Functions 版と、構成の違いを比べました。

項目 Step Functions 版 durable functions 版
作成するリソース ステートマシン Lambda 関数(エイリアス付き)
待機と判定の書き方 ステートマシンの定義(JSONata) 関数のコード(waitForCondition)
DevOps Agent の API の呼び出し AWS SDK 統合 関数の中で AWS SDK for JavaScript を使う
課金の対象 状態遷移 Lambda の実行時間、durable operation(step と待機)、記録したデータの量と保持期間
処理の流れの確認 コンソールのグラフと実行履歴 実行履歴(永続オペレーションの一覧)

確認の間隔が異なる(Step Functions 版は 1 分、durable functions 版は 10 秒)ため、呼び出し回数や料金の数値は比べていません。durable functions 版では、取り消しまでの約 1 分半の実行で関数が 10 回呼び出され、課金の対象になる Lambda の実行時間は合計 5.4 秒でした。このうち 3.1 秒は 1 回目の呼び出しで、2 回目以降は 1 回あたり 0.2〜0.5 秒でした。確認と確認の間は関数が停止しているため、調査が長く続いても Lambda の実行時間はほとんど増えません。

料金はどちらも小さい額ですが、課金の対象の種類が異なります。運用する件数が多い場合は、それぞれの料金ページで試算する必要があります。

課金の対象になる調査の時間

CloudWatch の ConsumedInvestigationTime メトリクスで、上限 60 秒で取り消した調査の課金の対象になる時間を確認しました。

調査 IN_PROGRESS だった時間 ConsumedInvestigationTime
durable functions 版で取り消した調査 約 62〜72 秒(15:42:21〜15:42:31 のいずれかから 15:43:33 まで) 69 秒
Step Functions 版で取り消した調査(前回の記事、確認の間隔は 1 分) 約 61〜121 秒 110 秒

どちらの構成で取り消しても、課金の対象になる時間は IN_PROGRESS だった時間の範囲に収まっており、取り消した後は課金されていないと考えられます。確認の間隔が短いほど、上限を超えてから取り消すまでの時間が短くなり、課金の対象になる時間も上限時間に近くなります。

注意点

step の中での時刻の取得

前述のとおり、durable functions では、再開するたびに関数が先頭から実行し直されます。step の外で取得した時刻や乱数は実行し直すたびに変わるため、判定に使う値は step(今回は waitForCondition の確認処理)の中で取得し、結果として記録する必要があります。

スタック削除時の実行中の処理の待機

AWS CDK のドキュメントには、durable function を削除する場合は実行中の処理の終了を待ち、最大で 1 時間待つと記載されています。executionTimeout を長くしている場合は、実行中の処理がないことを確認してから削除する必要があります。

後片付け

検証用のスタックは cdk destroy で削除しました。

npx cdk destroy DevOpsAgentDurableTimeoutVerification --context environment=dev

おわりに

AWS DevOps Agent のインシデント調査に、Lambda durable functions で時間の上限を設けてみました。Step Functions 版と同じ動作を関数 1 個で実現でき、waitForCondition を使うと、一定間隔の確認と上限の判定を短いコードで書くことができました。

今回はサーキットブレーカーが作動したときに調査を取り消しましたが、取り消す代わりに Slack などへ通知したり、担当者へエスカレーションしたりして、調査を続けるかどうかを人が判断する構成も考えられます。その場合は、cancel-investigation の step を、通知を送る処理に置き換えることになります。

処理をコードで書きたい場合は durable functions、Lambda 関数のコードを持たずに定義だけで書きたい場合や、処理の流れをグラフで確認したい場合は Step Functions と使い分けることができます。

特に、調査の開始を自動化する際に、アラームの内容によって調査を開始するかどうかを判断するフィルター処理など、独自の処理を入れるために Lambda 関数を挟みたい場合は、durable functions を選択するとよいと考えられます。独自の処理と、調査の開始から取り消しまでの処理を、同じ関数のコードの中にまとめて書くことができます。

参考になれば幸いです。

参考

以上

この記事をシェアする

関連記事