# ツール



## Catalyst Maven ツール



--------------------------------------------------------------------------------
title: "はじめに"
description: "Catalyst Maven Toolsは、Basic I/OおよびAdvanced I/Oサーバーレス関数を作成するためのCatalyst Mavenアーキタイプ、Maven依存関係としてのCatalyst Java SDK、およびIDE上から直接関数に対してさまざまなコマンドを実行できるCatalyst Mavenプラグインを含む機能セットです。"
last_updated: "2026-07-02T09:34:22.110Z"
source: "https://docs.catalyst.zoho.com/ja/tools/maven-tools/introduction/"
service: "Serverless"
--------------------------------------------------------------------------------


# Catalyst Maven Tools

### はじめに

Catalystは、Javaアプリケーション開発者に対して、アプリケーション開発のライフサイクル全体を通じて、好みのIDEで作業できる柔軟性と利便性を提供します。これには、Javaサーバーレス関数の初期化から、コードのビルド、テスト、Catalystリモートプロジェクトへのデプロイまでのすべての段階が含まれます。

このサポートは、Javaプロジェクトで広く使用されているビルド自動化ツールであるApache Maven向けのいくつかの機能として提供されています。Mavenはプロジェクトオブジェクトモデル（POM）に従い、ビルドおよび依存関係管理、プロジェクトの保守、テスト駆動デプロイメントを含むプロジェクト管理を処理でき、Javaプログラミングを支援する多数のプラグインを提供します。

<br>

Catalystは、Javaアプリケーション開発のために以下のMavenツールを提供しています：

* Catalyst Maven Archetypes: Catalystは、CLIで初期化する必要なく、Java IDE内から直接サーバーレスのBasic I/O関数およびAdvanced I/O関数をそれぞれ作成するための2つのMavenアーキタイプを提供します。

* Maven依存関係としてのCatalyst Java SDK: Catalystが提供するJava SDKパッケージは、Maven設定ファイルに依存関係として含めることができ、手動でダウンロードやインストールする必要はありません。

* Catalyst Maven Plugins: Catalystは、CLIの代わりにIDEからアーキタイプを使用してJava関数をパッケージ化、サーブ、およびデプロイできるMavenフレームワークのプラグインも提供しています。

<br>

Eclipse、IntelliJ IDEA、NetBeans、Visual Studio Codeなど、お使いのどのJava IDEでもCatalyst Maven Toolsを利用できます。Maven統合を含むJava開発環境の詳細については、公式ドキュメントをご覧ください。

CatalystのMavenサポートは、作業負荷を軽減し、機能性を向上させることで、簡単なJavaアプリケーション開発を促進します。Java依存関係やSDKパッケージのバージョン管理を手動で処理する手間を省くことができます。このサポートにより、基本的な操作のためにCLIに切り替えることなく、アプリケーション環境のセットアップ、コーディング、テスト、デプロイ、管理を含むすべての操作を単一のインターフェース内で実行できます。

注意: Catalystが提供するMavenアーキタイプ、依存関係、およびプラグインには、ローカル環境から実行できるすべてのCatalyst操作が含まれているわけではありません。Mavenツールと並行して、他の操作にはCatalyst CLIを利用できます。

<br>


### 前提条件

Catalyst Maven Toolsを使用するには、お使いのJava IDEにMavenがインストールされていることを確認する必要があります。

* Eclipse: Eclipseは組み込みバージョンのMavenを実行し、Mavenの組み込みサポートを提供しています。M2Eclipseは、多数の組み込み機能を備えたMavenとの緊密な統合を提供します。新しいソフトウェアとしてインストールするか、Eclipse Marketplaceで「Maven」を検索できます。

* IntelliJ IDEA: IntelliJ IDEAは、Maven プロジェクトを直接作成したり、既存のプロジェクトにMavenサポートを追加したりできるMavenとの完全な統合を提供しています。

* NetBeans: Apache NetBeansは、Mavenの組み込みサポートを備えており、Mavenを使用してNetBeansアーティファクトをビルドおよび設定するためのいくつかのユーティリティを提供しています。

* Visual Studio Code: VS Codeは、インストール後にMaven操作を実行できる完全に統合されたMaven拡張機能を提供しています。
<br>

注意: VS Codeを使用している場合、Mavenを初めてインストールする際は、Mavenの実行可能パスを設定する必要があります。これは、以下に示すようにVS Codeの設定で構成できます。

<br>

<br />


--------------------------------------------------------------------------------
title: "Catalyst Maven アーキタイプ"
description: "Catalystは、Maven Central Repositoryに一覧表示されている、IDEから直接Basic I/OおよびAdvanced I/Oタイプのサーバーレス関数を作成するための事前定義済みMavenアーキタイプを提供しています。"
last_updated: "2026-07-02T09:34:22.110Z"
source: "https://docs.catalyst.zoho.com/ja/tools/maven-tools/maven-archetypes/"
service: "Serverless"
--------------------------------------------------------------------------------


# Maven Archetypes

### はじめに

Maven archetypeは、Mavenプロジェクトのテンプレートを定義するツールキットです。Maven archetypeは、Java開発者にプロジェクトのテンプレートのパラメータ化されたバージョンを標準化された方法で生成する手段を提供します。

Catalystは、Basic I/OおよびAdvanced I/Oタイプのサーバーレス関数を作成するための事前定義済みMavenアーキタイプを提供しています。これらのアーキタイプはMaven Central Repositoryから一覧表示されます。これらのアーキタイプを使用すると、関数の詳細を含む入力値を提供するだけで、関数を標準構造で作成・初期化し、Mavenプロジェクトのディレクトリに必要な依存関係を含めます。この方法で、個別のPOMディレクトリに複数の関数を追加できます。

Mavenアーキタイプで関数を作成する際には、以下の点に注意してください：

* CLIから関数を初期化する場合、最初にプロジェクトを初期化するか、既存のCatalystプロジェクトディレクトリに関数を追加する必要があります。Mavenの場合、プロジェクトを個別に初期化することはできません。関数を直接作成できます。

* アーキタイプで作成した関数は、次のセクションで説明するように、選択した保存先フォルダに作成されます。

* アーキタイプで作成した関数は、後のセクションで説明するMaven設定ファイルpom.xmlにProject IDを設定することで、リモートアカウントの既存プロジェクトに関連付けることができます。このファイルにCatalyst組織のOrg IDも追加する必要があります。

* Mavenツールを通じて、Basic I/OおよびAdvanced I/O以外のタイプの関数、他のスタック、またはクライアントコンポーネントを作成することはできません。これらのリソースをローカル環境で初期化するには、CLIを利用する必要があります。

<br>


### アーキタイプでBasic I/OまたはAdvanced I/O関数を作成する

このヘルプドキュメントでは、VS Code IDEの例を使用してCatalyst Maven Toolsを操作する手順を説明します。使用するIDEによっては、一部の詳細が異なる場合があります。

以下の方法でBasic I/OまたはAdvanced I/O関数を作成できます：

1. IDEで新しいMavenプロジェクトを作成します。使用するIDEによって手順は異なる場合があります。IDEに応じて、既存のプロジェクトをMavenに変換することもできます。

    VS Codeの場合、Mavenの下にある**+**アイコンをクリックして新しいMavenプロジェクトを作成します。

<br />

2. アーキタイプ検索バーに「com.zoho.catalyst」と入力します。作成したい関数のタイプに基づいて、以下のいずれかを選択します：

* catalyst-archetype-basicio: Basic I/O関数を作成する場合
* catalyst-archetype-advancedio: Catalyst SDKを含むAdvanced I/O関数を作成する場合
* catalyst-archetype-advancedio-basic: Catalyst SDKなしでAdvanced I/O関数を作成する場合

<br />

注意: Catalystアーキタイプが結果に表示されない場合、または最新のアーキタイプ定義を取得したい場合は、IDEのMavenアーキタイプカタログを更新して、最新の公開済みアーキタイプにアクセスする必要がある場合があります。IDEに応じて、カタログの更新手順を確認し、必要な操作を実行してください。VS Codeでは、コマンドパレットを開いてMaven: Update Maven Archetype Catalogを選択します。

3. 選択したアーキタイプのバージョンを選択します。最新バージョンを選択することを推奨します。

<br />

4. プロジェクトのgroup IDを入力します。このIDはMavenプロジェクトを一意に識別します。**Enter**を押してデフォルト値を使用することもできます。

<br />

5. プロジェクトのartifact IDを入力します。これはバージョンなしのJARの名前です。**Enter**を押してデフォルト値を使用することもできます。

<br />

6. Mavenプロジェクトを保存する保存先フォルダを選択します。

7. ターミナルでいくつかの入力を求められます。各入力後に**Enter**を押してください。入力せずに直接**Enter**を押すと、デフォルト値が送信されます。

    * 出力JARファイルのSNAPSHOTのバージョン
    * Mavenパッケージ名
    * Java関数のappNameまたはCatalyst参照名
    * 関数のメインクラス名
    * この関数が関連付けられるプロジェクトのProject ID
    * プロジェクトが属するCatalyst組織のOrg ID

<br />

注意: Project IDとOrg IDの値はpom.xml設定ファイルに保存されます。後でpom.xmlで直接設定することもできるため、ここでは**Enter**を押してこれらの値の入力をスキップできます。

8. 「**Y**」を入力して**Enter**を押し、Mavenプロジェクトのプロパティ設定を確認します。

<br />

以下に示すディレクトリ構造でMavenプロジェクトに関数が作成されます。

<br />

CLIからJava関数を初期化する場合、関数はプロジェクトのルートにcatalyst.jsonプロジェクト設定ファイル、関数のルートにCatalyst Java SDK JARファイル、およびその他のプロジェクト依存関係とともに作成されます。Catalyst Mavenアーキタイプを使用して関数を作成する場合、これらのディレクトリにJava SDKファイルやプロジェクト依存関係は含まれません。

代わりに、関数のディレクトリにはソースディレクトリとターゲットディレクトリが個別に含まれ、さらにMaven環境固有のpom.xmlも含まれます。メインのJava関数ファイルも関数タイプに基づくデフォルトコードで作成され、catalyst-config.jsonファイルが作成されて自動設定されます。


--------------------------------------------------------------------------------
title: "Java SDK依存関係"
description: "Catalyst Java SDKは、IDEでCatalyst Mavenアーキタイプを使用してBasic I/OおよびAdvanced I/Oを作成する際に、Maven依存関係として自動的に処理されます。"
last_updated: "2026-07-02T09:34:22.111Z"
source: "https://docs.catalyst.zoho.com/ja/tools/maven-tools/java-sdk-dependency/"
service: "Serverless"
--------------------------------------------------------------------------------


# Catalyst Java SDK依存関係

catalyst-java-sdkパッケージは、通常CLIからのJava関数の初期化時にダウンロードされ、関数のディレクトリに保存されます。また、CatalystコンソールのSettings内のDeveloper ToolsセクションからいつでもSDKパッケージにアクセスし、Java関数のフォルダ内に含めることもできます。

Catalyst Java SDKをMaven依存関係として追加するオプションにより、Catalystは以下のことを保証します：

* CatalystアーキタイプでJava関数を作成するたびに、Java SDKパッケージが自動的に組み込まれます。

* SDKは、関数バンドル内のpom.xml設定ファイルにMaven依存関係として追加されます。

* Java SDKパッケージのバージョン管理が自動的に処理されます。CatalystはJava関数がサーブまたはデプロイされる際に、SDKパッケージの最新バージョンが適用されることを保証します。

* 関数をパッケージ化、サーブ、またはデプロイする際に、SDKパッケージと自動的にバンドルされます。

Java SDK Maven依存関係により、SDKツールキットの管理を行う必要がなくなり、作成する各関数ごとにSDKをダウンロードする必要がなくなります。

IDE内のMaven依存関係の下にJava SDKパッケージが一覧表示されます。

<br />


--------------------------------------------------------------------------------
title: "pom.xml"
description: "Catalyst Java SDK依存関係およびCatalyst Mavenプラグインの定義は、Mavenプロジェクト内のMaven設定ファイルであるpom.xmlに記載されています。"
last_updated: "2026-07-02T09:34:22.111Z"
source: "https://docs.catalyst.zoho.com/ja/tools/maven-tools/pom-xml/"
service: "Serverless"
--------------------------------------------------------------------------------



# pom.xml設定ファイル

pom.xmlは、MavenプロジェクトのディレクトリにあるMaven設定ファイルで、プロジェクトに関する情報とMavenがプロジェクトをビルドするために使用する設定の詳細が含まれています。たとえば、Mavenプロジェクトのgroup IDとartifact ID、プロジェクトのプロパティ、使用される依存関係とプラグイン、それらの実行情報などが指定されています。

注意: pom.xmlは、Mavenプロジェクトを作成するか、既存のプロジェクトをMavenに変換する際に自動的に作成されます。IDEによっては、プロジェクトに追加されていない場合、このファイルを生成する必要がある場合があります。

Java関数の作成後、pom.xmlにCatalyst Java SDKが依存関係として自動的に追加されます。

<dependencies>
    <dependency>
      <groupId>com.zoho.catalyst</groupId>
      <artifactId>java-sdk</artifactId>
      <version>1.15.0</version>
    </dependency>
  </dependencies>



Maven Central Repositoryで公開されているZohoリポジトリから取得されたJava依存関係を確認できます。

<repositories>
    <repository>
      <id>java-sdk</id>
      <url>https://maven.zohodl.com</url>
    </repository>
  </repositories>


pom.xmlのビルド定義には、Catalyst Mavenプラグインアーティファクトと、プラグインで利用可能な個別のコマンドに関する情報が含まれています。

<build>
    <plugins>
      <plugin>
        <groupId>com.zoho.catalyst</groupId>
        <artifactId>catalyst-maven-plugin</artifactId>
        <version>0.0.2</version>
        <executions>
          <execution>
            <id>catalyst-package</id>
            <phase>package</phase>
            <goals>
              <goal>package</goal>
            </goals>
          </execution>
          <execution>
            <id>catalyst-deploy</id>
            <phase>deploy</phase>
            <goals>
              <goal>deploy</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <org>901738101</org>
          <project>3376000001796044</project>
        </configuration>
      </plugin>
      </plugins>
  </build>


前述のとおり、関数作成時に設定していない場合は、ビルド定義の_<configuration></configuration>_セクションで、CatalystプロジェクトのProject IDと、プロジェクトが属する組織のOrg IDを設定できます。


--------------------------------------------------------------------------------
title: "Catalyst Maven プラグイン"
description: "Catalystは、Catalyst Mavenアーキタイプで作成した関数を簡単にパッケージ化、サーブ、デプロイできるMavenプラグインを提供しています。"
last_updated: "2026-07-02T09:34:22.111Z"
source: "https://docs.catalyst.zoho.com/ja/tools/maven-tools/maven-plugin/"
service: "Serverless"
--------------------------------------------------------------------------------



# Catalyst Maven Plugin

### はじめに

catalystプラグインは、アーキタイプからBasic I/OまたはAdvanced I/O関数を初期化した後、Mavenプラグインの下に利用可能になります。このプラグインの下に、以下に示す個別のコマンドがあり、Catalyst関数およびMavenアーティファクトに対してさまざまな操作を実行できます。

<br />

serveおよびdeployコマンドの実行は、リクエストが認証された後に行われます。Catalystは現在、Catalyst CLI認証とは独立した、Mavenプラグイン用のプロプライエタリ認証を提供しています。これらのコマンドを実行すると、IDEが認証トークンの生成を求めるプロンプトを表示し、作成されたトークンはローカルシステムに保存されます。packageおよびhelpコマンドは認証が不要です。

<br>

### パッケージ

CatalystのpackageコマンドはMavenプラグイン専用で、CLIでは利用できません。これにより、Java関数ディレクトリを実行可能なバンドルとしてパッケージ化できます。

注意: サーブまたはデプロイする前に、関数を手動でパッケージ化できます。ただし、最初にpackageコマンドを実行せずに直接サーブまたはデプロイする場合、Catalystはサーブまたはデプロイの前に関数を自動的にパッケージ化します。


#### Catalyst Mavenプラグインで関数をパッケージ化する

以下に説明する方法で、Java Basic I/OまたはAdvanced I/O関数をパッケージ化できます。この例では、VS Code IDEでこのコマンドを実行しています。

Mavenツールの**Plugins > catalyst**の下にある**package**コマンドをクリックします。

<br />

IDEのターミナルで実行の進行状況を追跡できます。関数はMavenのSNAPSHOTとしてJARファイル形式にコンパイルされます。Mavenプロジェクトディレクトリのtargetフォルダに、デプロイ可能なバンドル全体catalyst-archive.zipが追加されています。

<br />

targetディレクトリには、ビルドアーカイブとメイン関数のSNAPSHOT JARとともに、すべてのコンパイル済みファイル、ライブラリ、およびその他のMaven依存関係が含まれます。

<br />

catalyst-archiveには、Java SDK、コンパイル済みソースファイル、catalyst-config.json、およびpom.xmlを含むデプロイ可能なライブラリファイルが含まれます。

<br />

これで、関数をローカルでサーブするか、リモートプロジェクトにデプロイできます。

<br>

### サーブ

Catalyst Mavenプラグインのserveコマンドは、CLIコマンドのcatalyst serveと同様です。リモートプロジェクトにデプロイする前に、システム内のlocalhostを通じて関数をサーブしてテストできます。Basic I/OおよびAdvanced I/O関数の両方をサーブし、テスト用のローカルエンドポイントを取得できます。

さらに、IDEのデバッガーを活用してライブサーブセッションにアタッチし、テスト体験を向上させることができます。Catalystは、サーブする関数のホットリロードも可能にします。これにより、関数のコードを変更し、再コンパイルや再サーブを行うことなく、更新がライブで反映されるのを確認できます。


注意:

* 関数に関連付けられたProject IDとOrg IDは、関数をサーブする前にpom.xmlで設定する必要があります。

* 関数はサーブされる前にバンドルする必要があります。プラグインから[パッケージ化](#パッケージ)するか、直接サーブすることができ、その場合はpackageコマンドが自動的に実行されます。

* サーブを成功させるには、Mavenプロジェクトのディレクトリが、すべての必要なMavenおよびCatalyst依存関係ファイルを含む標準構造になっている必要があります。

<br>

#### Catalyst Mavenプラグインで関数をサーブする

以下に説明する方法で、Java Basic I/OまたはAdvanced I/O関数をサーブできます。この例では、VS Code IDEでこのコマンドを実行しています。

1. Mavenツールの**Plugins > catalyst**の下にある**serve**コマンドをクリックします。

<br />

IDEのターミナルにサーブセッションの進行状況が表示されます。

<br />

2. 有効な認証トークンが検出されない場合、Catalystはサーブリクエストの認証を求めるプロンプトを表示します。ターミナルに表示されたURLをブラウザウィンドウで開きます。

<br />

3. ブラウザウィンドウで**Accept**をクリックします。これにより、Catalystアカウントが認証され、Catalyst CLIに要求された権限が付与されます。

<br />

ウィンドウを閉じて、IDEに戻ることができます。

4. Catalystはデフォルトのポート3010でローカルサーバーを起動します。ターミナルからサーブされた関数のローカルURLにアクセスします。

<br />

注意: IDEによっては、ホストされたリソースをテストするためのデバッグコンソールが自動的に起動する場合があります。自動的に起動しない場合は、サーブセッションに自分でデバッガーをアタッチすることもできます。

ターミナルには実行されたアクションのライブログが表示されます。IDEによっては、コマンドの実行を終了してサーブセッションを終了できます。

<br>

### デプロイ

Catalyst Mavenプラグインのdeployコマンドは、CLIコマンドのcatalyst deployと同様です。テストが完了した後、関数をリモートプロジェクトにデプロイできます。Basic I/OおよびAdvanced I/O関数の両方をデプロイし、デプロイされたURLエンドポイントを取得できます。

注意:

* 関数に関連付けられたProject IDとOrg IDは、関数をデプロイする前にpom.xmlで設定する必要があります。

* 関数はデプロイされる前にバンドルする必要があります。プラグインから[パッケージ化](#パッケージ)するか、直接デプロイすることができ、その場合はpackageコマンドが自動的に実行されます。

* デプロイを成功させるには、Mavenプロジェクトのディレクトリが、すべての必要なMavenおよびCatalyst依存関係ファイルを含む標準構造になっている必要があります。

<br>

#### Catalyst Mavenプラグインで関数をデプロイする

以下に説明する方法で、Java Basic I/OまたはAdvanced I/O関数をデプロイできます。この例では、VS Code IDEでこのコマンドを実行しています。

1. Mavenツールの**Plugins > catalyst**の下にある**deploy**コマンドをクリックします。

<br />

IDEのターミナルにコマンド実行の進行状況が表示されます。

<br />

2. 有効な認証トークンが検出されない場合、Catalystはデプロイリクエストの認証を求めるプロンプトを表示します。ターミナルに表示されたURLをブラウザウィンドウで開きます。

<br />

3. ブラウザウィンドウで**Accept**をクリックします。これにより、Catalystアカウントが認証され、Catalyst CLIに要求された権限が付与されます。

<br />

ウィンドウを閉じて、IDEに戻ることができます。

4. ターミナルにアクセス可能な関数のデプロイ済みURLが表示されます。

<br />

注意: CatalystアプリケーションのURLの/server/部分は関数を示します。Basic I/O関数のURLは関数名の後に/executeが含まれますが、Advanced I/O関数のURLにはそのキーワードは含まれません。

これで、リモートコンソールのプロジェクト内の関数にアクセスできるようになります。

<br>

### ヘルプ

Mavenプラグインは、実行するとプラグイン内のすべてのコマンドのヘルプ情報を表示するhelpコマンドを提供します。

<br />

IDEのターミナルで詳細を確認できます。

<br />


## Catalyst トンネリング



--------------------------------------------------------------------------------
title: "はじめに"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.128Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/introduction/"
service: "All Services"
--------------------------------------------------------------------------------


# Catalyst Tunneling

## はじめに

Catalyst Tunnelingは、非HTTPSの**Catalystサーバーレス関数**（Event関数およびCron関数）、ならびにIntegration関数をローカルでデバッグできるようにします。ローカルデバッグは、アプリケーションエンジニアリングにおいて重要な要素です。CatalystではBasic I/OおよびAdvanced I/O関数のデバッグには明確な手段があり制限はありませんが、Event関数やCron関数のような非HTTPSバックエンド関数、またはIntegration関数のようなHTTPSバックエンド関数のデバッグは、困難または制約が多い場合があります。

Cron、Event、およびIntegration関数は、自動的なバックエンド呼び出しによってのみ実行されます。AdvancedおよびBasic I/O関数のように、エンドポイントURLによって直接トリガーされるわけではありません。これらの関数は、ランタイムイベント、特定のスケジュール、または時間間隔によってバックエンドプロセスとして実行されます。正確なトリガーなしに開発環境でこれらの関数をデバッグすることは、結論を得られません。Tunnelingは、この問題を解決するCatalystの機能です。

Catalyst Tunnelingなしで開発環境でIntegrationおよび非HTTPS関数をデバッグするには、Catalyst CLIで関数シェルを起動し、サンプル入力を提供して関数をテストする必要がありました。Event関数のみ、追加で入力としてサンプルペイロードを生成し、出力を確認することができました。しかし、これらの方法ではコードロジックを検査したり、関数をテストするための十分なデバッグ支援を得ることはできません。

Tunnelingは、Catalyst関数の実行をクラウドからローカルWebサーバーへリバースプロキシする原理で動作します。これにより、ローカルIDEで関数をデバッグできます。任意のリバースプロキシプロバイダーを使用し、これらの関数をデバッグするためのTunneling URLを提供できます。その後、URLをトリガーし、Catalyst Tunnelingを使用して、これらの関数への呼び出しをローカルシステムにルーティングすることで、簡単にデバッグできます。

注意: Tunnelingは、サポートされているすべてのランタイム（Java、Node.js、Python）のCatalyst関数のデバッグに使用できます。


<br />

Catalyst Tunnelingと任意のサードパーティリバースプロキシサービスを組み合わせることで、Catalystコンソール、Catalyst CLI、および任意のIDEを使用して効果的に関数をデバッグできます。

注意: Tunnelingは、Catalystの開発環境でのみ利用可能です。


--------------------------------------------------------------------------------
title: "メリット"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.128Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/benefits/"
service: "All Services"
--------------------------------------------------------------------------------


# メリット

* **効率的なデバッグ体験**: Catalyst Tunnelingがなければ、開発環境でCronやEventなどの非HTTPS関数、またはIntegration関数のデバッグは結論を得られない作業でした。Basic I/OやAdvanced I/O関数のようにコードファイルに好みのブレークポイントを設定してデバッグする自由がありませんでした。Tunnelingを使用することで、Cron、Event、およびIntegration関数を自由にトリガーし、すべてのコード行を簡単に検査できるようになりました。

* **リバースプロキシプロバイダーの制限なし**: Catalyst Tunnelingは、任意のリバースプロキシプロバイダーと使用できます。使用できるリバースプロキシプロバイダーに制限はありませんが、信頼できるリバースプロキシプロバイダーのサービスを使用することを推奨します。一般的なリバースプロキシプロバイダーを使用したTunneling URLの設定手順の詳細は、このセクションに記載されています。

* **IDEの制限なし**: IDEがデバッガーの設定を許可する場合、Catalyst Tunnelingを使用して非HTTPSおよびIntegration関数を直接デバッグできます。このヘルプドキュメントには、一般的に使用されるIDEのデバッガーの設定に関する具体的な手順も含まれています。

* **コンソールからのTunneling管理**: コンソールから直接、Tunnelingの有効化、無効化、および複数の関数のトンネリング選択が可能です。Catalystコンソールは、Tunnelingプロセスを無効にしない場合、24時間後にTunnelingを自動的に無効にします。トンネリングが必要な非HTTPSおよびIntegration関数の選択を更新するオプションもあります。

<br />


--------------------------------------------------------------------------------
title: "主要な概念"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.129Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/key-concepts/"
service: "All Services"
--------------------------------------------------------------------------------


# 主要な概念

関数にTunnelingを実装する前に、いくつかの主要な概念を理解しておく必要があります：

* **サードパーティリバースプロキシサービス**: リバースプロキシプロバイダーは、リクエストに応じてパブリックにアクセス可能なURLを生成し、すべてのリクエストをローカルWebサーバーにプロキシして、localhostをインターネットに接続できるようにします。任意のリバースプロキシプロバイダーを選択できます。このヘルプドキュメントのセクションでは、以下のリバースプロキシプロバイダーを使用して関数のTunneling URLを生成する詳細な手順を説明します：
    - Ngrok
    - Localtunnel
    - Serveo
    - Localhost.run
    - Pagekite

注意: このヘルプドキュメントでは、リバースプロキシプロバイダーを使用してTunneling URLを生成する手順のみを説明します。これらのリバースプロキシプロバイダーとその提供サービスの詳細については、各プロバイダーのヘルプドキュメントをご覧ください。

* **Tunneling URL**: リバースプロキシプロバイダーが生成するURLです。このURLは、非HTTPS関数およびIntegration関数への呼び出しをすべてローカルシステムにルーティングします。ローカルWebサーバーがアプリケーションのホスティングを処理し、このURLでアクセスできます。本質的に、このURLにより、ローカルシステムがCron、Event、およびIntegration関数を実行できるサーバーとして機能します。リバースプロキシプロバイダーがTunneling URLを正しく生成しない場合、トンネリング時に関数の*実行履歴*が「**URL Not Found**」ステータスで表示され、エラーが発生します。

* **トンネリング済み関数**: トンネリングするために選択した非HTTPSおよびIntegration関数です。Cron、Event、およびIntegration関数はランタイム中にバックエンドプロセスとしてのみトリガーされ、通常はCatalystクラウドで実行されます。しかし、これらの関数がトンネリングされると、その実行はローカルシステムにルーティングされます。その結果、これらの関数実行のライブログはCLIでのみ利用可能であり、Catalystログコンポーネントやコンソールの他の場所では利用できません。Tunnelingに関する情報を含むもう1つのログセットは監査ログで、Tunnelingがいつ、誰によって有効にされたかなどの情報が表示されます。

* **Catalyst関数シェル**: Catalystでは、Catalyst CLIで関数シェルを起動し、関数をデバッグできます。Nodeシェルのように機能しますが、Catalyst CLIの機能で動作します。このシェルを使用してTunnelingコマンドを実行します。TunnelingのCatalystシェルコマンドの一覧は、このセクションに記載されています。

* **Tunnelingを有効にするための条件:** Tunnelingは、Catalystの開発環境でのみ使用可能です。関数をトンネリングするには、まずCatalyst Serverlessセクションからコンソールで作成してコーディングするか、ローカル環境でコーディングした後にコンソールにデプロイすることで、Catalystコンソールで利用可能にする必要があります。


* **トンネリング中は関数のアプリケーションパフォーマンスモニタリングが利用不可**: 関数がトンネリングされている間、関数への呼び出しはローカルシステムにルーティングされます。これにより、アプリケーションパフォーマンスモニタリング（APM）コンポーネントが関数のパフォーマンスを監視できなくなります。ただし、Tunnelingを終了すれば、APMを使用して関数のパフォーマンスを監視できます。


--------------------------------------------------------------------------------
title: "アーキテクチャ"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.129Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/architecture/"
service: "All Services"
--------------------------------------------------------------------------------


# アーキテクチャ

以下の図は、**Catalyst Tunneling**を使用してCatalystの非HTTPSおよびIntegration関数をデバッグする際に関わるバックエンド操作を示しています：

<br />

注意: Catalyst Tunnelingは開発環境でのみ利用可能です。

以下の手順は、Catalyst Tunnelingを使用して非HTTPSおよびIntegration関数をデバッグする際のワークフローを説明しています：

1. Catalystコンソールで、トンネリングする非HTTPSまたはIntegration関数を選択し、サードパーティのリバースプロキシサービスを使用して生成したTunneling URLを提供してTunnelingを有効にします。

2. 次に、関数シェルを起動し、Catalyst Tunnelingを使用してデバッグ操作を開始します。

3. Tunneling URLを使用して関数をトリガーするたびに、呼び出しがローカルシステムにルーティングされ、ログはCatalyst CLIで確認できます。本質的に、ローカルシステムがTunneling対応関数が実行されるサーバーとして機能します。<br /><br />これにより、コードファイルにブレークポイントを設定し、関数を簡単にデバッグできます。

注意:

* 関数がトンネリングされた後、その実行ログはCatalyst CLIでのみ確認でき、Tunnelingがいつ、誰によって有効にされたかなどの基本情報は、コンソールの監査ログセクションで確認できます。

* 複数の関数をトンネリングに選択できますが、最初の関数のデバッグが完了してから次の関数のデバッグを開始できます。現在のアップデートでは、この種の同期的な関数デバッグのみが可能です。

* Visual Studio Code、IntelliJなどの一般的なIDEのデバッガーを設定して関数をデバッグする手順は、このセクションに記載されています。


--------------------------------------------------------------------------------
title: "コンソールでのTunneling管理"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.129Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/manage-tunneling/"
service: "All Services"
--------------------------------------------------------------------------------


# コンソールでのTunneling管理

このヘルプセクションでは、コンソールでのTunneling操作の管理方法について説明します。

### Tunnelingの編集

トンネリングする関数の追加や削除、または設定したTunneling URLを更新できます。

トンネルを編集するには：

1. **Edit Tunnel**オプションをクリックします
<br />

2. 必要な変更を行い、**Update**をクリックします。
<br />

トンネルが編集されました。
<br />

### Tunnelingの無効化

関数のTunnelingを無効にするには：

1. **Disable**ボタンをクリックします。
<br />

2. **Yes, Proceed**をクリックしてTunnelingを無効にします。
<br />

Tunnelingが無効になります。
<br />

関数のTunnelingを手動で無効にしない場合、Catalystにより**24時間**後に自動的に無効化され、その旨を通知するメール通知が届きます。

<br />

**Enable**をクリックすると、Tunnelingを再度有効にできます。

注意:

以下のCatalyst CLIコマンドを使用してTunnelingを有効にすることもできます：
catalyst functions: shell --tunnel tunnel-port-number --enable-tunnel tunneling-URL
<br>
Tunnelingに関連するCLIコマンドの詳細については、このヘルプセクションをご覧ください。


このオプションコマンドは、Tunnelingの有効化のみを行うことができます。コンソールで利用可能な編集やその他の操作を実行することはできません。Tunnelingを無効にするには、ターミナルを終了するだけです。
<br>

新しいTunneling URLで関数をトンネリングしたい場合は、<tunneling-URL>を新しく生成したURLに置き換えてください。


### 実装


> Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。



--------------------------------------------------------------------------------
title: "前提条件"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.129Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/prerequisites/"
service: "All Services"
--------------------------------------------------------------------------------


# 前提条件

非HTTPSおよびIntegration関数をデバッグするには、以下の条件を満たす必要があります：

1. リバースプロキシプロバイダーがCLIのインストールなど特定の手順を必要とする場合、実装を開始する前にそれらを完了してください。たとえば、リバースプロキシプロバイダーがNgrokの場合、そのCLIをインストールする必要があります。

<br />

注意: 以下の一般的なリバースプロキシプロバイダーのTunneling URL生成の詳細な手順を確認できます：

* Ngrok

* Localtunnel

* Serveo

* Localhost.run

* Pagekite<br />


2. CLIを使用してローカルプロジェクト環境から開発環境のCatalystコンソールにトンネリングしたい関数をデプロイします。
<br />

Catalyst Tunnelingを使用して非HTTPSおよびIntegration関数をデバッグするには、以下の手順を実装する必要があります：

1. Tunneling URLを生成する
2. コンソールでTunnelingを設定する
3. Catalyst関数シェルを起動してTunnelingを開始する
4. 関数のデバッグを開始するためにIDEのデバッガーを設定する
5. トンネリング済み関数をデバッグする

以降のヘルプセクションには、上記の手順を完了するための詳細な手順が含まれています。


--------------------------------------------------------------------------------
title: "Tunneling URLの生成"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.130Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/generate-tunneling-url/"
service: "All Services"
--------------------------------------------------------------------------------


# Tunneling URLの生成

Tunneling URLは、Tunnelingを有効にする際にトンネリング対応関数に関連付けるために必要です。トンネリング済み関数がトリガーされると、このURLへの呼び出しがローカルシステムにルーティングされます。

選択したリバースプロキシプロバイダーによって、Tunneling URLの生成手順は異なります。このヘルプドキュメントでは、最も一般的に使用されているリバースプロキシプロバイダーを使用したTunneling URLの生成手順を説明します。

### Ngrok

* CLIから**Ngrok**にログインし、システムでNgrokの二要素認証（2FA）を設定します。

注意: Ngrokの2FA設定手順は、公式ヘルプドキュメントに記載されています。

* *Tunneling URL*を生成するには、以下のCLIコマンドを使用します：
ngrok http tunnel-port-number



* Ngrokが生成したTunneling URLをコピーし、Catalystを使用して関数をトンネリングするためにCatalystコンソールに進みます。

注意:

* ここで使用するtunnel-port-numberは、関数シェルの起動時に使用するものと同じである必要があります。

* Ngrokの詳細については、公式ヘルプドキュメントをご覧ください。

### Localtunnel

* 以下のターミナルコマンドを実行して、ローカルシステムに**Localtunnel**をインストールします：
npm install -g localtunnel

<br />

* Localtunnel CLIで以下のコマンドを実行してTunneling URLを生成します
lt --port tunnel-port-number



* Localtunnelが生成したTunneling URLをコピーし、Catalystを使用して関数をトンネリングするためにCatalystコンソールに進みます。

注意:

* ここで使用するtunnel-port-numberは、関数シェルの起動時に使用するものと同じである必要があります。

* Localtunnelの詳細については、公式ヘルプドキュメントをご覧ください。

### Serveo

* 新しいターミナルウィンドウで以下のコマンドを実行し、**Serveo**を使用してTunneling URLを生成します。
ssh -R 80:localhost:tunnel-port_number serveo.net



* Serveoが生成したTunneling URLをコピーし、Catalystを使用して関数をトンネリングするためにCatalystコンソールに進みます。

注意:

* ここで使用するtunnel-port-numberは、関数シェルの起動時に使用するものと同じである必要があります。

* Serveoを使用してTunneling URLを生成するために追加のCLIコマンドは不要です。Serveoの詳細については、公式ヘルプドキュメントをご覧ください。

### Localhost.run

* 新しいターミナルウィンドウで以下のコマンドを実行し、**Localhost.run**を使用してTunneling URLを生成します
ssh -R 80:localhost:tunnel-port-number nokey@localhost.run



* Localhost.runが生成したTunneling URLをコピーし、Catalystを使用して関数をトンネリングするために進みます。

注意:

* ここで使用するtunnel-port-numberは、関数シェルの起動時に使用するものと同じである必要があります。

* Localhost.runを使用してTunneling URLを生成するために追加のCLIコマンドは不要です。Localhost.runの詳細については、公式ヘルプドキュメントをご覧ください。

### Pagekite

* 新しいターミナルウィンドウで以下のコマンドを実行し、**Pagekite**を使用してTunneling URLを生成します。
ssh -R 80:localhost:tunnel-port-number nokey@localhost.run



このコマンドはPagekiteのWebサイトにcurlリクエストを送信し、ローカルシステムにpagekite.pyファイルをダウンロードするよう求めます。

注意: Pagekiteを使用して任意のプログラミングスタックの関数をリバースプロキシできます。ただし、Pagekiteサービスを使用するには、システムにPython 3がインストールされていることを確認する必要があります。

* PagekiteターミナルでTunneling URLを生成するために以下のコマンドを実行します
python3 pagekite.py tunnel-port-number yourname.pagekite.me



プロンプトが表示されたら、Tunneling URLに一意の名前を指定してください。

注意:

* ここで使用するtunnel-port-numberは、関数シェルの起動時に使用するものと同じである必要があります。

* Pagekiteの詳細については、公式ヘルプドキュメントをご覧ください。


--------------------------------------------------------------------------------
title: "CatalystコンソールでのTunneling設定"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.130Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/config-tunneling-console/"
service: "All Services"
--------------------------------------------------------------------------------


# CatalystコンソールでのTunneling設定

CatalystコンソールでTunnelingにアクセスするには：

1. コンソールでCatalystプロジェクトを開き、**settings**アイコンをクリックします。
<br />

2. *Project Settings*に移動し、**Tunneling**をクリックします。
<br />

3. **Create Tunnel Route**をクリックします。
<br />

4. ドロップダウンからトンネリングしたい非HTTPSおよびIntegration関数を選択します。
<br />

5. 前の手順で生成した*Tunneling URL*を**Tunneling URL**入力フィールドに貼り付けます。
<br />

注意:

* 選択した関数と使用するTunneling URLは、Tunnelingフロー図に表示されます。

* コンソールで関数を利用可能にするには、ローカルシステムからプロジェクトの開発環境のCatalystコンソールに関数をデプロイしている必要があります。

* 現時点では、関数の同期デバッグのみ実行できます。1つの関数のTunnelingが完了してから、次の関数がトンネリングされます。

6. **Enable**をクリックします。
<br />

Tunnelingを有効にした関数の一覧と、Tunnelingがいつ、誰によって有効にされたかなどの一般的な詳細を確認できるようになります。

注意:

* Integration関数の実行タイムアウトは30秒、CronおよびEvent関数は15分です。

* 関数のトンネリングに使用するリバースプロキシプロバイダーによっては、Catalystが設定した期間よりも短い期間でタイムアウトメッセージが発行される場合があります。この場合もタイムアウトメッセージはCatalyst関数の実行履歴に表示されます。

* 関数のトンネリングに使用するリバースプロキシプロバイダーによっては、Catalystが設定した期間よりも短い期間でタイムアウトメッセージが発行される場合があります。この場合もタイムアウトメッセージはCatalyst関数の実行履歴に表示されます。

トンネリング済み関数をデバッグしたい場合は、追加の設定を行い、別のCLIコマンドを使用する必要があります。IDEからトンネリング済み関数をデバッグする方法の詳細な手順は、このセクションに記載されています。


--------------------------------------------------------------------------------
title: "Catalyst関数シェルの起動とTunnelingの開始"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.130Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/launch-tunneling/"
service: "All Services"
--------------------------------------------------------------------------------


# Catalyst関数シェルの起動とTunnelingの開始

以下のCLIコマンドに--tunnelオプションを付けてCatalyst関数シェルを起動し、Tunneling URLを生成したポート番号を指定します。

catalyst functions:shell --tunnel tunnel-port-number

このコマンドにより、関数のTunnelingが開始されます。

<br />

関数をトリガーすると、すべての呼び出しがローカルにルーティングされ、Catalyst CLIで実行ログを確認できます。
<br />

コンポーネントセクションにあるトンネリング済み関数の*実行履歴*を確認しようとすると、関数がトンネリングされていることが明確に表示されます。
<br />

さらに**view-logs**アイコンをクリックすると、Tunnelingがいつ、誰によって有効化および無効化されたかなどの詳細を確認できます。
<br />

注意: 非HTTPSまたはIntegration関数はCatalystクラウドではなくローカルマシンで実行されるため、ログはCatalyst CLIでのみ確認できます。

同じ情報は監査ログでも確認できます。

<br />

次に、以下のCLIコマンドを実行して関数をトンネリングしてデバッグします：
catalyst functions:shell --tunnel tunnel-port-number --debug port-number

<br />

注意: Tunnelingとデバッグには異なるポート番号を指定してください。

関数をトンネリングしてデバッグを選択した場合、追加のIDE設定を実装する必要があります。トンネリング済み関数をデバッグするためのIDEデバッガーの設定手順は、このセクションに記載されています。


#### 関数スタック


> Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。



--------------------------------------------------------------------------------
title: "Java"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.130Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/ide-config/java/"
service: "All Services"
--------------------------------------------------------------------------------


# Java関数のデバッグ用IDE設定

このヘルプドキュメントでは、Visual Studio Code、IntelliJ IDEA、Eclipse IDEでJavaの非HTTPSおよびIntegration関数のデバッグ設定を行う方法を説明します。

注意: この手順は、トンネリング済み関数をデバッグしたい場合にのみ適用され、以下のCLIコマンドを使用している場合に該当します：

catalyst functions:shell --tunnel tunnel-port-number --debug port-number<br />

関数のトンネリングのみを行い、以下のCLIコマンドを使用している場合は、IDE設定は不要です。

catalyst functions:shell --tunnel tunnel-port-number<br />

このコマンドは関数をトンネリングするのみで、関数のログをCatalyst CLIに出力します。





### Visual Studio Code IDEのデバッガー設定

1. デバッグが必要なすべての関数がローカルマシンにあることを確認し、該当するプロジェクトをVS Codeで開きます。
<br />

2. メニューバーの**Run/Debug**ボタンをクリックし、「**create a launch.json file**」オプションをクリックしてlaunch.jsonファイルを作成します。
<br />

設定を開始する前のlaunch.jsonファイルの表示は以下のとおりです。
<br />

3. 以下のJSONスニペットをコピーし、「**configurations**」JSONキーの値として貼り付けます。

"configurations": [{
            "type": "java",
            "name": "java_cron", // 名前は任意ですが、デバッグ時に同じ関数名にすると便利です
            "request": "attach",
            "hostName": "localhost",
            "port": 9001,// catalyst functions:shell --tunnel 8001 --debug 9001で指定したデバッグポート番号。他のプロセスで使用されていない任意の番号を指定できます
            "projectName": "java_cron"// 関数名
}],


4. このファイルを保存し、必要なコード行にブレークポイントを適用して、次の手順に進みます。
<br />




### IntelliJ IDEA IDEのデバッガー設定

1. IntelliJ IDEにプロジェクトディレクトリをインポートし、ランタイムJDKをJavaバージョンと一致するように設定します。
<br />

注意: IntelliJ IDEAでJDKを設定する方法については、公式ヘルプドキュメントをご覧ください。

2. **Run>Edit Configurations**をクリックします。
<br />

3. **+アイコン**をクリックし、ポップアップから**Remote JVM Debug**オプションを選択して、**OK**をクリックします。
<br />

4. ポップアップで以下の値を設定してください：
    - Name: プロジェクト名または任意の名前を設定します。
    - *Configurations*タブ:
        - Debugger mode: **Attach to remote JVM**
        - Host: **localhost**
        - Port: Catalyst CLIでデバッグ用に設定したのと同じポート値を設定します。
        - Use module classpath: プロジェクトディレクトリのパスを選択します。
        - **OK**をクリックします。
    <br />

5. コードに必要なデバッグポイントを設定し、次の手順に進みます。
<br />




### Eclipse IDEのデバッガー設定

1. *Eclipse IDE*にプロジェクトディレクトリをインポートします。
<br />

2. プロジェクトリストを右クリックし、**Build Path > Configure Build Path**を選択して、JavaスタックとJDKが同じバージョンであることを確認します。
<br />

3. **Project Natures**を選択します。「**Java**」を検索し、リストから「**java**」を選択して**OK**をクリックします。
<br />

4. **Java Compiler**が選択されていることを確認し、**Apply and Close**をクリックしてプロジェクトにJavaコンパイラを追加します。
<br />

5. 次に、プロジェクトディレクトリを右クリックし、**Debug As > Debug Configuration**をクリックします。
<br />

6. *Remote Java Applications*を検索し、検索結果を右クリックして**New Configurations**を選択します。
<br />
**Debug Configurations**ポップアップが表示されます。

7. 以下の値でデバッガーを設定してください：
- *Connect*タブ:
    - プロジェクトディレクトリを選択します
    - Connection Typeを「**Standard (Socket Attach)**」に設定します
    - *Connection Properties*を以下のように設定します：
        - Host: **localhost**
        - Port: Catalyst CLIでデバッグ用に設定したポート番号を入力します
        <br />

- *Source*タブ:
    - **Add**ボタンをクリックし、関数ディレクトリを選択します
    <br />

必要な設定を適用したら、**Debug**をクリックします。

8. 関数ファイルを開き、コードに必要なデバッグポイントを設定して、次の手順に進みます。
<br />




--------------------------------------------------------------------------------
title: "Node.js"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.131Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/ide-config/nodejs/"
service: "All Services"
--------------------------------------------------------------------------------


# Node.js関数のデバッグ用IDE設定

このヘルプドキュメントでは、Visual Studio CodeでNode.jsの非HTTPSおよびIntegration関数のデバッグ設定を行う方法を説明します。

注意: この手順は、トンネリング済み関数をデバッグしたい場合にのみ適用され、以下のCLIコマンドを使用している場合に該当します：

catalyst functions:shell --tunnel tunnel-port-number --debug port-number<br />

関数のトンネリングのみを行い、以下のCLIコマンドを使用している場合は、IDE設定は不要です。

catalyst functions:shell --tunnel tunnel-port-number<br />

このコマンドは関数をトンネリングするのみで、関数のログをCatalyst CLIに出力します。


VS Code IDEのデバッガーを以下の方法で設定します：

1. デバッグが必要なすべての関数がローカルマシンにあることを確認し、該当するプロジェクトをVS Codeで開きます。
<br />

2. メニューバーの**Run/Debug**ボタンをクリックし、「**create a launch.json file**」オプションをクリックしてlaunch.jsonファイルを作成します。
<br />

設定を開始する前のlaunch.jsonファイルの表示は以下のとおりです。
<br />

3. 以下のJSONスニペットをコピーし、「**configurations**」JSONキーの値として貼り付けます。

"configurations": [{
			"name": "cron_fun",  // 名前は任意ですが、デバッグ時に同じ関数名にすると便利です
            		"type": "node",
            		"request": "attach",
            		"address": "localhost",
          		  "port": 9001, // catalyst functions:shell --tunnel 8001 --debug 9001で指定したデバッグポート番号。他のプロセスで使用されていない任意の番号を指定できます
            		"localRoot": "/Users/jack/tun_cli/functions/cron_fun" //Exact path where the function folder is present
    }],


4. このファイルを保存し、必要なコード行にブレークポイントを適用して、次の手順に進みます。
<br />


--------------------------------------------------------------------------------
title: "Python"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.131Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/ide-config/python/"
service: "All Services"
--------------------------------------------------------------------------------


# Python関数のデバッグ用IDE設定

このヘルプドキュメントでは、Visual Studio CodeでPythonの非HTTPSおよびIntegration関数のデバッグ設定を行う方法を説明します。

注意: この手順は、トンネリング済み関数をデバッグしたい場合にのみ適用され、以下のCLIコマンドを使用している場合に該当します：

catalyst functions:shell --tunnel tunnel-port-number --debug port-number<br />

関数のトンネリングのみを行い、以下のCLIコマンドを使用している場合は、IDE設定は不要です。

catalyst functions:shell --tunnel tunnel-port-number<br />

このコマンドは関数をトンネリングするのみで、関数のログをCatalyst CLIに出力します。


VS Code IDEのデバッガーを以下の方法で設定します：

1. デバッグが必要なすべての関数がローカルマシンにあることを確認し、該当するプロジェクトをVS Codeで開きます。
<br />

2. メニューバーの**Run/Debug**ボタンをクリックし、「**create a launch.json file**」オプションをクリックしてlaunch.jsonファイルを作成します。
<br />

設定を開始する前のlaunch.jsonファイルの表示は以下のとおりです。
<br />

3. 以下のJSONスニペットをコピーし、「**configurations**」JSONキーの値として貼り付けます。

"configurations":[{
        "name": "Python: Current File",
        "type": "debugpy",
        "request": "attach",
        "connect": {
            "host": "127.0.0.1",
            "port": 9001 //the debug port number which you have specified in the catalyst functions:shell --tunnel 8001 --debug 9001.
        },
        "justMyCode": true
}],


4. Visual Studio Code IDEでPython関数をデバッグするために、**Python Debugger** VS Code拡張機能をインストールします。

<br />

5. 以下のコマンドを使用して、Python関数のソースディレクトリにdebugpyをインストールします：
python3.9 -m pip install debugpy -t ./

<br />

6. 以下のコード行をコピーし、関数コードの冒頭に貼り付けます：
import debugpy
  debugpy.listen(9001) #specify the port for debugging
    print("Waiting for debugger to attach")
    debugpy.wait_for_client()
    print("debugger attached")


7. メインのPythonコードファイルの任意の場所でdebugpy.breakpoint()関数を使用してブレークポイントを設定します。
<br />


#### 関数スタック


> Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。



--------------------------------------------------------------------------------
title: "Java"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.141Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/debug-tunneled-func/java/"
service: "All Services"
--------------------------------------------------------------------------------


# トンネリング済みJava関数のデバッグ

Catalyst Webでトンネリング済み関数をトリガーし、以下の画像に示すようなメッセージをCatalyst CLIで確認して、デバッガーがアタッチされたことを確認します：
<br />

使用するIDEによっては、以下の手順が異なる場合があります。




### Visual Studio Code IDEでのトンネリング済みJava関数のデバッグ

1. **Run/Debug**アイコンをクリックし、デバッグしたい関数を選択します。
<br />

2. **Play**ボタンをクリックします。
<br />

これで、非HTTPSおよびIntegration関数を簡単にデバッグできます。
<br />




### IntelliJ IDEA IDEでのトンネリング済みJava関数のデバッグ

1. コードに必要なブレークポイントを設定し、**Run/Debug configurations**ボタンをクリックします。
<br />

2. ドロップダウンから前の手順で設定した*デバッガーファイル*を選択します。
<br />

3. Catalyst Webで関数がトリガーされ、Catalyst CLIでTunnelingリクエストが開始されたら、**Debug**ボタンをクリックしてデバッグを開始します。
<br />

コードのデバッグが完了したら、**stop-icon**をクリックして、IDEでデバッグセッションを*停止/終了*してください。これは、次のデバッグセッションに進む際にポートが占有されないようにするためです。
<br />




### Eclipse IDEでのトンネリング済みJava関数のデバッグ

1. コードに必要なブレークポイントを設定し、**debugger-icon**をクリックします。
<br />

2. 前の手順で設定した*デバッガーファイル*を選択します。
<br />

3. Catalyst WebでTunneling対応関数をトリガーしたら、IDEで**Debug**ボタンをクリックし、必要に応じて関数をデバッグします。
<br />

コードのデバッグが完了したら、**terminate-icon**をクリックして、IDEでデバッグセッションを終了してください。これは、次のデバッグセッションに進む際にポートが占有されないようにするためです。
<br />





--------------------------------------------------------------------------------
title: "Node.js"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.142Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/debug-tunneled-func/nodejs/"
service: "All Services"
--------------------------------------------------------------------------------


# トンネリング済みNode.js関数のデバッグ

Catalyst Webでトンネリング済み関数をトリガーし、以下の画像に示すようなメッセージをCatalyst CLIで確認して、デバッガーがアタッチされたことを確認します：
<br />

このヘルプドキュメントでは、Visual Studio Code IDEを使用したトンネリング済みNode.js関数のデバッグを説明します。使用するIDEによっては、以下の手順が異なる場合があります。

1. **Run/Debug**アイコンをクリックし、デバッグしたい関数を選択します。
<br />

2. **Play**ボタンをクリックします。
<br />

これで、非HTTPSおよびIntegration関数を簡単にデバッグできます。
<br />


--------------------------------------------------------------------------------
title: "Python"
description: "Catalyst Tunnelingは、リバースプロキシプロバイダーのTunneling URLを使用して、関数呼び出しをローカルシステムにルーティングすることで、非HTTPSおよびIntegration関数をデバッグできます。"
last_updated: "2026-07-02T09:34:22.142Z"
source: "https://docs.catalyst.zoho.com/ja/tools/tunneling/implementation/debug-tunneled-func/python/"
service: "All Services"
--------------------------------------------------------------------------------


# トンネリング済みPython関数のデバッグ

このヘルプドキュメントでは、Visual Studio Code IDEを使用したトンネリング済みPython関数のデバッグを説明します。使用するIDEによっては、以下の手順が異なる場合があります。

1. **Run/Debug**アイコンをクリックし、デバッグしたい関数を選択します。
<br />

2. **Play**ボタンをクリックします。
<br />

これで、非HTTPSおよびIntegration関数を簡単にデバッグできます。
<br />

Python関数の場合のみ、以下の画像に示すボタンをクリックしてデバッガーを切断してください。
<br />

デバッガーを切断しないと、他のTunnelingリクエストが実行できなくなります。