---
title: Самостоятельно размещаемые песочницы
url: https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes
description: Запускайте сеансы Claude Managed Agents в самостоятельно размещаемых песочницах, сохраняя выполнение инструментов, файлы и исходящий сетевой трафик в собственной инфраструктуре.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Самостоятельно размещаемые песочницы («self-hosted sandboxes») переносят выполнение инструментов агента из облачных песочниц, управляемых Anthropic, в инфраструктуру, которую контролируете вы, при этом сам агент по-прежнему работает на стороне Anthropic. Чтобы узнать, что это означает, и решить, подходит ли это вашему агенту, см. [Выбор среды для агента](https://platform.claude.com/docs/ru/managed-agents/choosing-an-environment).

## Как это работает

Среда `self_hosted` действует как очередь задач. Вы запускаете **environment worker** (рабочий процесс среды) — процесс в вашей собственной инфраструктуре, который обслуживает эту очередь:

1. Вы создаёте [сеанс](https://platform.claude.com/docs/ru/managed-agents/sessions), нацеленный на эту среду. Anthropic помещает сеанс в очередь как элемент работы.
2. Ваш рабочий процесс забирает элемент работы и загружает [навыки](https://platform.claude.com/docs/ru/managed-agents/skills) агента и [хранилища памяти](https://platform.claude.com/docs/ru/managed-agents/memory) сеанса.
3. Claude работает на стороне Anthropic и запрашивает вызовы инструментов. Ваш рабочий процесс выполняет каждый вызов локально и отправляет результат обратно.

Входные и выходные данные инструментов по-прежнему передаются в плоскость управления Anthropic, чтобы модель могла видеть результаты и определять дальнейшие действия. Anthropic хранит навыки и хранилища памяти. Ваша песочница содержит их копию на время сеанса. Полное описание границ потоков данных см. в разделе [Модель безопасности](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-security).

Самостоятельно размещаемые песочницы поддерживают все модели Claude, доступные в Managed Agents. Модель настраивается в агенте, а не в среде.

CLI `ant` и SDK для Python, TypeScript и Go поставляются с готовыми рабочими процессами. Поставщики песочниц, такие как Cloudflare, Daytona и Modal, также публикуют собственные [руководства по платформам](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#platform-guides).

## Быстрый старт

В этом руководстве по быстрому старту запускается один постоянно работающий рабочий процесс с помощью CLI `ant`, ему отправляется сеанс, и проверяется, что вызовы инструментов агента выполнялись на вашем хосте.

### Предварительные требования

* **Агент:** если у вас его нет, сначала пройдите руководство [Начало работы с Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/quickstart) и запишите ID агента.
* **Хост Linux:** на хосте должен быть `/bin/bash` именно по этому пути. Рабочему процессу нужен только исходящий HTTPS.
* **Ключ API Claude:** вы используете его на своём компьютере для создания сеансов и чтения статистики очереди. Не размещайте его на хосте рабочего процесса, где его могут прочитать вызовы инструментов агента.
* **CLI `ant` или SDK на вашем компьютере:** шаги со статистикой и сеансами в этом руководстве выполняются там, а не на хосте рабочего процесса. Установите CLI так же, как это делается для рабочего процесса на [шаге установки](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session), или установите [SDK](https://platform.claude.com/docs/ru/cli-sdks-libraries/overview).

<Note>
  На [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws) рабочий процесс проходит аутентификацию с помощью AWS IAM (SigV4) или [ключа API, созданного в AWS Console](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws#api-key-authentication), а не ключа среды. Прикрепите управляемую политику [`AnthropicSelfHostedEnvironmentAccess`](https://platform.claude.com/docs/ru/api/claude-platform-on-aws-iam-actions#managed-policies) к субъекту IAM, от имени которого работает ваш рабочий процесс. Ключи среды, созданные в Claude Console, не работают с конечной точкой Claude Platform on AWS.
</Note>

### Запуск первого сеанса

<Steps>
  <Step title="Создайте самостоятельно размещаемую среду">
    В Claude Console перейдите на страницу [Environments](https://platform.claude.com/environments) (`platform.claude.com/environments`), нажмите **Create environment** и в разделе **Hosting** выберите **Self-hosted**.

    Или через API:

    <CodeGroup defaultLanguage="CLI">
      ```bash cURL
      curl -sS --fail-with-body 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": "self-hosted",
          "config": {"type": "self_hosted"}
        }'
      ```

      <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: self-hosted
          config:
            type: self_hosted
          ```
        </File>
      </CodeGroupItem>

      ```python Python
      client = anthropic.Anthropic()

      environment = client.beta.environments.create(
          name="self-hosted", config={"type": "self_hosted"}
      )
      print(environment.id)
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const environment = await client.beta.environments.create({
        name: "self-hosted",
        config: { type: "self_hosted" }
      });
      console.log(environment.id);
      ```

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

      var client = new AnthropicClient();

      var environment = await client.Beta.Environments.Create(
          new EnvironmentCreateParams
          {
              Name = "self-hosted",
              Config = new BetaSelfHostedConfigParams(),
          }
      );
      Console.WriteLine(environment.ID);
      ```

      ```go Go
      client := anthropic.NewClient()

      environment, err := client.Beta.Environments.New(context.Background(), anthropic.BetaEnvironmentNewParams{
      	Name: "self-hosted",
      	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
      		OfSelfHosted: &anthropic.BetaSelfHostedConfigParams{},
      	},
      })
      if err != nil {
      	panic(err)
      }
      fmt.Println(environment.ID)
      ```

      ```java Java
      import com.anthropic.models.beta.environments.BetaSelfHostedConfigParams;
      import com.anthropic.models.beta.environments.EnvironmentCreateParams;

      void main() {
          var client = AnthropicOkHttpClient.fromEnv();

          var environment = client.beta().environments().create(
              EnvironmentCreateParams.builder()
                  .name("self-hosted")
                  .config(BetaSelfHostedConfigParams.builder().build())
                  .build()
          );
          IO.println(environment.id());
      }
      ```

      ```php PHP
      $client = new \Anthropic\Client();

      $environment = $client->beta->environments->create(
          name: 'self-hosted',
          config: ['type' => 'self_hosted'],
      );
      echo $environment->id, PHP_EOL;
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      environment = client.beta.environments.create(
        name: "self-hosted",
        config: {type: :self_hosted}
      )
      puts environment.id
      ```
    </CodeGroup>
  </Step>

  <Step title="Создайте ключ среды">
    В Console откройте среду и нажмите **Generate environment key**. Ключ среды аутентифицирует рабочий процесс в его очереди. Создать его можно только в Console, даже для среды, созданной через API.

    Экспортируйте ID среды и ключ на хосте рабочего процесса:

    ```bash
    export ANTHROPIC_ENVIRONMENT_KEY="sk-ant-oat01-..."
    export ANTHROPIC_ENVIRONMENT_ID="env_..."
    ```
  </Step>

  <Step title="Установите CLI ant">
    Выполните это на хосте рабочего процесса.

    <Tabs>
      <Tab title="curl (Linux/WSL)">
        Для сред Linux загрузите бинарный файл релиза напрямую.

        ```bash
        VERSION=1.42.0
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        case $(uname -m) in
          x86_64) ARCH=amd64 ;;
          aarch64) ARCH=arm64 ;;
        esac
        curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
          | sudo tar -xz -C /usr/local/bin ant
        ```

        Все релизы можно найти на [странице релизов GitHub](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Запустите рабочий процесс">
    Создайте рабочий каталог, затем запустите рабочий процесс. `--workdir` по умолчанию указывает на текущий каталог, поэтому передайте `/workspace`, чтобы соответствовать системному значению по умолчанию.

    ```bash
    sudo mkdir -p /workspace && sudo chown "$USER" /workspace
    ant beta:worker poll --workdir /workspace
    ```

    Рабочий процесс считывает две экспортированные вами переменные и опрашивает очередь, пока вы его не остановите.
  </Step>

  <Step title="Убедитесь, что рабочий процесс подключён">
    На своём компьютере задайте для `ANTHROPIC_API_KEY` ваш ключ API Claude (не ключ среды), а для `ANTHROPIC_ENVIRONMENT_ID` (python, ruby: `environment_id`; typescript, java, csharp: `environmentId`; go: `environmentID`; php: `$environmentId`) — ID среды. Убедитесь, что `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) не меньше 1:

    <CodeGroup>
      ```bash cURL
      curl -sS --fail-with-body "https://api.anthropic.com/v1/environments/$ANTHROPIC_ENVIRONMENT_ID/work/stats" \
        -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:work stats --environment-id "$ANTHROPIC_ENVIRONMENT_ID"
      ```

      ```python Python
      client = anthropic.Anthropic()

      stats = client.beta.environments.work.stats(environment_id)
      print(f"workers_polling={stats.workers_polling}")
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const stats = await client.beta.environments.work.stats(environmentId);

      console.log(`workers_polling=${stats.workers_polling}`);
      ```

      ```csharp C#
      var client = new AnthropicClient();

      var stats = await client.Beta.Environments.Work.Stats(environmentId);

      Console.WriteLine($"workers_polling={stats.WorkersPolling}");
      ```

      ```go Go
      client := anthropic.NewClient()

      stats, err := client.Beta.Environments.Work.Stats(
      	context.Background(),
      	environmentID,
      	anthropic.BetaEnvironmentWorkStatsParams{},
      )
      if err != nil {
      	panic(err)
      }

      fmt.Printf("workers_polling=%d\n", stats.WorkersPolling)
      ```

      ```java Java
      var client = AnthropicOkHttpClient.fromEnv();

      var stats = client.beta().environments().work().stats(environmentId);

      IO.println("workers_polling=" + stats.workersPolling().orElse(null));
      ```

      ```php PHP
      $client = new Client();

      $stats = $client->beta->environments->work->stats($environmentId);

      printf("workers_polling=%d\n", $stats->workersPolling);
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      stats = client.beta.environments.work.stats(environment_id)

      puts "workers_polling=#{stats.workers_polling}"
      ```
    </CodeGroup>

    Если `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) остаётся равным 0, см. раздел [Устранение неполадок](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-operations#troubleshooting).
  </Step>

  <Step title="Запустите сеанс">
    Задайте для `AGENT_ID` (python, ruby: `agent_id`; typescript, java, csharp: `agentId`; go: `agentID`; php: `$agentId`) ID вашего агента. Создайте сеанс, нацеленный на среду, затем отправьте ему задачу:

    <CodeGroup>
      ```bash cURL
      SESSION_ID=$(curl -sS --fail-with-body 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" \
        -d '{
          "agent": "'"$AGENT_ID"'",
          "environment_id": "'"$ANTHROPIC_ENVIRONMENT_ID"'"
        }' | jq -er '.id'
      )

      curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
        -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 '{
          "events": [
            {
              "type": "user.message",
              "content": [
                {
                  "type": "text",
                  "text": "Write the output of \"uname -a\" to hello.txt in your working directory."
                }
              ]
            }
          ]
        }'
      ```

      ```bash CLI
      SESSION_ID=$(ant beta:sessions create \
        --agent "$AGENT_ID" \
        --environment-id "$ANTHROPIC_ENVIRONMENT_ID" \
        --transform id --raw-output)

      ant beta:sessions:events send --session-id "$SESSION_ID" <<'YAML'
      events:
        - type: user.message
          content:
            - type: text
              text: Write the output of "uname -a" to hello.txt in your working directory.
      YAML
      ```

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

      client.beta.sessions.events.send(
          session.id,
          events=[
              {
                  "type": "user.message",
                  "content": [
                      {
                          "type": "text",
                          "text": 'Write the output of "uname -a" to hello.txt in your working directory.',
                      },
                  ],
              },
          ],
      )
      ```

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

      await client.beta.sessions.events.send(session.id, {
        events: [
          {
            type: "user.message",
            content: [
              {
                type: "text",
                text: 'Write the output of "uname -a" to hello.txt in your working directory.'
              }
            ]
          }
        ]
      });
      ```

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

      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Type = BetaManagedAgentsTextBlockType.Text,
                          Text = "Write the output of \"uname -a\" to hello.txt in your working directory.",
                      },
                  ],
              },
          ],
      });
      ```

      ```go Go
      session, err := client.Beta.Sessions.New(context.Background(), anthropic.BetaSessionNewParams{
      	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agentID)},
      	EnvironmentID: environmentID,
      })
      if err != nil {
      	panic(err)
      }

      _, err = client.Beta.Sessions.Events.Send(context.Background(), session.ID, anthropic.BetaSessionEventSendParams{
      	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
      			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
      					Text: "Write the output of \"uname -a\" to hello.txt in your working directory.",
      				},
      			}},
      		},
      	}},
      })
      if err != nil {
      	panic(err)
      }
      ```

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

      client.beta().sessions().events().send(
          session.id(),
          EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
                  .addTextContent("Write the output of \"uname -a\" to hello.txt in your working directory.")
                  .build())
              .build());
      ```

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

      $client->beta->sessions->events->send(
          $session->id,
          events: [
              [
                  'type' => 'user.message',
                  'content' => [['type' => 'text', 'text' => 'Write the output of "uname -a" to hello.txt in your working directory.']],
              ],
          ],
      );
      ```

      ```ruby Ruby
      session = client.beta.sessions.create(
        agent: agent_id,
        environment_id: environment_id
      )

      client.beta.sessions.events.send_(
        session.id,
        events: [
          {
            type: :"user.message",
            content: [{type: :text, text: 'Write the output of "uname -a" to hello.txt in your working directory.'}]
          }
        ]
      )
      ```
    </CodeGroup>

    Сеанс ожидает в очереди среды, пока его не заберёт рабочий процесс. Если ни один рабочий процесс не подключён, сеанс остаётся в очереди, а не завершается с ошибкой.
  </Step>

  <Step title="Убедитесь, что инструменты выполнялись на вашем хосте">
    На хосте рабочего процесса прочитайте файл, записанный агентом:

    ```bash
    cat /workspace/hello.txt
    ```

    Файл описывает ядро вашего собственного хоста, значит, вызовы инструментов агента выполнялись именно там. Чтобы следить за работой агента в реальном времени, см. раздел [Поток событий сеанса](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming).
  </Step>
</Steps>

## Ресурсы сеанса

Самостоятельно размещаемые песочницы поддерживают только ресурсы `memory_store`. Сеанс в самостоятельно размещаемой среде, включающий ресурс `file` или `github_repository`, отклоняется с ошибкой 400:

```text wrap
Environment env_... is a self-hosted environment. `resources` are not supported with self-hosted environments.
```

[Развёртывания](https://platform.claude.com/docs/ru/managed-agents/scheduled-deployments), нацеленные на самостоятельно размещаемую среду, подчиняются тому же правилу. Чтобы предоставить сеансу собственные входные файлы, см. раздел [Подготовка файлов для сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#stage-files-for-a-session).

## Самостоятельно размещаемые песочницы и туннели MCP

Самостоятельное размещение определяет, *где выполняется код агента*. [Туннели MCP](https://platform.claude.com/docs/ru/agents-and-tools/mcp-tunnels/overview) определяют, *как Anthropic обращается к серверам MCP в вашей сети*. Эти механизмы независимы:

* Сеанс в облачных песочницах Anthropic может обращаться к частным серверам MCP через туннель. Например, частный сервер MCP может находиться перед базой данных или внутренним API за вашим брандмауэром.
* Самостоятельно размещаемый сеанс может использовать как туннелированные, так и публичные серверы MCP.

Используйте оба механизма, если хотите, чтобы и выполнение, и доступ к инструментам оставались внутри ваших границ. Чтобы обойтись без туннеля, [оберните сервер MCP в пользовательские инструменты](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-custom-tools#wrap-an-mcp-server-as-custom-tools), которые обслуживает ваш рабочий процесс.

## Руководства по платформам

На этих страницах описано, как создать рабочий процесс на любой платформе песочниц. Также доступны руководства для конкретных платформ:

* [AWS Lambda MicroVMs](https://docs.aws.amazon.com/lambda/latest/dg/microvms-integrations-claude-managed-agents.html)
* [Blaxel](https://docs.blaxel.ai/Tutorials/Claude-Managed-Agents)
* [Cloudflare](https://developers.cloudflare.com/sandbox/claude-managed-agents/)
* [Daytona](https://www.daytona.io/docs/en/guides/claude/claude-managed-agents)
* [E2B](https://e2b.dev/docs/agents/claude-managed-agents)
* [Fly.io](https://docs.sprites.dev/integrations/claude-managed-agents/)
* [GKE Agent Sandbox](https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/tree/main/ai-ml/anthropic-agent-sandbox)
* [Modal](https://github.com/modal-labs/claude-managed-agents-modal-sandbox)
* [Namespace](https://namespace.so/docs/integrations/claude)
* [Superserve](https://docs.superserve.ai/integrations/managed-agents/claude-managed-agents)
* [Vercel](https://vercel.com/kb/guide/run-claude-managed-agent-tools-with-vercel-sandbox)

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

<CardGroup cols={2}>
  <Card title="Развёртывание рабочих процессов" icon="play" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers">
    Запускайте рабочий процесс SDK, запускайте рабочие процессы по веб-хукам или выделяйте каждому сеансу собственную песочницу.
  </Card>

  <Card title="Хранилища памяти" icon="brain" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory">
    Подготовьте хост, настройте синхронизацию и обрабатывайте хранилища только для чтения и конфликты.
  </Card>

  <Card title="Пользовательские инструменты и серверы MCP" icon="tool" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-custom-tools">
    Обслуживайте собственные инструменты из рабочего процесса, включая инструменты сервера MCP внутри вашей сети.
  </Card>

  <Card title="Мониторинг и устранение неполадок" icon="lightning" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-operations">
    Отслеживайте глубину очереди, корректно останавливайте сеансы и рабочие процессы и устраняйте распространённые сбои.
  </Card>

  <Card title="Справочник по рабочему процессу" icon="book" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-reference">
    Флаги CLI, переменные среды, пути файловой системы и параметры вспомогательных функций SDK.
  </Card>

  <Card title="Модель безопасности" icon="lock" href="https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-security">
    Модель разделённой ответственности для самостоятельно размещаемых сред песочниц.
  </Card>
</CardGroup>