---
title: セッションごとに1つのサンドボックスを実行する
url: https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session
description: Kubernetes上のHelmチャート、スポーンスクリプト、またはSDKポーラーを使用して、各セッションに専用のセルフホスト型サンドボックスを割り当てます。
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: セルフホスト型Managed Agentsを除き、ZDRの適格対象ではありません。セッションはステートフルなリソースであり、トランスクリプトは削除するまで保持されます。
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
---

「sandbox-per-session」（セッションごとのサンドボックス）パターンでは、各セッションは新しいサンドボックスで実行され、サンドボックスごとに独自のファイルシステム、リソース制限、ネットワーク制御を持つことができます。他のパターンと比較するには、[デプロイパターンを選択する](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern)を参照してください。

このパターンは次の3つの方法でセットアップできます。

* **[Kubernetes上のHelmチャート](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes)：** Anthropicのディスパッチャーがワークを取得し、クラスター上でセッションごとにPodを起動します。
* **[スポーンスクリプト](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script)：** `ant` CLIがワークを取得してスクリプトを呼び出し、スクリプトが任意のプラットフォーム上でサンドボックスを起動します。
* **[SDKポーラー](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller)：** 独自のコードがワークを取得し、サンドボックスを起動します。

[Kubernetes上でサンドボックスを実行する](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes)以降のセクションは、スポーンスクリプトとSDKポーラーに適用されます。

## Kubernetes上でサンドボックスを実行する

Anthropicは、Helmチャート`cma-sandboxes`とそのイメージを公開しています。このチャートは、独自のKubernetesクラスター上でセッションごとに1つのサンドボックスを実行します。チャートのディスパッチャーは環境のワークキューをポーリングし、各セッションに専用のPodを割り当てます。

* **分離：** 各Podは、チャートのネットワークポリシーの背後で[gVisor](https://gvisor.dev/)の下で実行されます。Podは独自のファイルシステムとリソース制限を持ちます。環境キーを保持するのはディスパッチャーのみです。
* **セッションアフィニティ：** セッション内のすべてのメッセージは、そのセッションのサンドボックスに送られます。セッションが30分間（チャートの`sandbox.idleTimeout`設定のデフォルト値）アイドル状態になると、そのPodは停止します。`/workspace`ボリュームはセッションが終了するまで残ります。次のメッセージが届くと、同じボリューム上でPodが起動します。
* **ウォームプール：** Google Kubernetes Engine（GKE）以外では、チャートは新しいセッションのために2つのPodを待機状態に保ちます（チャートの`sandbox.warmPoolSize`設定のデフォルト値）。

サンドボックスPodは`ant` CLIワーカーを実行します。デフォルトの同期設定で[メモリストア](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory)をサポートしますが、[カスタムツール](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-custom-tools)はサポートしません。

### チャートをインストールする

このチャートは、GKE、Amazon EKS、およびその他のクラスターで動作します。インストールする前に、以下をセットアップしてください。

* **クラスター内：** [Agent Sandbox](https://github.com/kubernetes-sigs/agent-sandbox)コントローラー（GKEではAgent Sandboxアドオン）、gVisorを実行するノード、およびNetworkPolicyを適用するネットワークプラグイン。
* **独自のnamespace内：** Restricted Pod Security Standardのラベル、環境IDと[環境キー](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes#run-your-first-session)を含むSecret、およびディスパッチャーのTLS証明書。

[GitHub上のインストールガイド](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md)には、クラスターの種類ごとのセットアップ手順が記載されています。アップグレードとキーローテーションについても説明されています。

設定を`cma-values.yaml`として保存します。このファイル内の3つの設定がないと、インストールは失敗します。

<File filename="cma-values.yaml">
  ```yaml
  platform: gke             # or eks, or generic for any other cluster
  egress:
    # The chart already blocks the private ranges. List your other addresses
    # that sandboxes must not reach.
    clusterCIDRs:
      - 203.0.113.10/32     # your cluster's Kubernetes API endpoint
    cmaServer:
      public: true          # the Claude API has a public address
  ```
</File>

インストールガイドには、GKE Autopilotでの`gke.dns`など、クラスターに依存する設定が記載されています。また、`egress.clusterIsPrivate: true`が`egress.clusterCIDRs`の代わりになる場合についても説明されています。

次に、チャートをインストールします。

```bash
helm install cma \
  oci://us-docker.pkg.dev/anthropic-public-registry/sandboxes/charts/cma-sandboxes \
  --version 0.1.0 \
  --namespace cma \
  -f cma-values.yaml \
  --wait
```

インストール後、インストールガイドに記載されているプリフライトチェックを実行してください。

<Warning>
  `helm uninstall`だけでチャートを削除しないでください。このコマンドはネットワークポリシーを削除し、セッションのサンドボックスをネットワークポリシーなしで実行されたままにします。[インストールガイドのRemovalセクション](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#removal)に記載されている順序で、まずディスパッチャーを停止し、サンドボックスを削除してください。
</Warning>

### サンドボックスイメージにツールを追加する

公開されているサンドボックスイメージは、`bash`、`curl`、`jq`、および`ant` CLIを含むAlpine Linuxです。チャートはこのイメージを読み取り専用のルートファイルシステムかつ非rootユーザーとして実行するため、エージェントはセッション中にパッケージをインストールできません。

PythonやGitなど、エージェントにより多くのツールを提供するには、リリースのタグでリポジトリから両方のイメージをビルドします。コマンドは[インストールガイドのInstallセクション](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#install)に記載されています。イメージを`cma-dispatcher`および`cma-sandbox`としてレジストリにプッシュし、チャートのバージョンをタグとして付けます。次に、`image.registry`をそのレジストリに設定します。イメージダイジェストを固定する場合は、独自のイメージのダイジェストを使用してください。

### ネットワークエグレスを制限する

デフォルトでは、チャートのネットワークポリシーにより、サンドボックスはパブリックIPv4インターネットに到達できます。プライベートアドレス範囲、クラウドメタデータサーバー、および`egress.clusterCIDRs`内のアドレスはブロックされます。プロンプトインジェクションを受けたエージェントは、読み取った内容をサンドボックスが到達できる任意のアドレスに送信できます。詳細は、インストールガイドの[Network egress](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#network-egress)を参照してください。

* **Dataplane V2を使用するGKE：** `egress.mode: fqdnGke`を設定すると、接続を`egress.fqdnGke.hosts`内のホストのポート443に制限できます。`api.anthropic.com`をこのリストに残し、エージェントのコマンドが必要とするすべてのホストを追加してください。デフォルトとは異なり、このモードにはブロックされる範囲のリストがありません。リストされたホスト名が解決される任意のアドレスを許可するため、DNSを信頼できるホストのみをリストしてください。それでも、サンドボックスはDNSルックアップ内でデータを外部に送信できます。
* **その他のクラスターおよびDataplane V2を使用しないGKE：** デフォルトが唯一のモードです。
* **すべてのクラスター：** ネットワークポリシーは、クラスター自身のノードがリッスンするポートをカバーしません。インストールガイドの[Node isolation you own](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#node-isolation-you-own)を参照してください。

## スポーンスクリプトでサンドボックスを起動する

ホスト上のポーラーがワークを取得し、「work item」（ワークアイテム）ごとにスクリプトを1回呼び出します。スクリプトはその1つのセッション用のサンドボックスを起動します。

<Steps>
  <Step title="サンドボックスイメージをビルドする">
    `ant`をインストールし、`ant beta:worker run`をエントリポイントとして設定します。サンドボックスが起動すると、環境変数からセッションの詳細を読み取り、そのセッションを処理して終了します。ベースイメージは`/bin/bash`を提供する必要があります。ビルドでは`ant`のダウンロードにのみ`curl`を使用します。

    <File filename="Dockerfile">
      ```dockerfile
      FROM your-base-image
      ARG ANT_VERSION=2.11.0
      ARG TARGETARCH
      RUN ARCH=$([ "$TARGETARCH" = "arm64" ] && echo arm64 || echo amd64) && \
          curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${ANT_VERSION}/ant_${ANT_VERSION}_linux_${ARCH}.tar.gz" \
            | tar -xz -C /usr/local/bin ant
      WORKDIR /workspace
      VOLUME /workspace
      ENTRYPOINT ["ant", "beta:worker", "run"]
      ```
    </File>
  </Step>

  <Step title="スポーンスクリプトを書く">
    スクリプトはセッションの詳細を新しいサンドボックスに転送します。ポーラーホスト上に`jq`が必要です。

    <File filename="spawn.sh">
      ```bash
      #!/bin/bash
      # spawn.sh: 取得したワークアイテムごとに1回呼び出されます
      # 取得したワークアイテムは、stdin経由でJSONとして渡されます。
      ANTHROPIC_WORK_SECRET="$(jq -r '.secret // empty')"
      export ANTHROPIC_WORK_SECRET
      mkdir -p "/host/outputs/$ANTHROPIC_SESSION_ID"
      exec docker run --rm \
        -e ANTHROPIC_SESSION_ID -e ANTHROPIC_ENVIRONMENT_KEY \
        -e ANTHROPIC_WORK_ID -e ANTHROPIC_ENVIRONMENT_ID -e ANTHROPIC_BASE_URL \
        -e ANTHROPIC_WORK_SECRET \
        -v "/host/outputs/$ANTHROPIC_SESSION_ID":/workspace \
        your-image
      ```
    </File>

    ポーラーは`ANTHROPIC_WORK_ID`、`ANTHROPIC_ENVIRONMENT_ID`、`ANTHROPIC_SESSION_ID`、`ANTHROPIC_ENVIRONMENT_KEY`を設定します。`ANTHROPIC_BASE_URL`は、ポーラーのホストで設定した場合にのみスクリプトに渡されます。スクリプトは、標準入力上のワークアイテムのJSONから`ANTHROPIC_WORK_SECRET`を読み取ります。[環境変数](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-reference#environment-variables)を参照してください。

    `/host/outputs`は任意に選択するホストディレクトリです。これを`/workspace`にマウントすると、サンドボックスの終了後にセッションの成果物を取り出せます。このマウントには、ダウンロードされた`skills/`ツリーや中間ファイルも含まれます。
  </Step>

  <Step title="ポーラーを起動する">
    ```bash
    ant beta:worker poll --on-work ./spawn.sh
    ```
  </Step>
</Steps>

## ワークアイテムのシークレットを転送する

取得した各ワークアイテムは、Anthropicがそのセッションに対して発行する`secret` (csharp, go: `Secret`)を持つことがあります。セッションを実行するワーカーは、[メモリストア](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory)をマウントするためにこれを必要とします。

1つのプロセス内でセッションを取得して実行するワーカーは、シークレットを自ら受け渡します。`run()` (go: `Run()`)を使用する`EnvironmentWorker`はそのようなワーカーの1つであり、`--on-work`なしの`ant beta:worker poll`もその1つです。取得とワーカーの間に独自のコードが入る場合は、シークレットを自分で転送します。

| ワークを取得する方法                                                                                                       | シークレットの受け取り方                              | ワーカーへの渡し方                                                                                                                                                             |
| ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ant beta:worker poll --on-work`                                                                                 | スクリプトの標準入力上のワークアイテムJSONの`secret`フィールド     | サンドボックスの環境内の`ANTHROPIC_WORK_SECRET`                                                                                                                                   |
| Python、TypeScript、またはGo SDKの`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`) | 取得した各ワークアイテムの`secret` (go: `Secret`)フィールド | サンドボックスの環境内の`ANTHROPIC_WORK_SECRET`、または`handle_item()` (typescript: `handleItem()`; go: `HandleItem()`)への`work_secret` (typescript: `workSecret`; go: `WorkSecret`)引数 |

シークレットは、そのセッションを処理するサンドボックスにのみ渡し、決してログに記録しないでください。環境キーとの関係については、[セキュリティモデル](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-security)を参照してください。

## SDKポーラーからサンドボックスを起動する

`ant beta:worker poll --on-work`の代わりに独自のコードからワークを取得するには、Python、TypeScript、またはGo SDKのポーラー`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`)を使用します。ポーラーはキューをポーリングして取得した各セッションを渡し、サンドボックスの起動は独自のコードで行います。

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    ループでワークを取得し、セッションごとにサンドボックスを起動するには、単一のシェルコマンドよりも多くのロジックが必要です。シェルからは、[スポーンスクリプトでサンドボックスを起動する](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script)のように、スポーンスクリプトを指定して`ant beta:worker poll --on-work`を実行してください。
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    シェルからワークを取得してセッションごとにサンドボックスを起動するには、スポーンスクリプトを指定して`ant beta:worker poll --on-work`を実行します。[スポーンスクリプトでサンドボックスを起動する](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script)を参照してください。
  </CodeGroupItem>

  ```python Python
  import asyncio
  import os

  from anthropic import AsyncAnthropic
  from anthropic.types.beta.environments import BetaSelfHostedWork

  SANDBOX_ENV = (
      "ANTHROPIC_ENVIRONMENT_ID",
      "ANTHROPIC_ENVIRONMENT_KEY",
      "ANTHROPIC_WORK_ID",
      "ANTHROPIC_SESSION_ID",
      "ANTHROPIC_WORK_SECRET",
      "ANTHROPIC_BASE_URL",  # forwarded only when set on this host
  )


  async def launch_container(work: BetaSelfHostedWork) -> None:
      print(f"claimed session {work.data.id}")
      # `docker run` を独自のサンドボックスランチャーに置き換えてください。環境
      # キー（APIキーは絶対に渡さないでください）とワークアイテムのセッションごとのシークレットを転送します。内部の
      # ワーカーはセッションのメモリストアをマウントするためにシークレットを必要とします。
      env = os.environ | {
          "ANTHROPIC_WORK_ID": work.id,
          "ANTHROPIC_SESSION_ID": work.data.id,
          "ANTHROPIC_WORK_SECRET": work.secret or "",
      }
      forward = [arg for name in SANDBOX_ENV for arg in ("-e", name)]
      launcher = await asyncio.create_subprocess_exec(
          "docker", "run", "--rm", "--detach", *forward, "your-image", env=env
      )
      await launcher.wait()


  async def main() -> None:
      environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
      async with AsyncAnthropic(auth_token=environment_key) as client:
          async for work in client.beta.environments.work.poller(
              environment_id=environment_id,
              environment_key=environment_key,
              auto_stop=False,  # the launched sandbox owns the stop call
          ):
              await launch_container(work)


  asyncio.run(main())
  ```

  ```typescript TypeScript
  import { spawn } from "node:child_process";
  import { once } from "node:events";
  import Anthropic from "@anthropic-ai/sdk";
  import { WorkPoller } from "@anthropic-ai/sdk/helpers/beta/environments";
  import type { BetaSelfHostedWork } from "@anthropic-ai/sdk/resources/beta/environments";

  const SANDBOX_ENV = [
    "ANTHROPIC_ENVIRONMENT_ID",
    "ANTHROPIC_ENVIRONMENT_KEY",
    "ANTHROPIC_WORK_ID",
    "ANTHROPIC_SESSION_ID",
    "ANTHROPIC_WORK_SECRET",
    "ANTHROPIC_BASE_URL" // forwarded only when set on this host
  ];

  const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
  const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
  const client = new Anthropic({ authToken: environmentKey });

  async function launchContainer(work: BetaSelfHostedWork): Promise<void> {
    console.log(`claimed session ${work.data.id}`);
    // `docker run` を独自のサンドボックスランチャーに置き換えてください。環境
    // キー（APIキーは絶対に渡さないでください）とワークアイテムのセッションごとのシークレットを転送します。内部の
    // ワーカーは、セッションのメモリストアをマウントするためにこのシークレットを必要とします。
    const env = {
      ...process.env,
      ANTHROPIC_WORK_ID: work.id,
      ANTHROPIC_SESSION_ID: work.data.id,
      ANTHROPIC_WORK_SECRET: work.secret ?? ""
    };
    const forward = SANDBOX_ENV.flatMap((name) => ["-e", name]);
    const launcher = spawn("docker", ["run", "--rm", "--detach", ...forward, "your-image"], {
      env,
      stdio: "inherit"
    });
    await once(launcher, "close");
  }

  const poller = new WorkPoller({
    client,
    environmentId,
    environmentKey,
    autoStop: false // the launched sandbox owns the stop call
  });

  for await (const work of poller) {
    await launchContainer(work);
  }
  ```

  <CodeGroupItem language="C#">
    C# SDKにはワークをポーリングするヘルパーがありません。独自のコードからワークを取得するには、[Environments Workエンドポイント](https://platform.claude.com/docs/ja/api/beta/environments/work)を呼び出してアイテムをポーリングし、確認応答を送信してください。
  </CodeGroupItem>

  ```go Go
  package main

  import (
  	"context"
  	"fmt"
  	"log"
  	"os"
  	"os/exec"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
  	"github.com/anthropics/anthropic-sdk-go/v2/option"
  	"github.com/anthropics/anthropic-sdk-go/v2/packages/param"
  )

  var sandboxEnv = []string{
  	"ANTHROPIC_ENVIRONMENT_ID",
  	"ANTHROPIC_ENVIRONMENT_KEY",
  	"ANTHROPIC_WORK_ID",
  	"ANTHROPIC_SESSION_ID",
  	"ANTHROPIC_WORK_SECRET",
  	"ANTHROPIC_BASE_URL", // forwarded only when set on this host
  }

  func launchContainer(ctx context.Context, work *anthropic.BetaSelfHostedWork) error {
  	fmt.Printf("claimed session %s\n", work.Data.ID)
  	// `docker run` は独自のサンドボックスランチャーに置き換えてください。環境
  	// キー（APIキーは絶対に渡さないでください）とワークアイテムのセッションごとのシークレットを転送します。内部のワーカーは
  	// セッションのメモリストアをマウントするためにこのシークレットを必要とします。
  	args := []string{"run", "--rm", "--detach"}
  	for _, name := range sandboxEnv {
  		args = append(args, "-e", name)
  	}
  	launcher := exec.CommandContext(ctx, "docker", append(args, "your-image")...)
  	launcher.Env = append(os.Environ(),
  		"ANTHROPIC_WORK_ID="+work.ID,
  		"ANTHROPIC_SESSION_ID="+work.Data.ID,
  		"ANTHROPIC_WORK_SECRET="+work.Secret,
  	)
  	launcher.Stdout, launcher.Stderr = os.Stdout, os.Stderr
  	return launcher.Run()
  }

  func main() {
  	environmentID := os.Getenv("ANTHROPIC_ENVIRONMENT_ID")
  	environmentKey := os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")

  	client := anthropic.NewClient(option.WithAuthToken(environmentKey))

  	ctx := context.Background()

  	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		AutoStop:       param.NewOpt(false), // the launched sandbox owns the stop call
  	})
  	defer poller.Close()

  	for work, err := range poller.All() {
  		if err != nil {
  			log.Fatal(err)
  		}
  		if err := launchContainer(ctx, work); err != nil {
  			log.Fatal(err)
  		}
  	}
  }
  ```

  <CodeGroupItem language="Java">
    Java SDKにはワークをポーリングするヘルパーがありません。独自のコードからワークを取得するには、[Environments Workエンドポイント](https://platform.claude.com/docs/ja/api/beta/environments/work)を呼び出してアイテムをポーリングし、確認応答を送信してください。
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    PHP SDKにはワークをポーリングするヘルパーがありません。独自のコードからワークを取得するには、[Environments Workエンドポイント](https://platform.claude.com/docs/ja/api/beta/environments/work)を呼び出してアイテムをポーリングし、確認応答を送信してください。
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Ruby SDKにはワークをポーリングするヘルパーがありません。独自のコードからワークを取得するには、[Environments Workエンドポイント](https://platform.claude.com/docs/ja/api/beta/environments/work)を呼び出してアイテムをポーリングし、確認応答を送信してください。
  </CodeGroupItem>
</CodeGroup>

## サンドボックス内でSDKワーカーを実行する

サンドボックスが[カスタムツールを提供する](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-custom-tools)必要がある場合や、[デフォルト以外のメモリ同期設定](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory#configure-sync)を使用する必要がある場合は、`ant beta:worker run`エントリポイントをSDKエントリポイントに置き換えます。このエントリポイントは`EnvironmentWorker`を構築し、`handle_item()` (typescript: `handleItem()`; go: `HandleItem()`)を呼び出します。これは、スポーンスクリプトが転送するのと同じ`ANTHROPIC_*`変数を読み取ります。

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    ワーカーは単一のHTTPリクエストではなく、長時間実行されるプロセスです。カスタムツールを提供したりメモリ同期設定を変更したりするには、Python、TypeScript、またはGo SDKの`EnvironmentWorker`を使用してください。
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    `ant` CLIワーカー（`ant beta:worker run`）は、カスタムツールを提供したりメモリ同期設定を変更したりできません。いずれかを行うには、Python、TypeScript、またはGo SDKの`EnvironmentWorker`を使用してください。
  </CodeGroupItem>

  ```python Python
  import asyncio
  import contextlib
  import os
  import signal
  from anthropic import AsyncAnthropic
  from anthropic.lib.environments import EnvironmentWorker


  async def main() -> None:
      async with AsyncAnthropic(
          auth_token=os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      ) as client:
          worker = EnvironmentWorker(client, workdir="/workspace")
          # 引数なしの場合、handle_item() はスポーンスクリプトが転送した
          # ANTHROPIC_* 変数（ANTHROPIC_WORK_SECRET を含む）を読み取ります。
          task = asyncio.create_task(worker.handle_item())
          # コンテナ停止時にタスクをキャンセルすると、ワーカーは終了前に
          # 変更されたメモリファイルをアップロードし、ストアディレクトリを削除できます。
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task


  asyncio.run(main())
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { EnvironmentWorker } from "@anthropic-ai/sdk/helpers/beta/environments";

  const client = new Anthropic({ authToken: process.env.ANTHROPIC_ENVIRONMENT_KEY });
  const controller = new AbortController();
  // コンテナ停止時に中断することで、ワーカーは変更されたメモリ
  // ファイルをアップロードし、終了前にストアディレクトリを削除できます。
  process.once("SIGTERM", () => controller.abort());
  process.once("SIGINT", () => controller.abort());

  // 引数なしの場合、handleItem() はスポーンスクリプトが転送した ANTHROPIC_* 変数を
  // 読み取ります（ANTHROPIC_WORK_SECRET を含む）。
  await new EnvironmentWorker({
    client,
    workdir: "/workspace",
    signal: controller.signal
  }).handleItem();
  ```

  <CodeGroupItem language="C#">
    C# SDKには`EnvironmentWorker`がありません。
  </CodeGroupItem>

  ```go Go
  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
  	"github.com/anthropics/anthropic-sdk-go/v2/option"
  )

  func main() {
  	// コンテナ停止時にコンテキストをキャンセルすることで、ワーカーは終了前に
  	// 変更されたメモリファイルをアップロードし、ストアディレクトリを削除できます。
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := anthropic.NewClient(option.WithAuthToken(os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")))
  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// オプションがゼロ値の場合、HandleItem はスポーンスクリプトが転送した
  	// ANTHROPIC_* 変数(ANTHROPIC_WORK_SECRET を含む)を読み取ります。
  	if err := worker.HandleItem(ctx, environments.HandleItemOptions{}); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    Java SDKには`EnvironmentWorker`がありません。
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    PHP SDKには`EnvironmentWorker`がありません。
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Ruby SDKには`EnvironmentWorker`がありません。
  </CodeGroupItem>
</CodeGroup>

## セッション用のファイルをステージングする

Anthropicは、セルフホスト型サンドボックスにファイルやGitHubリポジトリをマウントしません。セッション固有のファイルを利用可能にするには、次の手順を実行します。

1. S3パスやコミットSHAなどのファイル参照を、セッションの`metadata` (csharp, go: `Metadata`)フィールドで渡します。
2. スポーンスクリプトまたは`--on-work`ハンドラー内で、セッションを取得し（`GET /v1/sessions/{session_id}`）、`metadata` (csharp, go: `Metadata`)を読み取ります。取得したワークアイテムにはセッションIDが含まれますが、メタデータは含まれません。
3. ツールが実行される前に、ファイルを作業ディレクトリにステージングします。

cURLのサンプルは、`ANTHROPIC_AUTH_TOKEN`からアクセストークンを読み取ります。トークンを入手するには、[フェデレーションのセットアップ](https://platform.claude.com/docs/ja/manage-claude/workload-identity-federation#set-up-federation)の説明に従って、デフォルトの`workspace:developer`スコープでWorkload Identity Federationをセットアップします。次に、[ワークロードからの認証](https://platform.claude.com/docs/ja/manage-claude/workload-identity-federation#authenticate-from-your-workload)に示すように、ワークロードのIDトークンをアクセストークンと交換します。`ANTHROPIC_AUTH_TOKEN`はフェデレーション設定よりも優先されるため、cURLのサンプルを実行するシェルでのみ設定してください。[認証](https://platform.claude.com/docs/ja/manage-claude/authentication)には、クイックスタートのAPIキーなど、APIが受け付けるその他の認証情報が記載されています。

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
    -H "authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "agent_011CYm1BLqPXpQRk5khsSXrs",
      "environment_id": "env_01595EKxaaTTGwwY3kyXdtbs",
      "metadata": {"input_file": "s3://my-bucket/data.csv"}
    }'
  ```

  ```bash CLI
  ant beta:sessions create \
    --agent agent_011CYm1BLqPXpQRk5khsSXrs \
    --environment-id env_01595EKxaaTTGwwY3kyXdtbs \
    --metadata '{"input_file": "s3://my-bucket/data.csv"}'
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      metadata={"input_file": "s3://my-bucket/data.csv"},
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    metadata: { input_file: "s3://my-bucket/data.csv" }
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Metadata = new Dictionary<string, string> { ["input_file"] = "s3://my-bucket/data.csv" },
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
  	EnvironmentID: environment.ID,
  	Metadata: map[string]string{
  		"input_file": "s3://my-bucket/data.csv",
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .metadata(SessionCreateParams.Metadata.builder()
          .putAdditionalProperty("input_file", JsonValue.from("s3://my-bucket/data.csv"))
          .build())
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      metadata: ['input_file' => 's3://my-bucket/data.csv'],
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    metadata: {input_file: "s3://my-bucket/data.csv"}
  )
  ```
</CodeGroup>

## 次のステップ

<CardGroup cols={2}>
  <Card title="セルフホストワーカーの監視とトラブルシューティング" icon="lightning" href="https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-operations">
    キューの深さを確認し、セッションとワーカーを正常に停止し、一般的な障害を修正します。
  </Card>
</CardGroup>
