---
title: Настройка облачной среды
url: https://platform.claude.com/docs/ru/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
---

Среды (environments) определяют конфигурацию песочницы (sandbox), в которой работает ваш агент. Вы создаёте среду один раз, а затем ссылаетесь на её идентификатор каждый раз при запуске сессии. Несколько сессий могут использовать одну и ту же среду, но каждая сессия получает собственную изолированную песочницу (новый контейнер Linux).

На этой странице рассматриваются среды `type: cloud`. Чтобы запускать песочницы в собственной инфраструктуре, см. [Самостоятельно размещаемые песочницы](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes). Чтобы выбрать между этими двумя вариантами, см. [Выбор среды для агента](https://platform.claude.com/docs/ru/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/ru/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`), чтобы различать среды. В этом примере используется [сетевой режим](https://platform.claude.com/docs/ru/managed-agents/environments#networking) `limited` с разрешёнными менеджерами пакетов, поэтому песочница может обращаться к реестрам пакетов и хостингам кода. Чтобы разрешить доступ к другим хостам, добавьте их в `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

## Использование среды в сессии

Передайте идентификатор среды в виде строки при [создании сессии](https://platform.claude.com/docs/ru/managed-agents/sessions).

<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). При желании можно закрепить конкретные версии. Для незакреплённых пакетов устанавливается последняя версия. Если среда использует [сетевой режим](https://platform.claude.com/docs/ru/managed-agents/environments#networking) `limited`, также установите `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) в `networking` (csharp, go: `Networking`) в значение `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`) также применяется к инструментам `web_search` и `web_fetch`, которые работают на серверах Anthropic. Вызов `web_fetch` для URL на хосте, который не соответствует `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`), возвращает агенту результат с ошибкой. `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`) не указано ни одного хоста, ни один вызов `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`) в записи инструмента в наборе инструментов агента. См. [Ограничение доменов для веб-поиска и веб-загрузки](https://platform.claude.com/docs/ru/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/ru/managed-agents/environments#risks-of-unrestricted-networking).                                                                                                                                                                                                                                   |

<Note>
  Явно задавайте `networking` (csharp, go: `Networking`) в запросах API; запрос на создание, в котором это поле опущено, получает `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>
  Используйте сетевой режим `limited` с явным списком `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Следуйте принципу наименьших привилегий, предоставляя только минимальный сетевой доступ, необходимый вашему агенту, и регулярно проверяйте список разрешённых доменов.
</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`) разрешает исходящий доступ к конечным точкам MCP-серверов, настроенным в агенте, помимо перечисленных в массиве `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). По умолчанию `false`. Пока значение равно `false`, создание сессии завершается ошибкой 400, если агент объявляет MCP-сервер, хост которого отсутствует в `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). То же относится к [агенту, которому он может делегировать задачи](https://platform.claude.com/docs/ru/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/ru/managed-agents/environments#package-manager-hosts). По умолчанию `false`. Устанавливайте значение `true` всякий раз, когда в среде указаны `packages` (csharp, go: `Packages`); в противном случае запрос будет отклонён с ошибкой 400, даже если хосты реестров перечислены в `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

#### Хосты менеджеров пакетов

Когда `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` и публикацию пакетов, с любыми учётными данными, которые передаёт команда. Если агент обрабатывает недоверенные входные данные (файлы репозитория, загруженный веб-контент или вывод сторонних инструментов), успешная «prompt injection» (внедрение подсказки) может использовать разрешённый хост для копирования файлов из песочницы. Чтобы снизить этот риск, установите для инструмента `bash` [политику разрешений](https://platform.claude.com/docs/ru/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/ru/managed-agents/permission-policies) по умолчанию для набора инструментов агента — `always_allow`, поэтому команды `bash` выполняются без подтверждения.
* **Всё, что находится в песочнице, может её покинуть:** это включает файлы, вывод инструментов, а также любые учётные данные или секреты, которые вы помещаете в песочницу.
* **Загруженный контент может управлять агентом:** веб-страницы, ответы API и другой контент, который читает агент, могут содержать инструкции (внедрение подсказки), меняющие его дальнейшие действия.
* **Агент действует от вашего имени:** его действия могут нарушать условия использования сайта или создавать на нём учётные записи и другие записи.
* **Поведение модели не является средством контроля безопасности:** агент может действовать на внешних сайтах так, как вы не просили, в том числе повторять попытку другим способом после того, как сайт заблокировал запрос. Используйте сетевые настройки и политики разрешений, чтобы ограничить его возможности.
* **Список блокировки по соображениям безопасности не является списком разрешений:** он не ограничивает, к каким другим сайтам обращается агент и что он на них делает.

Чтобы снизить эти риски, используйте сетевой режим `limited` с явным списком хостов. Следующее значение `networking` разрешает `api.example.com`, а также [хосты менеджеров пакетов](https://platform.claude.com/docs/ru/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/ru/managed-agents/environments#networking)), поэтому перечислите эти сайты в `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Если также указать их в `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) инструмента `web_search`, он будет выполнять поиск по этим сайтам. Хост, который вы добавляете в `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`), также становится доступен песочнице. Чтобы ограничить инструменты сильнее, см. [Ограничение доменов для веб-поиска и веб-загрузки](https://platform.claude.com/docs/ru/managed-agents/tools-web-restrictions).

Используйте `unrestricted` только тогда, когда агенту нужно обращаться к сайтам, которые невозможно перечислить заранее. В этом случае не помещайте в песочницу секреты и конфиденциальные файлы и предоставляйте агенту только те учётные данные, которые нужны для задачи. Рассмотрите возможность установить политику разрешений инструмента `bash` в `always_ask` или `auto` и [отслеживайте события сессии](https://platform.claude.com/docs/ru/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
  # Список окружений
  ant beta:environments list

  # Получить конкретное окружение
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # Архивировать окружение (только чтение, существующие сеансы продолжаются)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Удалить окружение (только если на него не ссылаются сеансы)
  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/ru/managed-agents/cloud-sandboxes-reference).

## Следующие шаги

<CardGroup cols={2}>
  <Card title="Справочник по облачным песочницам" icon="book" href="https://platform.claude.com/docs/ru/managed-agents/cloud-sandboxes-reference">
    Предустановленные пакеты, базы данных и утилиты, доступные в облачных песочницах.
  </Card>

  <Card title="Запуск сессии" icon="play" href="https://platform.claude.com/docs/ru/managed-agents/sessions">
    Создайте сессию, чтобы запустить вашего агента и начать выполнять задачи.
  </Card>
</CardGroup>