--- title: Развёртывание самостоятельно размещаемых воркеров url: https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers description: "Выберите, как самостоятельно размещаемые воркеры песочниц получают работу и где выполняются сеансы: постоянно работающие или запускаемые вебхуками, в одном процессе или в отдельной песочнице для каждого сеанса." featureMetadata: topic: title: Managed Agents url: https://platform.claude.com/docs/en/managed-agents/overview status: beta betaHeader: managed-agents-2026-04-01 --- В [кратком руководстве](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#quickstart) запускается один воркер CLI `ant`, который непрерывно опрашивает очередь и выполняет все сеансы в одном процессе. На этой странице описаны другие способы запуска воркера и то, как выбрать между ними. ## Выбор шаблона развёртывания При развёртывании воркеров необходимо сделать два выбора: как воркер получает работу и где выполняется каждый сеанс. **Как воркер получает работу:** * **Постоянная работа («always-on»):** долго работающий процесс непрерывно опрашивает очередь, и ему нужен только исходящий HTTPS. Это самая простая конфигурация. * **Запуск по вебхуку («webhook-triggered»):** обработчик активируется по событию `session.status_run_started` и начинает опрос. Это позволяет избежать простаивающего опрашивающего процесса, но требует конечной точки [вебхука](https://platform.claude.com/docs/ru/managed-agents/webhooks), доступной для Anthropic. **Где выполняется каждый сеанс:** * **В процессе:** воркер, получивший сеанс, сам выполняет его вызовы инструментов в одном общем рабочем каталоге. * **Песочница на сеанс:** опрашивающий процесс запускает новую песочницу для каждого полученного сеанса. Выбирайте этот вариант для более сильной изоляции: новая файловая система, ограничения ресурсов или сетевые ограничения для каждого сеанса. Воркеры CLI и SDK поддерживают разные комбинации: | Возможность | CLI `ant` | SDK (Python, TypeScript, Go) | | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | ---------------------------------- | | Постоянный опрос | Да | Да | | Запуск по вебхуку | Нет | Да | | Песочница на сеанс | Да | Да | | [Хранилища памяти](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) | Нет | Да | Все флаги CLI и параметры SDK описаны в [справочнике по самостоятельно размещаемым воркерам](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-reference). Для большего контроля вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work) напрямую и реализуйте собственный воркер. ## Запуск постоянно работающего воркера Запустите воркер, который непрерывно опрашивает очередь. Он проходит аутентификацию с помощью [ключа среды](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session) из краткого руководства: ```bash CLI ant beta:worker poll --workdir /workspace ``` ```python Python import asyncio import contextlib import os import signal from anthropic import AsyncAnthropic from anthropic.lib.environments import EnvironmentWorker 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: worker = EnvironmentWorker( client, environment_id=environment_id, environment_key=environment_key, workdir="/workspace", ) task = asyncio.create_task(worker.run()) # Отмена задачи вместо принудительного завершения процесса позволяет воркеру остановить # текущий рабочий элемент и выгрузить изменённые файлы памяти перед выходом. 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 environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!; const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!; const client = new Anthropic({ authToken: environmentKey }); const controller = new AbortController(); // Прерывание по любому из сигналов позволяет воркеру выгрузить изменённые файлы памяти и удалить свои // каталоги хранилища до завершения процесса. process.once("SIGINT", () => controller.abort()); process.once("SIGTERM", () => controller.abort()); await new EnvironmentWorker({ client, environmentId, environmentKey, workdir: "/workspace", signal: controller.signal }).run(); ``` В SDK для C# нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`. ```go Go package main import ( "context" "log" "os" "os/signal" "syscall" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/lib/environments" "github.com/anthropics/anthropic-sdk-go/option" ) func main() { environmentKey := os.Getenv("ANTHROPIC_ENVIRONMENT_KEY") environmentID := os.Getenv("ANTHROPIC_ENVIRONMENT_ID") ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() client := anthropic.NewClient(option.WithAuthToken(environmentKey)) worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{ EnvironmentID: environmentID, EnvironmentKey: environmentKey, Workdir: "/workspace", }) if err := worker.Run(ctx); err != nil { log.Fatalf("worker: %v", err) } } ``` В SDK для Java нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`. В SDK для PHP нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`. В SDK для Ruby нет `EnvironmentWorker`. Вместо этого запустите воркер CLI `ant`: `ant beta:worker poll --workdir /workspace`. ## Запуск воркеров по вебхукам В [Console](https://platform.claude.com/settings/workspaces/default/webhooks) определите конечную точку вебхука, которая прослушивает события `session.status_run_started`. Подробнее см. в разделе [Вебхуки](https://platform.claude.com/docs/ru/managed-agents/webhooks). Вместе с идентификатором среды и ключом из [краткого руководства](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes#run-your-first-session) экспортируйте ключ подписи вебхука на хосте обработчика. Обработчик использует его для проверки входящих полезных данных. ```bash export ANTHROPIC_WEBHOOK_SIGNING_KEY="whsec_..." ``` Вызывайте воркер при срабатывании `session.status_run_started`. Обработчик опустошает очередь и передаёт каждый полученный элемент работы в `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`), который загружает навыки, выполняет вызовы инструментов, отправляет результаты обратно и завершает работу. Чтобы проверять подписи вебхуков, установите дополнительный пакет webhooks: `pip install "anthropic[webhooks]"`. ```python Python import asyncio import os import anthropic import standardwebhooks # installed by the anthropic[webhooks] extra environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"] environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"] client = anthropic.AsyncAnthropic( auth_token=environment_key, ) # Отменяется через shutdown(), чтобы выполняемый рабочий элемент мог выгрузить изменённые файлы памяти и # удалить свои каталоги хранилищ до завершения процесса. inflight: set[asyncio.Task[None]] = set() # Ожидайте это из хука завершения хоста, например ASGI lifespan shutdown (код после # `yield` в lifespan FastAPI), который uvicorn запускает по SIGTERM. uvicorn даёт открытым запросам # завершиться до запуска этого хука, поэтому задайте --timeout-graceful-shutdown, чтобы ограничить ожидание. async def shutdown() -> None: for task in inflight: task.cancel() await asyncio.gather(*inflight, return_exceptions=True) async def handle(raw: bytes, headers: dict[str, str]) -> tuple[dict[str, str], int]: try: event = client.beta.webhooks.unwrap(raw.decode(), headers=headers) except standardwebhooks.WebhookVerificationError: return {"error": "signature verification failed"}, 401 if event.data.type != "session.status_run_started": return {"status": "ignored"}, 200 task = asyncio.create_task(run_queued_work()) inflight.add(task) task.add_done_callback(inflight.discard) try: # Защищено (shield): сброшенная или просроченная доставка не должна отменять элемент; это делает shutdown(). await asyncio.shield(task) except asyncio.CancelledError: return {"status": "shutting down"}, 503 return {"status": "ok"}, 200 async def run_queued_work() -> None: async for work in client.beta.environments.work.poller( environment_id=environment_id, environment_key=environment_key, block_ms=None, reclaim_older_than_ms=2000, drain=True, auto_stop=False, ): await client.beta.environments.work.worker(workdir="/workspace").handle_item( work_id=work.id, environment_id=environment_id, session_id=work.data.id, environment_key=environment_key, # Именно секрет сессии позволяет воркеру монтировать хранилища памяти этой сессии. work_secret=work.secret, ) ``` ```typescript TypeScript import Anthropic from "@anthropic-ai/sdk"; const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!; const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!; const client = new Anthropic({ authToken: environmentKey }); // Вызовите shutdown.abort() из обработчика SIGTERM/SIGINT хоста, одновременно с закрытием сервера, // затем дождитесь выполняющихся вызовов handle() перед выходом: abort позволяет работающему элементу // сначала выгрузить изменённые файлы памяти и удалить свои каталоги хранилищ. export const shutdown = new AbortController(); export async function handle(req: Request): Promise { // Никогда не подтверждайте доставку, работа которой здесь не будет выполнена; 503 заставит отправителя повторить попытку. if (shutdown.signal.aborted) { return Response.json({ status: "shutting down" }, { status: 503 }); } const body = await req.text(); let event; try { event = client.beta.webhooks.unwrap(body, { headers: Object.fromEntries(req.headers) }); } catch { return new Response("signature verification failed", { status: 401 }); } if (event.data.type !== "session.status_run_started") { return Response.json({ status: "ignored" }); } for await (const work of client.beta.environments.work.poller({ environmentId, environmentKey, blockMs: null, reclaimOlderThanMs: 2000, drain: true, autoStop: false, signal: shutdown.signal })) { await client.beta.environments.work.worker({ workdir: "/workspace" }).handleItem({ workId: work.id, environmentId, sessionId: work.data.id, environmentKey, // Именно секрет сессии позволяет воркеру монтировать хранилища памяти этой сессии. workSecret: work.secret ?? undefined, signal: shutdown.signal }); } // Поллер и handleItem тихо завершаются при abort, поэтому прерванный досрочно drain попадает сюда. if (shutdown.signal.aborted) { return Response.json({ status: "shutting down" }, { status: 503 }); } return Response.json({ status: "ok" }); } ``` В SDK для C# нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). ```go Go package main import ( "context" "encoding/json" "errors" "io" "log/slog" "net/http" "os" "os/signal" "syscall" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/lib/environments" "github.com/anthropics/anthropic-sdk-go/option" "github.com/anthropics/anthropic-sdk-go/packages/param" ) var ( environmentKey = os.Getenv("ANTHROPIC_ENVIRONMENT_KEY") environmentID = os.Getenv("ANTHROPIC_ENVIRONMENT_ID") client = anthropic.NewClient( option.WithAuthToken(environmentKey), option.WithWebhookKey(os.Getenv("ANTHROPIC_WEBHOOK_SIGNING_KEY")), ) worker = environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{ Workdir: "/workspace", }) // Отменяется по SIGINT или SIGTERM (задаётся в main), чтобы выполняющийся рабочий элемент мог // выгрузить изменённые файлы памяти и удалить свои каталоги хранилищ перед выходом. shutdown context.Context ) func handle(w http.ResponseWriter, r *http.Request) { body, err := io.ReadAll(r.Body) if err != nil { http.Error(w, "bad request", http.StatusBadRequest) return } event, err := client.Beta.Webhooks.Unwrap(body, r.Header) if err != nil { http.Error(w, "signature verification failed", http.StatusUnauthorized) return } if event.Data.Type != "session.status_run_started" { json.NewEncoder(w).Encode(map[string]string{"status": "ignored"}) return } // Go SDK не предоставляет вспомогательный метод RunOne: извлекаем ожидающие элементы // через WorkPoller и запускаем каждый с помощью HandleItem. // Отвязываемся от r.Context(): сессия может пережить тайм-аут доставки вебхука. // Общий для процесса контекст завершения всё равно корректно завершит элемент по SIGTERM. ctx := shutdown poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{ EnvironmentID: environmentID, EnvironmentKey: environmentKey, BlockMs: param.Null[int64](), ReclaimOlderThanMs: param.NewOpt[int64](2000), Drain: true, AutoStop: param.NewOpt(false), }) defer poller.Close() for poller.Next() { item := poller.Current() if err := worker.HandleItem(ctx, environments.HandleItemOptions{ WorkID: item.ID, EnvironmentID: item.EnvironmentID, SessionID: item.Data.ID, EnvironmentKey: environmentKey, // Именно секрет сессии позволяет воркеру монтировать хранилища памяти этой сессии. WorkSecret: item.Secret, }); err != nil { slog.Error("handle work item", "work_id", item.ID, "err", err) http.Error(w, "internal error", http.StatusInternalServerError) return } } if err := poller.Err(); err != nil { slog.Error("poll work queue", "err", err) http.Error(w, "internal error", http.StatusInternalServerError) return } json.NewEncoder(w).Encode(map[string]string{"status": "ok"}) } func main() { ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() shutdown = ctx server := &http.Server{Addr: ":8080"} http.HandleFunc("POST /webhook", handle) go func() { if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { slog.Error("http server", "err", err) os.Exit(1) } }() // По сигналу прекращаем принимать доставки и возвращаемся только после того, как выполняющиеся // обработчики, а значит и освобождение памяти их рабочих элементов, завершатся. <-ctx.Done() if err := server.Shutdown(context.Background()); err != nil { slog.Error("http shutdown", "err", err) } } ``` В SDK для Java нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). В SDK для PHP нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). В SDK для Ruby нет `EnvironmentWorker`. Чтобы обрабатывать элементы работы из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). Поскольку обработчик сам получает работу, он должен [передавать секрет элемента работы](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#forward-the-work-items-secret), как это делает здесь аргумент `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Этот обработчик выполняет каждый полученный элемент в одном процессе на одном хосте. Если ваши сеансы подключают одно и то же хранилище памяти, см. раздел [Изоляция сеансов, использующих общее хранилище](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory#isolate-sessions-that-share-a-store). ## Запуск отдельной песочницы для каждого сеанса Опрашивающий процесс на хосте получает работу и вызывает ваш скрипт один раз для каждого элемента работы. Скрипт запускает песочницу для этого одного сеанса. Установите `ant` и задайте `ant beta:worker run` в качестве точки входа. При запуске песочница считывает сведения о сеансе из переменных окружения, обрабатывает этот сеанс и завершает работу. Базовый образ должен предоставлять `/bin/bash`; `curl` используется только во время сборки. ```dockerfile FROM your-base-image ARG ANT_VERSION=1.42.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"] ``` Скрипт передаёт сведения о сеансе в новую песочницу. Для него на хосте опрашивающего процесса требуется `jq`. ```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 ``` Опрашивающий процесс задаёт переменные `ANTHROPIC_*`, которые передаёт скрипт, за исключением секрета. См. раздел [Переменные окружения](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-reference#environment-variables). `/host/outputs` — это выбранный вами каталог на хосте. Его монтирование в `/workspace` позволяет получить результаты сеанса после завершения работы песочницы. В это монтирование также попадают загруженное дерево `skills/` и любые промежуточные файлы. ```bash ant beta:worker poll --on-work ./spawn.sh ``` ### Передача секрета элемента работы Каждый полученный элемент работы может содержать выдаваемый Anthropic секрет сеанса `secret` (csharp, go: `Secret`). Он нужен воркеру, выполняющему сеанс, для монтирования [хранилищ памяти](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory). Воркер, который получает и выполняет сеансы в одном процессе (`ant beta:worker poll` без `--on-work` или `EnvironmentWorker` с `run()` (go: `Run()`)), передаёт секрет сам. Если между получением работы и воркером находится ваш собственный код, секрет передаёте вы: | Вы получаете работу с помощью | Секрет поступает как | Передайте его воркеру как | | ----------------------------------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `ant beta:worker poll --on-work` | Поле `secret` в JSON элемента работы на стандартном вводе вашего скрипта | `ANTHROPIC_WORK_SECRET` в окружении песочницы | | `work.poller()` (go: `environments.NewWorkPoller()`) из SDK | Поле `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`, используйте `work.poller()` (go: `environments.NewWorkPoller()`). Он опрашивает очередь и передаёт вам каждый полученный сеанс, а песочницу запускаете вы: Получение работы в цикле и запуск песочницы для каждого сеанса требуют больше логики, чем одна команда оболочки. Из оболочки запустите `ant beta:worker poll --on-work` со скриптом запуска, как в разделе [Запуск отдельной песочницы для каждого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#run-one-sandbox-per-session). Чтобы получать работу из оболочки и запускать песочницу для каждого сеанса, запустите `ant beta:worker poll --on-work` со скриптом запуска, как в разделе [Запуск отдельной песочницы для каждого сеанса](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-workers#run-one-sandbox-per-session). ```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 { 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); } ``` В SDK для C# нет вспомогательного средства для опроса очереди. Чтобы получать работу из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). ```go Go package main import ( "context" "fmt" "log" "os" "os/exec" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/lib/environments" "github.com/anthropics/anthropic-sdk-go/option" "github.com/anthropics/anthropic-sdk-go/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) } } } ``` В SDK для Java нет вспомогательного средства для опроса очереди. Чтобы получать работу из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). В SDK для PHP нет вспомогательного средства для опроса очереди. Чтобы получать работу из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). В SDK для Ruby нет вспомогательного средства для опроса очереди. Чтобы получать работу из собственного кода, вызывайте [конечные точки Environments Work](https://platform.claude.com/docs/ru/api/beta/environments/work). ### Запуск воркера 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_*`, что передаёт скрипт запуска. ```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(); ``` В SDK для C# нет `EnvironmentWorker`. ```go Go package main import ( "context" "log" "os" "os/signal" "syscall" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/lib/environments" "github.com/anthropics/anthropic-sdk-go/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) } } ``` В SDK для Java нет `EnvironmentWorker`. В SDK для PHP нет `EnvironmentWorker`. В SDK для Ruby нет `EnvironmentWorker`. ## Подготовка файлов для сеанса Anthropic не монтирует файлы или репозитории GitHub в самостоятельно размещаемые песочницы. Чтобы сделать файлы конкретного сеанса доступными: 1. Передайте ссылки на файлы, например путь S3 или SHA коммита, в поле `metadata` сеанса. 2. В скрипте запуска или обработчике `--on-work` получите сеанс (`GET /v1/sessions/{session_id}`) и прочитайте `metadata`. Полученный элемент работы содержит идентификатор сеанса, но не метаданные. 3. Разместите файлы в рабочем каталоге до начала выполнения инструментов. ```bash cURL 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"'", "metadata": {"input_file": "s3://my-bucket/data.csv"} }' ``` ```bash CLI ant beta:sessions create \ --agent "$AGENT_ID" \ --environment-id "$ANTHROPIC_ENVIRONMENT_ID" \ --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 { ["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"} ) ``` ## Следующие шаги Отслеживайте глубину очереди, корректно останавливайте сеансы и воркеры и устраняйте распространённые сбои. Модель разделённой ответственности для самостоятельно размещаемых сред песочниц.