> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> AWS EventBridge またはウェブフックを使用して Event Stream を作成する方法を説明します。

# Event Stream を作成する

イベントをサブスクライブし、Event Stream を使用して任意の送信先に配信することで、次のようなユースケースを実現できます。

* 新規顧客に歓迎メールを送信したり、メールアドレスの確認を依頼したりする。
* ユーザーのライフサイクルの変化を監視し、CRM (顧客関係管理) や請求システムを更新する。

AWS EventBridge またはウェブフックを使用して Event Stream を作成できます。以下のセクションでは、両方のオプションの設定手順を説明します。

<div id="access-management-api-optional">
  ## Management API へのアクセス (任意)
</div>

イベントストリームは、<Tooltip tip="Auth0 Dashboard: サービスを設定するための Auth0 の主要プロダクトです。" cta="用語集を見る" href="/ja/docs/glossary?term=Auth0+dashboard">Auth0 Dashboard</Tooltip> または [Auth0 Management API](https://auth0.com/docs/api/management/v2) を使用してプロビジョニングできます。<Tooltip tip="Management API: 顧客が管理タスクを実行できるようにするプロダクトです。" cta="用語集を見る" href="/ja/docs/glossary?term=Management+API">Management API</Tooltip> を使用する場合は、イベントストリームを設定する前に、マシンツーマシン (M2M) アプリケーションを作成し、Management API トークンで認証する必要があります。詳細については、[Management API Access Tokens](/ja/docs/secure/tokens/access-tokens/management-api-access-tokens) を参照してください。

1. [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) に移動し、**Create Application** を選択します。
2. アプリケーションにわかりやすい名前を入力し、**Machine to Machine Applications** を選択します。次に、**Create** を選択します。
3. アプリケーションから呼び出す API を選択します。この場合は、**Auth0 Management API** を使用します。
4. アプリケーションのアクセストークンに含めて発行する権限を選択し、**Authorize** を選択します。テスト目的では、次を選択します。

   * `read:event_streams`
   * `create:event_streams`
   * `update:event_streams`
   * `delete:event_streams`
   * `read:event_deliveries`
   * `update:event_deliveries`
   * `create:users`
5. **Settings** タブに移動して、**クライアントID**、**クライアントシークレット**、および **ドメイン** を控えます。
6. [Get Management API Access Tokens](/ja/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) を参照し、アクセストークンを取得して保存します。

<div id="aws-eventbridge">
  ## AWS EventBridge
</div>

以下では、AWS EventBridge を使用して Event Stream を作成し、有効化する方法について説明します。

<div id="eventbridge-prerequisites">
  ### EventBridge の前提条件
</div>

Event Stream で AWS EventBridge を使用するには、次のものが必要です。

* AWS アカウント

  * AWS アカウントには、EventBridge を使用するための権限が必要です。アカウントをお持ちでない場合は、[https://aws.amazon.com/eventbridge/](https://aws.amazon.com/eventbridge/) から登録してください。
* AWS IAM 権限
* AWS EventBridge イベントバス
* AWS アカウント ID とリージョン

<div id="create-an-event-stream-eventbridge">
  ### Event Stream (EventBridge) を作成する
</div>

<Tabs>
  <Tab title="Management API">
    Event Stream を使用すると、Auth0 テナント内のリアルタイムの変更を取得し、処理のために外部システムに送信できます。

    Event Stream を設定する前に、監視する [イベントタイプ](/ja/docs/customize/events/event-types) を特定する必要があります。次に、以下に示すように、AWS アカウント ID とリージョンを使用して Event Stream を設定します。

    この例では、Auth0 CLI を使用して `user.created` イベントをサブスクライブする Event Stream を作成します。このイベントは、テナントで新しいユーザーが登録されるたびにトリガーされます。

    ```bash wrap lines theme={null}
    auth0 events create --name ng-demo-eventbridge --type eventbridge --subscriptions "user.created" --configuration '{"aws_account_id":"<your-aws-account-id>","aws_region":"<your-aws-region>"}'
    ```

    成功した場合、この呼び出しはイベントストリームの `id` を含む次の JSON を返します。新しいイベントストリームはデフォルトで有効です。

    ```json lines theme={null}
    {
      "id": "est_8of6RXoM1997qikH7NS11h",
      "status": "enabled",
      "name": "ng-demo-eventbridge",
      "subscriptions": [
        {
          "event_type": "user.created"
        }
      ],
      "created_at": "2025-01-29T18:08:43.440Z",
      "updated_at": "2025-01-29T18:08:43.440Z",
      "destination": {
        "type": "eventbridge",
        "configuration": {
          "aws_account_id": "<your-aws-account-id>",
          "aws_region": "<your-aws-region>",
          "aws_partner_event_source": "default"
        }
      }
    }
    ```
  </Tab>

  <Tab title="ダッシュボード">
    Auth0 Dashboard で AWS EventBridge を使用して Event Stream を作成するには、次の手順に従います。

    1. **Auth0 Dashboard** > **Event Streams (Early)** に移動します。
    2. **+Create Event Stream** を選択します。
    3. ストリームタイプの一覧から **AWS EventBridge** を選択します。新しい EventBridge ストリームの設定フォームが開きます。
    4. **ストリームの詳細を設定:** 設定フォームで、次の情報を入力します。

       * **ストリーム名:**

         Event Stream がわかりやすい説明的な名前を入力します。これにより、Auth0 Dashboard 内で識別しやすくなります。
       * **AWS アカウント ID:**

         Auth0 イベントの送信先となる 12 桁の AWS アカウント ID を入力します。
       * **AWS リージョン:**

         EventBridge のイベントバスが配置されている AWS リージョンを選択します。
    5. **イベントタイプを選択:** **Select Event Types** セクションで、このストリームに含める Auth0 のイベントタイプを選択します。要件に応じて複数のイベントタイプを選択できます (例: `user.created`, `user.updated`, `user.deleted`) 。
    6. **変更を保存:** ストリーム名、AWS の詳細、および必要なイベントタイプを設定したら、**Save Changes** ボタンをクリックします。

    これで新しい Event Stream が作成され、Auth0 は選択したイベントタイプの発行を、指定した AWS EventBridge イベントバスに開始できます。Auth0 Dashboard の Event Streams (Early) ページで、Event Stream のステータスを確認および管理できます。
  </Tab>

  <Tab title="Terraform">
    <Note>
      Terraform を使い始める前に、以下を準備してください。

      * Terraform CLI をインストールする
      * Auth0 CLI をインストールし、`auth0 login` で認証する
      * EventBridge ストリームを設定するための AWS アカウント ID と AWS リージョンを用意する
    </Note>

    ### ファイル構成

    Terraform を使用して Event Stream をプロビジョニングするには、構成されたプロジェクトディレクトリが必要です。初めて設定する場合の構成例を以下に示します。

    ```bash theme={null}

    auth0-event-streams/
    ├── main.tf             # コア設定: プロバイダーと 'auth0_event_stream' リソースを定義します。
    ├── variables.tf        # 変数宣言: 'aws_account_id' や 'aws_region' などの入力変数を定義します。
    └── terraform.tfvars    # 変数の値: 実際の設定値（例: "123456789012"）を格納します。

    ```

    ### 変数を定義する

    `variables.tf` ファイルで、ストリーム構成に必要な入力変数を宣言します。

    ```bash theme={null}
    variable "aws_account_id" {
      description = "EventBridgeイベントバスが存在する12桁のAWSアカウントID。"
      type        = string
    }

    variable "aws_region" {
      description = "EventBridgeイベントバスのAWSリージョン（例：us-east-1）。"
      type        = string
    }
    ```

    ### 変数の値を設定する

    `terraform.tfvars` ファイルで、使用する環境に対応する実際の値を指定します。

    ```bash theme={null}
    aws_account_id = "<your-aws-account-id>" # 例: "123456789012"
    aws_region     = "<your-aws-region>"     # 例: "us-east-1"
    ```

    ### 環境変数を設定する

    ターミナルで、上記の「Access Management API (任意) 」でコピーした認証情報を使って、必要な3つの環境変数を設定します。

    ```bash theme={null}
    export AUTH0_DOMAIN="your-tenant-name.auth0.com"
    export AUTH0_CLIENT_ID="your_m2m_client_id"
    export AUTH0_CLIENT_SECRET="your_m2m_client_secret"
    ```

    ## Event Stream を作成する

    この例では、`auth0_event_stream` リソースを使用して、`user.created` イベントを購読する Event Stream を作成します。このイベントは、テナントで新しいユーザーが登録されるたびに発生します。次のサンプルを `main.tf` ファイルに使用してください。

    ```hcl theme={null}
    terraform {
      required_providers {
        auth0 = {
          source  = "auth0/auth0"
          version = ">= 1.0.0" 
        }
      }
    }

    provider "auth0" {}

    resource "auth0_event_stream" "eventbridge_stream" {
      name             = "ng-demo-eventbridge-tf"
      destination_type = "eventbridge" # 必須
      subscriptions    = ["user.created"]

      eventbridge_configuration {
        aws_account_id = var.aws_account_id
        aws_region     = var.aws_region
      }
    }
    ```

    正常に完了すると、この呼び出しはイベントストリームの `id` を含む次の JSON を返します。新しいイベントストリームはデフォルトで有効です。

    上記の 3 つのファイルをすべて作成して保存したら、ストリームを作成する準備は完了です。

    1. プロバイダーを初期化します

    ```bash theme={null}
    terraform init
    ```

    2. 変更内容を確認します。

    ```bash theme={null}
    terraform plan
    ```

    3. ストリームを作成します。

    ```bash theme={null}
    terraform apply
    ```
  </Tab>
</Tabs>

<div id="webhooks">
  ## Webhooks
</div>

AWS EventBridge の代替として、webhook を使用してEvent Streamを構成できます。

開始するには、まず特定のイベントが発生したときにリアルタイム通知を受信する webhook ハンドラーを設定します。次に、Event Streamを作成できます。

以下の手順に従って基本的な webhook ハンドラーを作成することも、次の既存サービスを使用することもできます。

* Vercel
* Inngest

既存のサービスを使用する場合は、[Event Streamを作成する (webhook) ](#create-an-event-stream-webhooks-) に進んでください。使用しない場合は、以下の手順に従って独自の基本的な webhook ハンドラーを作成してください。

<div id="webhook-prerequisites">
  ### Webhook の前提条件
</div>

Webhook ハンドラーを正しく作成するには、次のものがインストールされていることを確認してください。

* `node.js`
* `jq`
* `npm`
* `ngrok`

<div id="write-the-webhook-handler">
  ### Webhook ハンドラーを記述する
</div>

1. `express` を `node_modules` フォルダーにインストールし、`package.json` の依存関係に追加します。

2. 環境変数の保存に `.env` ファイルを使用できるよう、`dotenv` をルートディレクトリにインストールします。

3. `user.created` イベントを受信してデータベースに保存する `webhook.js` ファイルを作成します。

   ```javascript lines expandable theme={null}
   const express = require('express');
   const app = express();

   // 認可ミドルウェア
   app.use((req, res, next) => {
     const token = req.headers["authorization"];
     if (token !== `Bearer ${API_TOKEN}`) {
       return res.status(401).json({ error: "Unauthorized" });
     }
     next();
   });

   // Webhook エンドポイント
   app.post("/webhook", async (req, res) => {
     console.log("Webhook received:", JSON.stringify(req.body, null, 2));

     const eventData = req.body;
     const { id, type, time, data } = eventData;
     const user = data.object;

     try {
       switch (type) {
         case "user.created":
           await handleUserCreated(user, time);
           break;
         case "user.updated":
           await handleUserUpdated(user, time);
           break;
         case "user.deleted":
           await handleUserDeleted(user, time);
           break;
         default:
           await handleDefaultEvent(id, type, time, data);
       }

       console.log(`Webhook event of type '${type}' committed to the database.`);
       res.sendStatus(204);
     } catch (err) {
       console.error("Error processing webhook:", err);
       res.status(500).json({ error: "Internal server error" });
     }
   });

   // user created イベントを処理する専用関数
   // この例では、ユーザーが独自のデータベースにも作成されるようにしています
   async function handleUserCreated(user, time) {
     const { user_id, email, name, nickname, created_at, updated_at } = user;

     const query = `
       INSERT INTO users (user_id, email, name, nickname, created_at, updated_at, raw_user, last_event_processed)
       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
     `;
     const values = [
       user_id,
       email,
       name,
       nickname,
       created_at,
       updated_at,
       user,
       time,
     ];

     try {
       await getPool().query(query, values);
     } catch (err) {
       if (err.code === "23505") {
         console.error(`Duplicate user_id=${user_id}, skipping insert.`);
       } else {
         console.error(`Database error while creating user_id=${user_id}:`, err);
         throw err;
       }
     }
   }
   ```

4. プロジェクトのルートに `.env` ファイルを作成し、次のように API トークンを追加します。

   ```bash lines theme={null}
   API_TOKEN=`openssl rand -hex 32`
   echo "API_TOKEN=$API_TOKEN" > .env
   ```

5. サーバーを起動します。

   ```bash lines theme={null}
   node webhook.js
   ```

6. Webhook をテストするには、ngrok などのツールを使って Webhook ハンドラーを公開します。

   ```bash lines theme={null}
   ngrok http 3000
   ```

   これにより、ローカルの Webhook ハンドラー用の公開 URL が提供されます。たとえば、次のようになります。

   ```bash lines theme={null}
   http://localhost:3000
   ```

<div id="create-an-event-stream-webhooks">
  ### Event Streamを作成する (webhooks)
</div>

Event Streamを使用すると、Auth0テナント内のリアルタイムな変更を取得し、外部システムに送信して処理できます。

Event Streamを設定する前に、監視する[イベントタイプ](/ja/docs/customize/events/event-types)を特定する必要があります。次に、以下に示すように、webhookハンドラーを使用してEvent Streamを作成します。

<Tabs>
  <Tab title="Management API">
    この例では、Auth0 CLI を使用して、`user.created` イベントをサブスクライブする Event Stream を作成します。このイベントは、テナントで新しいユーザーが登録されるたびにトリガーされます。続いて、イベントデータは追加の処理のために Webhook エンドポイントへ転送されます。

    ```bash lines theme={null}
    source .env # .env ファイルを作成した webhook ディレクトリにいることを確認してください
    WEBHOOK_URL="<ngrok URL>/webhook"

    auth0 events create -n my-event1 -t webhook -s "user.created" -c '{"webhook_endpoint":"'"${WEBHOOK_URL}"'","webhook_authorization":{"method":"bearer","token":'"${API_TOKEN}"'"}}'
    ```

    成功した場合、イベントストリームの `id` を含む次の JSON が返されます。新しいイベントストリームはデフォルトで有効になります。

    ```hcl theme={null}
    {
      "id": "est_8of6RXoM1997qikH7NS11h",
      "status": "enabled",
      "name": "ng-demo-2",
      "subscriptions": [
        {
          "event_type": "user.created"
        }
      ],
      "created_at": "2025-01-29T18:08:43.440Z",
      "updated_at": "2025-01-29T18:08:43.440Z",
      "destination": {
        "type": "webhook",
        "configuration": {
          "webhook_endpoint": "https://example.com/webhook",
          "webhook_authorization": {
            "method": "bearer"
          }
        }
      }
    }
    ```

    #### Event Stream を確認する

    Event Stream を作成したら、次のコマンドを使用して Event Stream が存在することを確認できます。

    ```bash lines theme={null}
    auth0 events show <EVENT_STREAM_ID>
    ```
  </Tab>

  <Tab title="Dashboard">
    AWS EventBridge を使用して Auth0 Dashboard で Event Stream を作成するには、次の手順を実行します。

    1. **Auth0 Dashboard** > **Event Streams (Early)** に移動します。
    2. **+Create Event Stream** を選択します。
    3. ストリームタイプの一覧から **Webhook** を選択します。新しい Webhook ストリームの設定フォームが開きます。
    4. **ストリームの詳細を設定:** 設定フォームで、次の情報を入力します。

       * **ストリーム名:**

         Event Stream が識別しやすくなるよう、わかりやすい名前を入力します。これにより、Auth0 Dashboard 内で見分けやすくなります。
       * **エンドポイント:** Auth0 がイベントを送信する HTTP エンドポイントの完全な URL を入力します。これは、イベントデータを受信して処理するサービスです。
       * **認証方法:** エンドポイントで必要な認証方法を選択します。
       * **認可トークン:** 認証方法として **Bearer Token** を選択した場合は、必要な認可トークンをここに入力します。
    5. **イベントタイプを選択:** **イベントタイプを選択** セクションで、このストリームに含める Auth0 のイベントタイプを選択します。要件に応じて複数のイベントタイプを選択できます (例: `user.created`, `user.updated`, `user.deleted`) 。
    6. **変更を保存:** ストリーム名、AWS の詳細、および使用するイベントタイプの選択が完了したら、**変更を保存** ボタンをクリックします。

    これで新しい Event Stream が作成され、Auth0 は選択したイベントタイプを指定した Webhook に配信できるようになります。状態の監視や Event Stream の管理は、Auth0 Dashboard の Event Streams (Early) ページから行えます。
  </Tab>

  <Tab title="Terraform">
    ### ファイル構成

    Terraform を使用して Event Stream をプロビジョニングするには、適切に構成されたプロジェクトディレクトリが必要です。初めて設定する場合の構成例を以下に示します。

    ```bash theme={null}
    auth0-event-streams/
    ├── main.tf             # コア設定: プロバイダーと 'auth0_event_stream' リソースを定義します。
    ├── variables.tf        # 変数宣言: 'aws_account_id' や 'aws_region' などの入力変数を定義します。
    └── terraform.tfvars    # 変数の値: 実際の設定値を保持します（例: "123456789012"）。
    ```

    ### 変数を定義する

    `variables.tf` ファイルで、ストリーム構成に必要な入力変数を宣言します。

    ```bash theme={null}
    variable "api_token" {
      description = "The secret token used for Webhook Bearer Authorization."
      type        = string
      sensitive   = true 
    }

    variable "webhook_endpoint_url" {
      description = "The public HTTPS URL for the webhook handler (e.g., your ngrok URL)."
      type        = string
    }
    ```

    ### 環境設定

    上で生成したAPIトークンを使用し、`TF_VAR_` プレフィックスを付けて、ターミナルで環境変数を安全に設定してください。

    ```bash wrap lines theme={null}
    export AUTH0_DOMAIN="your-tenant-name.auth0.com"
    export AUTH0_CLIENT_ID="your_m2m_client_id"
    export AUTH0_CLIENT_SECRET="your_m2m_client_secret"
    ```

    成功すると、イベントストリームの `id` を含む次の JSON が返されます。新しいイベントストリームはデフォルトで有効化されます。

    ```bash theme={null}
    export TF_VAR_api_token="${API_TOKEN}"

    export AUTH0_DOMAIN="your-tenant-name.auth0.com"
    export AUTH0_CLIENT_ID="your_m2m_client_id"
    export AUTH0_CLIENT_SECRET="your_m2m_client_secret"
    ```

    ## Event Stream を作成する

    この例では、`auth0_event_stream` リソースを使用して、`user.created` イベントをサブスクライブする Event Stream を作成します。このイベントは、テナントで新しいユーザーが登録されるたびにトリガーされます。`main.tf` ファイルで次のサンプルを使用します。

    成功すると、この呼び出しは Event Stream の `id` を含む次の JSON を返します。新しい Event Stream はデフォルトで有効です。

    ```hcl theme={null}
    terraform {
      required_providers {
        auth0 = {
          source  = "auth0/auth0"
          version = ">= 1.0.0" 
        }
      }
    }

    provider "auth0" {}

    resource "auth0_event_stream" "webhook_stream" {
      name             = "my-webhook-handler-stream-tf"
      destination_type = "webhook" 
      subscriptions    = ["user.created"] 

      webhook_configuration {
        webhook_endpoint = var.webhook_endpoint_url

        webhook_authorization {
          method = "bearer"
          token  = var.api_token 
        }
      }
    }
    ```

    上記の 3 つのファイルをすべて作成して保存したら、ストリームを作成できます。

    1. プロバイダーを初期化する

    ```bash theme={null}
    terraform init
    ```

    2. プランを実行します:

    ```bash theme={null}
    URL="<your-ngrok-url>/webhook"
    terraform plan -var="webhook_endpoint_url=${URL}"
    ```

    3. ストリームを作成します。

    ```bash theme={null}
    terraform apply -var="webhook_endpoint_url=https://<your-ngrok-url>/webhook"
    ```
  </Tab>
</Tabs>

ストリームが有効になったら、Event Stream をテストできます。詳細については、[**イベントのテスト、可観測性、障害復旧**](/ja/docs/customize/events/event-testing-observability-and-failure-recovery)を参照してください。

<div id="auth0-actions">
  ## Auth0 Actions
</div>

以下では、Auth0 Actions を使用して Event Stream を作成して有効化する方法を説明します。

<div id="create-an-event-stream-actions">
  ### Event Streamを作成する (Actions)
</div>

<Tabs>
  <Tab title="Management API">
    Event Streamを使用すると、Auth0 テナント内のリアルタイムな変更を取得し、処理のために外部システムへ送信できます。

    Event Streamを設定する前に、監視する[イベントタイプ](/ja/docs/customize/events/event-types)を特定する必要があります。この例では Auth0 CLI を使用して、`user.created` イベントをサブスクライブするEvent Streamを作成します。このイベントは、テナントに新しいユーザーが登録されるたびにトリガーされます。

    ```bash wrap lines theme={null}
    auth0 event-streams create \
      --name actions-1 \
      --type action \
      --subscriptions "user.created,user.updated,user.deleted" \
      --configuration '{"action_id":"385db79f-28a4-43d9-909d-6f5511dd6632"}'
    ```

    成功すると、この呼び出しはEvent Streamの `id` を含む次の JSON を返します。新しいEvent Streamはデフォルトで有効になっています。

    ```json lines theme={null}
    {
        "configuration": {
          "action_id": "act_xyz789...",
          "status": "enabled"
      }
    }
    ```
  </Tab>

  <Tab title="Dashboard">
    Auth0 Actions を使用して Auth0 Dashboard でEvent Streamを作成するには、次の手順を実行します。

    1. **Auth0 Dashboard** > **Event Streams (Early)** に移動します。

    2. **+Create Event Stream** を選択します。

    3. ストリームタイプの一覧から **+Auth0 Actions** を選択します。新しい Auth0 Actions ストリームの設定フォームが開きます。

    4. **ストリームの詳細を設定:** 設定フォームで、次の情報を入力します。

       * **ストリーム名:**

         Event Streamがわかりやすいよう、説明的な名前を入力します。これにより、Auth0 Dashboard 内で識別しやすくなります。

    5. **イベントタイプを選択:** **Select Event Types** セクションで、このストリームに含める Auth0 のイベントタイプを選択します。要件に応じて複数のイベントタイプ (例: `Created`、`Updated`、`Deleted`) を選択できます。

    6. **Action Editor** でハンドラーコードを記述します。システムでは `onExecuteEventStream` 関数が必要です。成功または失敗の状態は `api` オブジェクトを使用して管理できます。

    ```javascript theme={null}
    /**
     * Event Stream の実行中に呼び出されるハンドラー。
     * @param {Event} event - Cloud Event の詳細。
     * @param {EventStreamAPI} api - イベントの処理に使用できるメソッドを持つインターフェース。
     */
    exports.onExecuteEventStream = async (event, api) => {
      const eventType = event.message.type;
      const eventData = event.message.data;

      console.log(`Received event: ${eventType}`);

      // カスタムロジック: 例: 外部 API にデータを送信する
      // await axios.post('https://my-crm.com/ingest', eventData);

      // 障害処理:
      // 再試行をトリガーするには、エラーをスローするか api.message.fail() を使用します
      if (!eventData) {
         // api.message.fail('No data received');
         throw new Error('No data received');
      }

      // 成功:
      // 関数がエラーなしで終了すると、イベントは配信済みとしてマークされます。
    };
    ```

    7. **変更を保存:** ストリーム名と Action ハンドラーを設定すると、システムによって Action が自動的に作成され、ストリームにバインドされて有効になります。

    これで新しいEvent Streamが作成され、Auth0 は選択したイベントタイプを指定した Auth0 Action にパブリッシュできるようになります。ステータスの監視やEvent Streamの管理は、Auth0 Dashboard の Event Streams (Early) ページから行えます。
  </Tab>
</Tabs>

<div id="learn-more">
  ## 詳細情報
</div>

* [イベントタイプ](/ja/docs/customize/events/event-types)
* [イベントのテスト、可観測性、障害復旧](/ja/docs/customize/events/event-testing-observability-and-failure-recovery)
* [イベントのベストプラクティス](/ja/docs/customize/events/events-best-practices)