nemo_gym.sandbox.providers.ecs_fargate

ECS Fargate sandbox provider package.

Submodules

Package Contents

Classes

Name	Description
`EcsFargateConfig`	Configuration for the ECS Fargate sandbox.
`EcsFargateProvider`	Run sandboxes as AWS ECS Fargate tasks behind an SSH sidecar.
`SshSidecarConfig`	SSH sidecar container configuration.

Functions

Name	Description
`engine_config_from_mapping`	Build an `EcsFargateConfig` from provider kwargs.

API

class nemo_gym.sandbox.providers.ecs_fargate.EcsFargateConfig(
    region: str | None = None,
    cluster: str = '',
    subnets: list[str] = list(),
    security_groups: list[str] = list(),
    assign_public_ip: bool = False,
    task_definition: str | None = None,
    task_definition_family_prefix: str = 'ecs-sandbox',
    image_template: str | None = None,
    container_name: str = 'main',
    container_port: int | None = None,
    cpu: str = '4096',
    memory: str = '8192',
    ephemeral_storage_gib: int | None = None,
    platform_version: str | None = None,
    execution_role_arn: str | None = None,
    task_role_arn: str | None = None,
    extra_env: dict[str, str] | None = None,
    log_group: str | None = None,
    log_stream_prefix: str | None = None,
    max_task_lifetime_sec: int = 14400,
    startup_timeout_sec: float = 300.0,
    poll_interval_sec: float = 2.0,
    run_task_max_retries: int = 30,
    ssh_sidecar: nemo_gym.sandbox.providers.ecs_fargate.engine.SshSidecarConfig | None = None,
    s3_bucket: str | None = None,
    s3_prefix: str | None = None,
    ecr_repository: str | None = None,
    environment_dir: str | None = None,
    codebuild_project: str | None = None,
    codebuild_service_role: str | None = None,
    codebuild_compute_type: str = 'BUILD_GENERAL1_MEDIUM',
    codebuild_build_timeout: int = 60,
    dockerhub_secret_arn: str | None = None,
    build_parallelism: int = 50,
    auto_mirror: bool = True,
    efs_filesystem_id: str | None = None,
    efs_access_point_id: str | None = None,
    ssm_project: str = DEFAULT_SSM_PROJECT
)

Dataclass

Configuration for the ECS Fargate sandbox.

assign_public_ip

bool = False

auto_mirror

bool = True

build_parallelism

int = 50

cluster

str = ''

codebuild_build_timeout

int = 60

codebuild_compute_type

str = 'BUILD_GENERAL1_MEDIUM'

codebuild_project

str | None = None

codebuild_service_role

str | None = None

container_name

str = 'main'

container_port

int | None = None

cpu

str = '4096'

dockerhub_secret_arn

str | None = None

ecr_repository

str | None = None

efs_access_point_id

str | None = None

efs_filesystem_id

str | None = None

environment_dir

str | None = None

ephemeral_storage_gib

int | None = None

execution_role_arn

str | None = None

extra_env

dict[str, str] | None = None

image_template

str | None = None

log_group

str | None = None

log_stream_prefix

str | None = None

max_task_lifetime_sec

int = 14400

memory

str = '8192'

platform_version

str | None = None

poll_interval_sec

float = 2.0

region

str | None = None

run_task_max_retries

int = 30

s3_bucket

str | None = None

s3_prefix

str | None = None

security_groups

list[str] = field(default_factory=list)

ssh_sidecar

SshSidecarConfig | None = None

ssm_project

str = DEFAULT_SSM_PROJECT

startup_timeout_sec

float = 300.0

subnets

list[str] = field(default_factory=list)

task_definition

str | None = None

task_definition_family_prefix

str = 'ecs-sandbox'

task_role_arn

str | None = None

class nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider(
    config: typing.Any = {}
)

Run sandboxes as AWS ECS Fargate tasks behind an SSH sidecar.

_cfg

= engine_config_from_mapping(config)

name

= 'ecs_fargate'

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.aclose() -> None

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.close(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> None

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.create(
    spec: nemo_gym.sandbox.providers.base.SandboxSpec
) -> nemo_gym.sandbox.providers.base.SandboxHandle

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.download_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    source_path: str,
    target_path: pathlib.Path
) -> None

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.exec(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    command: str,
    cwd: str | None = None,
    env: dict[str, str] | None = None,
    timeout_s: int | float | None = None,
    user: str | int | None = None
) -> nemo_gym.sandbox.providers.base.SandboxExecResult

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.status(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle
) -> nemo_gym.sandbox.providers.base.SandboxStatus

async

nemo_gym.sandbox.providers.ecs_fargate.EcsFargateProvider.upload_file(
    handle: nemo_gym.sandbox.providers.base.SandboxHandle,
    source_path: pathlib.Path,
    target_path: str
) -> None

async

class nemo_gym.sandbox.providers.ecs_fargate.SshSidecarConfig(
    sshd_port: int = 2222,
    ssh_ready_timeout_sec: float = 300.0,
    public_key_secret_arn: str = '',
    private_key_secret_arn: str = '',
    image: str | None = None,
    exec_server_port: int | None = None
)

Dataclass

SSH sidecar container configuration.

exec_server_port set → exec-server mode (one-way tunnel). exec_server_port None → agent-server mode (two-way tunnel).

exec_server_port

int | None = None

image

str | None = None

private_key_secret_arn

str = ''

public_key_secret_arn

str = ''

ssh_ready_timeout_sec

float = 300.0

sshd_port

int = 2222

nemo_gym.sandbox.providers.ecs_fargate.engine_config_from_mapping(
    config: dict[str, typing.Any]
) -> nemo_gym.sandbox.providers.ecs_fargate.engine.EcsFargateConfig

Build an EcsFargateConfig from provider kwargs.

When region is given but cluster is omitted, infrastructure is auto-discovered from SSM; explicit kwargs always win over SSM.