---
title: Запуск отдельной песочницы для каждого сеанса
url: https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session
description: Предоставьте каждому сеансу собственную самостоятельно размещаемую песочницу с помощью Helm-чарта в Kubernetes, скрипта запуска или опрашивающего процесса SDK.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
---

В шаблоне «sandbox-per-session» (песочница на каждый сеанс) каждый сеанс выполняется в новой песочнице, у которой могут быть собственная файловая система, ограничения ресурсов и сетевые ограничения. Чтобы сравнить его с другими шаблонами, см. [Выбор шаблона развёртывания](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).

Настроить его можно тремя способами:

* **[Helm-чарт в Kubernetes](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes):** диспетчер Anthropic забирает работу и запускает под для каждого сеанса в вашем кластере.
* **[Скрипт запуска](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script):** CLI `ant` забирает работу и вызывает ваш скрипт, который запускает песочницу на любой платформе.
* **[Опрашивающий процесс SDK](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller):** ваш собственный код забирает работу и запускает песочницу.

Разделы после [Запуск песочниц в Kubernetes](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes) относятся к скрипту запуска и опрашивающему процессу SDK.

## Запуск песочниц в Kubernetes

Anthropic публикует Helm-чарт `cma-sandboxes` и его образы. Чарт запускает отдельную песочницу для каждого сеанса в вашем собственном кластере Kubernetes. Его диспетчер опрашивает очередь работы среды и выделяет каждому сеансу собственный под:

* **Изоляция:** каждый под работает под управлением [gVisor](https://gvisor.dev/) за сетевыми политиками чарта. У него собственная файловая система и ограничения ресурсов. Ключ среды есть только у диспетчера.
* **Привязка к сеансу («session affinity»):** каждое сообщение в сеансе направляется в песочницу этого сеанса. Когда сеанс находится в состоянии простоя 30 минут (значение по умолчанию параметра чарта `sandbox.idleTimeout`), его под останавливается. Его том `/workspace` сохраняется до завершения сеанса. Следующее сообщение запускает под на том же томе.
* **Тёплый пул («warm pool»):** везде, кроме Google Kubernetes Engine (GKE), чарт держит наготове два пода для новых сеансов (значение по умолчанию параметра чарта `sandbox.warmPoolSize`).

Поды песочниц запускают «worker» (воркер) CLI `ant`. Они поддерживают [хранилища памяти](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory) с настройками синхронизации по умолчанию и не поддерживают [пользовательские инструменты](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-custom-tools).

### Установка чарта

Чарт работает в GKE, Amazon EKS и других кластерах. Перед установкой настройте следующее:

* **В кластере:** контроллер [Agent Sandbox](https://github.com/kubernetes-sigs/agent-sandbox) (в GKE — дополнение Agent Sandbox), узлы с gVisor и сетевой плагин, применяющий NetworkPolicy.
* **В вашем собственном пространстве имён:** метки Restricted Pod Security Standard, Secret с идентификатором среды и [ключом среды](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session), а также TLS-сертификат диспетчера.

В [руководстве по установке на GitHub](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md) приведены шаги настройки для каждого типа кластера. В нём также описаны обновления и ротация ключей.

Сохраните свои настройки в файле `cma-values.yaml`. Без трёх параметров из этого файла установка завершится ошибкой:

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

В руководстве по установке перечислены параметры, зависящие от вашего кластера, например `gke.dns` в GKE Autopilot. В нём также указано, когда `egress.clusterIsPrivate: true` заменяет `egress.clusterCIDRs`.

Затем установите чарт:

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

После установки выполните предварительную проверку, описанную в руководстве по установке.

<Warning>
  Не удаляйте чарт одной лишь командой `helm uninstall`. Эта команда удаляет сетевые политики и оставляет песочницы сеансов работающими без них. Сначала остановите диспетчер и удалите песочницы в порядке, указанном в [разделе Removal руководства по установке](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#removal).
</Warning>

### Добавление инструментов в образ песочницы

Опубликованный образ песочницы основан на Alpine Linux и содержит `bash`, `curl`, `jq` и CLI `ant`. Чарт запускает его с корневой файловой системой только для чтения и от имени пользователя без прав root, поэтому агент не может устанавливать пакеты во время сеанса.

Чтобы предоставить агентам больше инструментов, например Python или Git, соберите оба образа из репозитория по тегу релиза. Команды приведены в [разделе Install руководства по установке](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#install). Отправьте образы в свой реестр как `cma-dispatcher` и `cma-sandbox`, указав в качестве тега версию чарта. Затем задайте для `image.registry` этот реестр. Если вы закрепляете дайджесты образов, используйте дайджесты собственных образов.

### Ограничение исходящего сетевого трафика

По умолчанию сетевые политики чарта позволяют песочнице обращаться к публичному интернету IPv4. Они блокируют частные диапазоны адресов, сервер метаданных облака и адреса из `egress.clusterCIDRs`. Агент, подвергшийся «prompt injection» (внедрению подсказок), может отправить прочитанное на любой адрес, доступный его песочнице. Подробности см. в разделе [Network egress](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#network-egress) руководства по установке.

* **GKE с Dataplane V2:** задайте `egress.mode: fqdnGke`, чтобы ограничить подключения портом 443 на хостах из `egress.fqdnGke.hosts`. Оставьте в этом списке `api.anthropic.com` и добавьте каждый хост, необходимый командам ваших агентов. В отличие от режима по умолчанию, в этом режиме нет списка заблокированных диапазонов. Он разрешает любой адрес, в который разрешается имя указанного хоста, поэтому указывайте только хосты, DNS которых вы доверяете. Песочница всё равно может передавать данные наружу внутри DNS-запросов.
* **Другие кластеры и GKE без Dataplane V2:** доступен только режим по умолчанию.
* **Любой кластер:** сетевые политики не распространяются на порты, прослушиваемые собственными узлами кластера. См. [Node isolation you own](https://github.com/anthropics/anthropic-cli/blob/main/sandboxes/kubernetes/README.md#node-isolation-you-own) в руководстве по установке.

## Запуск песочниц с помощью скрипта запуска

Опрашивающий процесс на хосте забирает работу и вызывает ваш «spawn script» (скрипт запуска) один раз для каждого «work item» (элемента работы). Скрипт запускает песочницу для этого одного сеанса.

<Steps>
  <Step title="Соберите образ песочницы">
    Установите `ant` и укажите `ant beta:worker run` в качестве точки входа. При запуске песочница считывает сведения о сеансе из переменных окружения, обрабатывает этот сеанс и завершает работу. Базовый образ должен предоставлять `/bin/bash`; при сборке `curl` используется только для загрузки `ant`.

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

  <Step title="Напишите скрипт запуска">
    Скрипт передаёт сведения о сеансе в новую песочницу. Для него на хосте опрашивающего процесса требуется `jq`.

    <File filename="spawn.sh">
      ```bash
      #!/bin/bash
      # spawn.sh: вызывается один раз для каждого забранного элемента работы
      # Забранный элемент работы поступает в формате JSON через stdin.
      ANTHROPIC_WORK_SECRET="$(jq -r '.secret // empty')"
      export ANTHROPIC_WORK_SECRET
      mkdir -p "/host/outputs/$ANTHROPIC_SESSION_ID"
      exec docker run --rm \
        -e ANTHROPIC_SESSION_ID -e ANTHROPIC_ENVIRONMENT_KEY \
        -e ANTHROPIC_WORK_ID -e ANTHROPIC_ENVIRONMENT_ID -e ANTHROPIC_BASE_URL \
        -e ANTHROPIC_WORK_SECRET \
        -v "/host/outputs/$ANTHROPIC_SESSION_ID":/workspace \
        your-image
      ```
    </File>

    Опрашивающий процесс задаёт `ANTHROPIC_WORK_ID`, `ANTHROPIC_ENVIRONMENT_ID`, `ANTHROPIC_SESSION_ID` и `ANTHROPIC_ENVIRONMENT_KEY`. `ANTHROPIC_BASE_URL` попадает в скрипт, только если вы задали её на хосте опрашивающего процесса. Скрипт считывает `ANTHROPIC_WORK_SECRET` из JSON элемента работы со стандартного ввода. См. [Переменные окружения](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-reference#environment-variables).

    `/host/outputs` — это выбранный вами каталог хоста. Монтирование его в `/workspace` позволяет получить результаты сеанса после завершения работы песочницы. При монтировании туда также попадают загруженное дерево `skills/` и любые промежуточные файлы.
  </Step>

  <Step title="Запустите опрашивающий процесс">
    ```bash
    ant beta:worker poll --on-work ./spawn.sh
    ```
  </Step>
</Steps>

## Передача секрета элемента работы

Каждый забранный элемент работы может содержать `secret` (csharp, go: `Secret`), выдаваемый Anthropic для этого сеанса. Он нужен воркеру, выполняющему сеанс, чтобы монтировать [хранилища памяти](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory).

Воркер, который забирает и выполняет сеансы в одном процессе, сам передаёт секрет дальше. Одним из таких воркеров является `EnvironmentWorker` с `run()` (go: `Run()`), другим — `ant beta:worker poll` без `--on-work`. Если между получением работы и воркером находится ваш собственный код, секрет передаёте вы:

| Способ получения работы                                                                                                  | В каком виде поступает секрет                                            | Как передать его воркеру                                                                                                                                                                   |
| ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ant beta:worker poll --on-work`                                                                                         | Поле `secret` в JSON элемента работы на стандартном вводе вашего скрипта | `ANTHROPIC_WORK_SECRET` в окружении песочницы                                                                                                                                              |
| `work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`) в SDK для Python, TypeScript или Go | Поле `secret` (go: `Secret`) каждого забранного элемента работы          | `ANTHROPIC_WORK_SECRET` в окружении песочницы или аргумент `work_secret` (typescript: `workSecret`; go: `WorkSecret`) для `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) |

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

## Запуск песочниц из опрашивающего процесса SDK

Чтобы забирать работу из собственного кода вместо `ant beta:worker poll --on-work`, используйте опрашивающий процесс в SDK для Python, TypeScript или Go: `work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`). Он опрашивает очередь и передаёт вам каждый забранный сеанс, а песочницу запускаете вы:

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Получение работы в цикле и запуск песочницы для каждого сеанса требуют больше логики, чем может вместить одна команда оболочки. В оболочке запустите `ant beta:worker poll --on-work` со скриптом запуска, как в разделе [Запуск песочниц с помощью скрипта запуска](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script).
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Чтобы забирать работу из оболочки и запускать песочницу для каждого сеанса, выполните `ant beta:worker poll --on-work` со скриптом запуска. См. [Запуск песочниц с помощью скрипта запуска](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-with-a-spawn-script).
  </CodeGroupItem>

  ```python Python
  import asyncio
  import os

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

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


  async def launch_container(work: BetaSelfHostedWork) -> None:
      print(f"claimed session {work.data.id}")
      # Замените `docker run` собственным средством запуска песочниц. Передайте ключ
      # среды (но никогда не ключ API) и секрет сеанса из элемента работы: воркеру
      # внутри секрет нужен, чтобы монтировать хранилища памяти сеанса.
      env = os.environ | {
          "ANTHROPIC_WORK_ID": work.id,
          "ANTHROPIC_SESSION_ID": work.data.id,
          "ANTHROPIC_WORK_SECRET": work.secret or "",
      }
      forward = [arg for name in SANDBOX_ENV for arg in ("-e", name)]
      launcher = await asyncio.create_subprocess_exec(
          "docker", "run", "--rm", "--detach", *forward, "your-image", env=env
      )
      await launcher.wait()


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


  asyncio.run(main())
  ```

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

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

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

  async function launchContainer(work: BetaSelfHostedWork): Promise<void> {
    console.log(`claimed session ${work.data.id}`);
    // Замените `docker run` собственным средством запуска песочницы. Передайте ключ
    // среды (но никогда не ваш ключ API) и секрет сеанса из элемента работы: воркеру
    // внутри секрет нужен, чтобы монтировать хранилища памяти сеанса.
    const env = {
      ...process.env,
      ANTHROPIC_WORK_ID: work.id,
      ANTHROPIC_SESSION_ID: work.data.id,
      ANTHROPIC_WORK_SECRET: work.secret ?? ""
    };
    const forward = SANDBOX_ENV.flatMap((name) => ["-e", name]);
    const launcher = spawn("docker", ["run", "--rm", "--detach", ...forward, "your-image"], {
      env,
      stdio: "inherit"
    });
    await once(launcher, "close");
  }

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

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

  <CodeGroupItem language="C#">
    В SDK для C# нет вспомогательного средства для опроса работы. Чтобы забирать работу из собственного кода, вызывайте [эндпоинты Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) для опроса элемента и его подтверждения.
  </CodeGroupItem>

  ```go Go
  package main

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

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

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

  func launchContainer(ctx context.Context, work *anthropic.BetaSelfHostedWork) error {
  	fmt.Printf("claimed session %s\n", work.Data.ID)
  	// Замените `docker run` собственным средством запуска песочниц. Передайте ключ
  	// среды (но ни в коем случае не ключ API) и секрет сеанса элемента работы: воркеру
  	// внутри нужен этот секрет, чтобы монтировать хранилища памяти сеанса.
  	args := []string{"run", "--rm", "--detach"}
  	for _, name := range sandboxEnv {
  		args = append(args, "-e", name)
  	}
  	launcher := exec.CommandContext(ctx, "docker", append(args, "your-image")...)
  	launcher.Env = append(os.Environ(),
  		"ANTHROPIC_WORK_ID="+work.ID,
  		"ANTHROPIC_SESSION_ID="+work.Data.ID,
  		"ANTHROPIC_WORK_SECRET="+work.Secret,
  	)
  	launcher.Stdout, launcher.Stderr = os.Stdout, os.Stderr
  	return launcher.Run()
  }

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

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

  	ctx := context.Background()

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

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

  <CodeGroupItem language="Java">
    В SDK для Java нет вспомогательного средства для опроса работы. Чтобы забирать работу из собственного кода, вызывайте [эндпоинты Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) для опроса элемента и его подтверждения.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    В SDK для PHP нет вспомогательного средства для опроса работы. Чтобы забирать работу из собственного кода, вызывайте [эндпоинты Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) для опроса элемента и его подтверждения.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    В SDK для Ruby нет вспомогательного средства для опроса работы. Чтобы забирать работу из собственного кода, вызывайте [эндпоинты Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) для опроса элемента и его подтверждения.
  </CodeGroupItem>
</CodeGroup>

## Запуск воркера SDK внутри песочницы

Замените точку входа `ant beta:worker run` точкой входа SDK, если песочница должна [обслуживать пользовательские инструменты](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-custom-tools) или использовать [нестандартные настройки синхронизации памяти](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory#configure-sync). Точка входа создаёт `EnvironmentWorker` и вызывает `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`), который считывает те же переменные `ANTHROPIC_*`, передаваемые скриптом запуска.

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Воркер — это долго работающий процесс, а не отдельный HTTP-запрос. Чтобы обслуживать пользовательские инструменты или изменить настройки синхронизации памяти, используйте `EnvironmentWorker` в SDK для Python, TypeScript или Go.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Воркер CLI `ant` (`ant beta:worker run`) не может обслуживать пользовательские инструменты или изменять настройки синхронизации памяти. Для любого из этих действий используйте `EnvironmentWorker` в SDK для Python, TypeScript или Go.
  </CodeGroupItem>

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


  async def main() -> None:
      async with AsyncAnthropic(
          auth_token=os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      ) as client:
          worker = EnvironmentWorker(client, workdir="/workspace")
          # Без аргументов handle_item() читает переменные ANTHROPIC_*, переданные скриптом
          # запуска, включая ANTHROPIC_WORK_SECRET.
          task = asyncio.create_task(worker.handle_item())
          # Отмена задачи при остановке контейнера позволяет воркеру загрузить
          # изменённые файлы памяти и удалить каталоги хранилища перед завершением.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task


  asyncio.run(main())
  ```

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

  const client = new Anthropic({ authToken: process.env.ANTHROPIC_ENVIRONMENT_KEY });
  const controller = new AbortController();
  // Прерывание при остановке контейнера позволяет воркеру загрузить изменённые файлы памяти
  // и удалить каталоги хранилища перед завершением.
  process.once("SIGTERM", () => controller.abort());
  process.once("SIGINT", () => controller.abort());

  // Без аргументов handleItem() читает переменные ANTHROPIC_*, переданные скриптом
  // запуска, включая ANTHROPIC_WORK_SECRET.
  await new EnvironmentWorker({
    client,
    workdir: "/workspace",
    signal: controller.signal
  }).handleItem();
  ```

  <CodeGroupItem language="C#">
    В SDK для C# нет `EnvironmentWorker`.
  </CodeGroupItem>

  ```go Go
  package main

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

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

  func main() {
  	// Отмена контекста при остановке контейнера позволяет воркеру загрузить
  	// изменённые файлы памяти и удалить каталоги хранилища перед завершением.
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := anthropic.NewClient(option.WithAuthToken(os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")))
  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// С нулевыми значениями опций HandleItem считывает переменные ANTHROPIC_*, переданные
  	// скриптом запуска, включая ANTHROPIC_WORK_SECRET.
  	if err := worker.HandleItem(ctx, environments.HandleItemOptions{}); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    В SDK для Java нет `EnvironmentWorker`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    В SDK для PHP нет `EnvironmentWorker`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    В SDK для Ruby нет `EnvironmentWorker`.
  </CodeGroupItem>
</CodeGroup>

## Подготовка файлов для сеанса

Anthropic не монтирует файлы или репозитории GitHub в самостоятельно размещаемые песочницы. Чтобы сделать файлы, относящиеся к сеансу, доступными:

1. Передайте ссылки на файлы, например путь S3 или SHA коммита, в поле `metadata` (csharp, go: `Metadata`) сеанса.
2. В скрипте запуска или обработчике `--on-work` получите сеанс (`GET /v1/sessions/{session_id}`) и прочитайте `metadata` (csharp, go: `Metadata`). Забранный элемент работы содержит идентификатор сеанса, но не метаданные.
3. Поместите файлы в рабочий каталог до запуска любого инструмента.

Пример cURL считывает токен доступа (access token) из `ANTHROPIC_AUTH_TOKEN`. Чтобы получить его, настройте Workload Identity Federation с областью действия (scope) по умолчанию `workspace:developer`, как описано в разделе [Настройка федерации](https://platform.claude.com/docs/ru/manage-claude/workload-identity-federation#set-up-federation). Затем обменяйте токен идентификации (identity token) вашей рабочей нагрузки на токен доступа, как показано в разделе [Аутентификация из вашей рабочей нагрузки](https://platform.claude.com/docs/ru/manage-claude/workload-identity-federation#authenticate-from-your-workload). Задавайте `ANTHROPIC_AUTH_TOKEN` только в той оболочке, где запускаете пример cURL, поскольку эта переменная имеет приоритет над вашими настройками федерации. В разделе [Аутентификация](https://platform.claude.com/docs/ru/manage-claude/authentication) перечислены другие учётные данные, принимаемые API, например ключ API из краткого руководства.

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

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

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

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

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

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

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

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

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

## Дальнейшие шаги

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