---
title: クラウド環境のセットアップ
url: https://platform.claude.com/docs/ja/managed-agents/environments
description: セッション用のクラウドサンドボックスをカスタマイズします。
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

環境（environment）は、エージェントが実行されるサンドボックスの構成を定義します。環境を一度作成すれば、セッションを開始するたびにそのIDを参照できます。複数のセッションで同じ環境を共有できますが、各セッションにはそれぞれ独立したサンドボックス（新しいLinuxコンテナ）が割り当てられます。

このページでは `type: cloud` 環境について説明します。独自のインフラストラクチャ上でサンドボックスを実行するには、[セルフホスト型サンドボックス](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes)を参照してください。両者のどちらを選ぶかについては、[エージェント環境の選択](https://platform.claude.com/docs/ja/managed-agents/choosing-an-environment)を参照してください。

## 環境を作成する

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "name": "python-dev",
      "config": {
        "type": "cloud",
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: python-dev
      config:
        type: cloud
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/ja/cli-sdks-libraries/cli/apply) は `environment.yaml` から環境を作成し、そのIDを出力して `claude-lock.json` に記録します。`claude-lock.json` をコミットしておくと、次回の `ant apply` で環境を再作成しようとするのではなく、この環境が更新されます。
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="python-dev",
      config={
          "type": "cloud",
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )

  print(f"Environment ID: {environment.id}")
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "python-dev",
    config: {
      type: "cloud",
      networking: { type: "limited", allow_package_managers: true }
    }
  });

  console.log(`Environment ID: ${environment.id}`);
  ```

  ```csharp C#
  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "python-dev",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });

  Console.WriteLine($"Environment ID: {environment.ID}");
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "python-dev",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("Environment ID: %s\n", environment.ID)
  ```

  ```java Java
  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("python-dev")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  IO.println("Environment ID: " + environment.id());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'python-dev',
      config: [
          'type' => 'cloud',
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  echo "Environment ID: {$environment->id}\n";
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "python-dev",
    config: {
      type: "cloud",
      networking: {type: "limited", allow_package_managers: true}
    }
  )

  puts "Environment ID: #{environment.id}"
  ```
</CodeGroup>

環境を区別できるように、一意でわかりやすい `name` (csharp, go: `Name`) を使用してください。この例では、パッケージマネージャーを許可した `limited` [ネットワーキング](https://platform.claude.com/docs/ja/managed-agents/environments#networking)を使用しているため、サンドボックスはパッケージレジストリとコードホストにアクセスできます。その他のホストへのアクセスを許可するには、それらを `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に追加してください。

## セッションで環境を使用する

[セッションを作成する](https://platform.claude.com/docs/ja/managed-agents/sessions)際に、環境IDを文字列として渡します。

<CodeGroup>
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create --agent "$AGENT_ID" --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

## 構成オプション

### パッケージ

`packages` (csharp, go: `Packages`) フィールドは、エージェントの起動前にサンドボックスへパッケージをプリインストールします。パッケージはそれぞれのパッケージマネージャーによってインストールされ、同じ環境を共有するセッション間でキャッシュされます。複数のパッケージマネージャーが指定されている場合は、アルファベット順（apt、cargo、gem、go、npm、pip）に実行されます。必要に応じて特定のバージョンを固定できます。バージョンを固定していないパッケージは最新バージョンがインストールされます。環境で `limited` [ネットワーキング](https://platform.claude.com/docs/ja/managed-agents/environments#networking)を使用している場合は、`networking` (csharp, go: `Networking`) 内の `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) も `true` に設定してください。設定しない場合、リクエストは400エラーで拒否されます。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "name": "data-analysis",
      "config": {
        "type": "cloud",
        "packages": {
          "pip": ["pandas", "numpy", "scikit-learn"],
          "npm": ["express"]
        },
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: data-analysis
      config:
        type: cloud
        packages:
          pip:
            - pandas
            - numpy
            - scikit-learn
          npm:
            - express
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="data-analysis",
      config={
          "type": "cloud",
          "packages": {
              "pip": ["pandas", "numpy", "scikit-learn"],
              "npm": ["express"],
          },
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: ["pandas", "numpy", "scikit-learn"],
        npm: ["express"]
      },
      networking: { type: "limited", allow_package_managers: true }
    }
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Environments;

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "data-analysis",
      Config = new BetaCloudConfigParams
      {
          Packages = new()
          {
              Pip = ["pandas", "numpy", "scikit-learn"],
              Npm = ["express"],
          },
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "data-analysis",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Packages: anthropic.BetaPackagesParams{
  				Pip: []string{"pandas", "numpy", "scikit-learn"},
  				Npm: []string{"express"},
  			},
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("data-analysis")
      .config(BetaCloudConfigParams.builder()
          .packages(BetaPackagesParams.builder()
              .pip(List.of("pandas", "numpy", "scikit-learn"))
              .npm(List.of("express"))
              .build())
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'data-analysis',
      config: [
          'type' => 'cloud',
          'packages' => [
              'pip' => ['pandas', 'numpy', 'scikit-learn'],
              'npm' => ['express'],
          ],
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: %w[pandas numpy scikit-learn],
        npm: %w[express]
      },
      networking: {type: "limited", allow_package_managers: true}
    }
  )
  ```
</CodeGroup>

サポートされているパッケージマネージャー：

| フィールド   | パッケージマネージャー        | 例                                           |
| ------- | ------------------ | ------------------------------------------- |
| `apt`   | システムパッケージ（apt-get） | `"graphviz"`                                |
| `cargo` | Rust（cargo）        | `"hyperfine@1.18.0"`                        |
| `gem`   | Ruby（gem）          | `"rails:7.1.0"`                             |
| `go`    | Goモジュール            | `"golang.org/x/tools/cmd/goimports@latest"` |
| `npm`   | Node.js（npm）       | `"express@4.18.0"`                          |
| `pip`   | Python（pip）        | `"sqlalchemy==2.0.30"`                      |

### ネットワーキング

`networking` (csharp, go: `Networking`) フィールドは、サンドボックスのアウトバウンドネットワークアクセスを制御します。

`limited` ネットワーキングでは、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) はAnthropicのサーバー上で実行される `web_search` ツールと `web_fetch` ツールにも適用されます。`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に一致しないホスト上のURLに対する `web_fetch` 呼び出しは、エージェントにエラー結果を返します。`web_search` は、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に一致しないホストからの結果を除外します。`allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) と `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) は、これらのツールに対してホストを追加しません。`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) にホストが1つも記載されていない場合、`web_fetch` や `web_search` の呼び出しはページも検索結果も返しません。これらのツールのために `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に追加したホストは、サンドボックスにも開放されます。`unrestricted` ネットワーキングおよびセルフホスト型環境では、これらのツールは制限されません。さらに制限するには、エージェントのツールセット内のツールのエントリに `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) または `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) を設定してください。[Web検索とWebフェッチのドメインを制限する](https://platform.claude.com/docs/ja/managed-agents/tools-web-restrictions)を参照してください。

| モード            | 説明                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limited`      | サンドボックスのネットワークアクセスを `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) 内のホストに制限します。追加のアクセスを許可するには、`allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) と `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) を `true` に設定します。エージェントが事前に列挙できないサイトにアクセスする必要がない限り、このモードを使用してください。 |
| `unrestricted` | 一般的な安全ブロックリストを除き、完全なアウトバウンドネットワークアクセスを許可します。使用する前に、[無制限ネットワーキングのリスク](https://platform.claude.com/docs/ja/managed-agents/environments#risks-of-unrestricted-networking)をお読みください。                                                                                                                                                                                                                                     |

<Note>
  APIリクエストでは `networking` (csharp, go: `Networking`) を明示的に設定してください。これを省略した作成リクエストは `unrestricted` になります。Claude Consoleの環境作成フォームは、**Limited** が選択され、他に何も許可されていない状態で始まります。
</Note>

次の例では、`limited` ネットワーキングを使用する環境を作成します。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "api-access",
      "config": {
        "type": "cloud",
        "networking": {
          "type": "limited",
          "allowed_hosts": ["api.example.com"],
          "allow_mcp_servers": true,
          "allow_package_managers": true
        }
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: api-access
      config:
        type: cloud
        networking:
          type: limited
          allowed_hosts:
            - api.example.com
          allow_mcp_servers: true
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="api-access",
      config={
          "type": "cloud",
          "networking": {
              "type": "limited",
              "allowed_hosts": ["api.example.com"],
              "allow_mcp_servers": True,
              "allow_package_managers": True,
          },
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: ["api.example.com"],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Environments;

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "api-access",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowedHosts = ["api.example.com"],
              AllowMcpServers = true,
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "api-access",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowedHosts:         []string{"api.example.com"},
  					AllowMCPServers:      anthropic.Bool(true),
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("api-access")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowedHosts(List.of("api.example.com"))
              .allowMcpServers(true)
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'api-access',
      config: [
          'type' => 'cloud',
          'networking' => [
              'type' => 'limited',
              'allowed_hosts' => ['api.example.com'],
              'allow_mcp_servers' => true,
              'allow_package_managers' => true,
          ],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: %w[api.example.com],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  )
  ```
</CodeGroup>

<Info>
  明示的な `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) リストとともに `limited` ネットワーキングを使用してください。エージェントに必要な最小限のネットワークアクセスのみを付与する「principle of least privilege」（最小権限の原則）に従い、許可したドメインを定期的に監査してください。
</Info>

`limited` ネットワーキングで他のフィールドを何も設定しない場合、許可されるホストはありません。セッションにアタッチしたファイル、メモリストア、GitHubリポジトリは引き続き利用できます。サンドボックスからのポート80または443へのリクエストが、ホストが許可されていないために拒否された場合、ブロックされたホスト名を示す403レスポンスが返されます。

`limited` ネットワーキングを使用する場合：

* `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) は、サンドボックスがアクセスできるドメインを指定します。ホスト名のみ、またはワイルドカードパターン（`*.example.com` など）を指定してください。URLスキーム、ポート、パスは含めないでください。ホスト名のみの指定はそのホストに完全一致します。`example.com` は `www.example.com` に一致しません。`*.example.com` は `example.com` のすべてのサブドメインに一致しますが、`example.com` 自体には一致しません。
* `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) は、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) 配列に記載されたもの以外に、エージェントに構成されたMCPサーバーエンドポイントへのアウトバウンドアクセスを許可します。デフォルトは `false` です。`false` の間は、エージェントが `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に含まれないホストのMCPサーバーを宣言していると、セッションの作成は400エラーで失敗します。[エージェントが委任できるエージェント](https://platform.claude.com/docs/ja/managed-agents/multiagent-orchestration)についても同様です。これを解決するには、ホストを `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に追加するか、`allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) を `true` に設定してください。
* `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) は、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) 配列に記載されたもの以外に、一連の公開パッケージレジストリとコードホストへのアウトバウンドアクセスを許可します。一覧については[パッケージマネージャーのホスト](https://platform.claude.com/docs/ja/managed-agents/environments#package-manager-hosts)を参照してください。デフォルトは `false` です。環境で `packages` (csharp, go: `Packages`) を指定する場合は、必ず `true` に設定してください。設定しない場合、レジストリのホストが `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に記載されていても、リクエストは400エラーで拒否されます。

#### パッケージマネージャーのホスト

`allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) が `true` の場合、サンドボックスは `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) 内のホストに加えて、次のホストにアクセスできます。この一覧はAnthropicが管理しており、変更される場合があります。

| エコシステム      | ホスト                                                                                                                                                                                 |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| コードホスティング   | `github.com`、`api.github.com`、`codeload.github.com`、`raw.githubusercontent.com`、`objects.githubusercontent.com`、`release-assets.githubusercontent.com`、`gitlab.com`、`bitbucket.org` |
| Node.js     | `registry.npmjs.org`、`registry.yarnpkg.com`、`nodejs.org`                                                                                                                            |
| Python      | `pypi.org`、`files.pythonhosted.org`                                                                                                                                                 |
| Rust        | `crates.io`、`index.crates.io`、`static.crates.io`、`static.rust-lang.org`                                                                                                             |
| Go          | `proxy.golang.org`、`sum.golang.org`                                                                                                                                                 |
| Java        | `repo1.maven.org`、`repo.maven.apache.org`、`services.gradle.org`、`plugins.gradle.org`、`plugins-artifacts.gradle.org`                                                                 |
| Ruby        | `rubygems.org`、`index.rubygems.org`                                                                                                                                                 |
| PHP         | `packagist.org`、`repo.packagist.org`                                                                                                                                                |
| Ubuntu（apt） | `archive.ubuntu.com`、`security.ubuntu.com`、`ppa.launchpad.net`                                                                                                                      |
| コンテナ        | `registry-1.docker.io`、`auth.docker.io`、`production.cloudflare.docker.com`、`download.docker.com`、`ghcr.io`                                                                          |

<Warning>
  ネットワークアクセスは操作単位ではなくホスト単位で付与されます。サンドボックスは、コマンドが提供する任意の認証情報を使って、許可されたホストに任意のリクエストを送信できます。これには `git push` やパッケージの公開などのアップロードも含まれます。エージェントが信頼できない入力（リポジトリのファイル、取得したWebコンテンツ、サードパーティツールの出力）を処理する場合、「prompt injection」（プロンプトインジェクション）が成功すると、許可されたホストを使ってサンドボックスからファイルを持ち出される可能性があります。このリスクを軽減するには、`bash` ツールの[権限ポリシー](https://platform.claude.com/docs/ja/managed-agents/permission-policies)を `always_ask` または `auto` に設定してください。環境で `packages` (csharp, go: `Packages`) を指定しない場合は、代わりに `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) を `false` のままにし、エージェントに必要なホストのみを `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に記載することもできます。
</Warning>

#### 無制限ネットワーキングのリスク

`unrestricted` ネットワーキングでは、サンドボックス内のコードは、一般的な安全ブロックリストに含まれるホストを除き、インターネット上の任意のホストにリクエストを送信できます。このモードを選択する前に、エージェントがそのアクセスで何ができるかを検討してください：

* **エージェントは外部サイトを読み取るだけでなく、変更することもできます：** `bash` ツールは任意のリクエストを送信できます。エージェントはデータの投稿、フォームの送信、APIの呼び出し、外部サイトのデータを変更するスクリプトの実行が可能です。URLを取得するだけのリクエストでも、サイトによってはデータが変更される場合があります。
* **デフォルトでは、これらのリクエストを一時停止するものはありません：** エージェントのツールセットのデフォルトの[権限ポリシー](https://platform.claude.com/docs/ja/managed-agents/permission-policies)は `always_allow` であるため、`bash` コマンドは承認なしで実行されます。
* **サンドボックス内のあらゆるものが外部に出る可能性があります：** これには、ファイル、ツールの出力、サンドボックスに配置した認証情報やシークレットが含まれます。
* **取得したコンテンツがエージェントを誘導する可能性があります：** エージェントが読み取るWebページ、APIレスポンス、その他のコンテンツには、エージェントの次の行動を変える指示（プロンプトインジェクション）が含まれている可能性があります。
* **エージェントはあなたに代わって行動します：** その行動がサイトの利用規約に違反したり、サイト上でアカウントやレコードを作成したりする可能性があります。
* **モデルの振る舞いはセキュリティ制御ではありません：** エージェントは、サイトがリクエストをブロックした後に別の方法で再試行するなど、依頼していない方法で外部サイト上で行動する可能性があります。ネットワーク設定と権限ポリシーを使用して、エージェントができることを制限してください。
* **安全ブロックリストは許可リストではありません：** エージェントがアクセスする他のサイトや、それらのサイト上でエージェントが行うことを制限するものではありません。

これらのリスクを軽減するには、明示的なホストのリストとともに `limited` ネットワーキングを使用してください。次の `networking` の値は、`api.example.com` に加えて、パッケージをインストールするエージェント向けに[パッケージマネージャーのホスト](https://platform.claude.com/docs/ja/managed-agents/environments#package-manager-hosts)を許可します：

```json
{
  "type": "limited",
  "allowed_hosts": ["api.example.com"],
  "allow_package_managers": true
}
```

`web_search` ツールと `web_fetch` ツールのみを使用するエージェントは、必要なサイトを列挙できるのであれば `unrestricted` ネットワーキングは不要です。`limited` ネットワーキングでは、`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) はこれらのツールにも適用されるため（[ネットワーキング](https://platform.claude.com/docs/ja/managed-agents/environments#networking)を参照）、それらのサイトを `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に記載してください。`web_search` の `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) にもそれらを記載すると、それらのサイトを検索するようになります。`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) に追加したホストは、サンドボックスにも開放されます。ツールをさらに制限するには、[Web検索とWebフェッチのドメインを制限する](https://platform.claude.com/docs/ja/managed-agents/tools-web-restrictions)を参照してください。

`unrestricted` は、エージェントが事前にリストアップできないサイトにアクセスする必要がある場合にのみ使用してください。その場合は、シークレットや機密ファイルをサンドボックスに置かず、タスクに必要な認証情報のみをエージェントに与えてください。`bash` ツールの権限ポリシーを `always_ask` または `auto` に設定することを検討し、[セッションのイベントを監視](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming)してください。

## 環境のライフサイクル

* 環境は、明示的にアーカイブまたは削除されるまで保持されます。
* 複数のセッションが同じ環境を参照している場合でも、各セッションにはそれぞれ独自のサンドボックスインスタンスが割り当てられます。セッション間でファイルシステムの状態は共有されません。
* 環境はバージョン管理されません。環境を頻繁に更新する場合は、各セッションがどの構成を使用したかを把握できるように、変更内容を独自に記録しておいてください。

## 環境を管理する

<CodeGroup>
  ```bash cURL
  # 環境を一覧表示
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # 特定の環境を取得
  curl -fsS "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # 環境をアーカイブ（読み取り専用、既存セッションは継続）
  curl -fsS -X POST "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # 環境を削除（参照するセッションがない場合のみ）
  curl -fsS -X DELETE "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  # environment を一覧表示します
  ant beta:environments list

  # 特定の environment を取得します
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # environment をアーカイブします（読み取り専用になり、既存の session は継続します）
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # environment を削除します（参照している session がない場合のみ）
  ant beta:environments delete --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  # 環境を一覧表示
  environments = client.beta.environments.list()

  # 特定の環境を取得
  env = client.beta.environments.retrieve(environment.id)

  # 環境をアーカイブ（読み取り専用、既存セッションは継続）
  client.beta.environments.archive(environment.id)

  # 環境を削除（参照するセッションがない場合のみ）
  client.beta.environments.delete(environment.id)
  ```

  ```typescript TypeScript
  // 環境を一覧表示
  const environments = await client.beta.environments.list();

  // 特定の環境を取得
  const env = await client.beta.environments.retrieve(environment.id);

  // 環境をアーカイブ（読み取り専用、既存セッションは継続）
  await client.beta.environments.archive(environment.id);

  // 環境を削除（参照するセッションがない場合のみ）
  await client.beta.environments.delete(environment.id);
  ```

  ```csharp C#
  // 環境を一覧表示
  var environments = await client.Beta.Environments.List();

  // 特定の環境を取得
  var env = await client.Beta.Environments.Retrieve(environment.ID);

  // 環境をアーカイブ（読み取り専用、既存のセッションは継続）
  await client.Beta.Environments.Archive(environment.ID);

  // 環境を削除（参照しているセッションがない場合のみ）
  await client.Beta.Environments.Delete(environment.ID);
  ```

  ```go Go
  // 環境を一覧表示
  environments, err := client.Beta.Environments.List(ctx, anthropic.BetaEnvironmentListParams{})
  // ...

  // 特定の環境を取得
  env, err := client.Beta.Environments.Get(ctx, environment.ID, anthropic.BetaEnvironmentGetParams{})
  // ...

  // 環境をアーカイブ（読み取り専用、既存セッションは継続）
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // 環境を削除（参照するセッションがない場合のみ）
  _, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
  ```

  ```java Java
  // 環境を一覧表示
  var environments = client.beta().environments().list();
  // 特定の環境を取得
  var env = client.beta().environments().retrieve(environment.id());
  // 環境をアーカイブ（読み取り専用、既存のセッションは継続）
  client.beta().environments().archive(environment.id());
  // 環境を削除（参照しているセッションがない場合のみ）
  client.beta().environments().delete(environment.id());
  ```

  ```php PHP
  // 環境を一覧表示
  $environments = $client->beta->environments->list();
  // 特定の環境を取得
  $env = $client->beta->environments->retrieve($environment->id);
  // 環境をアーカイブ（読み取り専用、既存のセッションは継続）
  $client->beta->environments->archive($environment->id);
  // 環境を削除（参照しているセッションがない場合のみ）
  $client->beta->environments->delete($environment->id);
  ```

  ```ruby Ruby
  # 環境を一覧表示
  environments = client.beta.environments.list

  # 特定の環境を取得
  env = client.beta.environments.retrieve(environment.id)

  # 環境をアーカイブ（読み取り専用、既存セッションは継続）
  client.beta.environments.archive(environment.id)

  # 環境を削除（参照するセッションがない場合のみ）
  client.beta.environments.delete(environment.id)
  ```
</CodeGroup>

## プリインストールされたランタイム

クラウドサンドボックスには、一般的な言語ランタイム、データベース、コマンドラインツールが標準で含まれています。完全なリストについては、[クラウドサンドボックスリファレンス](https://platform.claude.com/docs/ja/managed-agents/cloud-sandboxes-reference)を参照してください。

## 次のステップ

<CardGroup cols={2}>
  <Card title="クラウドサンドボックスリファレンス" icon="book" href="https://platform.claude.com/docs/ja/managed-agents/cloud-sandboxes-reference">
    クラウドサンドボックスで利用可能なプリインストール済みのパッケージ、データベース、ユーティリティ。
  </Card>

  <Card title="セッションを開始する" icon="play" href="https://platform.claude.com/docs/ja/managed-agents/sessions">
    セッションを作成してエージェントを実行し、タスクの実行を開始します。
  </Card>
</CardGroup>