harnest.extensions.docker

All Python modules · Import and compatibility guidance

Sandbox configuration

Option	Default	Purpose
`image` / `docker_path`	None	Select exactly one registry image or local Docker build context
`base_url`	Docker SDK default	Connect to an explicitly configured daemon
`network_policy`	`none()`	Grant no egress or supported unrestricted egress
`services` / `network`	Empty	Declare a private multi-container topology
`timeout_seconds`	300	Bound queueing, startup, and execution
`max_output_bytes`	1 MiB	Bound captured output while streaming
`scope`	`EXECUTION`	Choose execution, invocation, or session reuse
`budget`	Harnest defaults	Bound CPU, memory, processes, and scratch space
`max_scopes`	8	Bound retained invocation or session identities

Public API and limits

API	Role
`docker.sandbox(...)` / `docker_sandbox(...)`	Create a portable Docker-backed `Sandbox`
`docker.service(...)`	Declare one topology service
`docker.network(...)`	Declare the topology bridge and egress boundary
`docker.readiness(...)`	Declare a bounded service health command
`DockerScope`	Select execution, invocation, or session ownership
`DockerService`, `DockerNetwork`, `DockerReadiness`	Immutable topology contracts
`DockerSandboxProvider`	Runtime adapter implementing Harnest’s sandbox provider contract

A topology supports up to eight services. Each service allows 16 aliases, 32 declared ports, 64 environment entries, and 64 command arguments; bounded authored string values may use up to 8 KiB. Readiness permits 1 to 100 attempts with finite timing values. Service names and aliases must be unique portable lowercase DNS labels. These checks run before the Docker SDK receives configuration.

Execution budgets

Setting	Default and behavior
`scope`	`DockerScope.EXECUTION`: remove the topology after every call
`DockerScope.INVOCATION`	Reuse only for the same agent, user, session, and invocation
`DockerScope.SESSION`	Reuse only for the same agent, user, and session
`max_scopes`	`8`: evict the least recently used retained container before exceeding this cap
`budget.cpu`	`1.0` CPU, enforced by Docker
`budget.memory_bytes`	`512 MiB`, with no additional swap allowance
`budget.pids`	`64` processes
`budget.scratch_bytes`	`64 MiB` for writable `/tmp`; the root filesystem is read-only
`timeout_seconds`	`300`; includes queue waiting and active execution
`max_output_bytes`	`1 MiB` combined stdout/stderr, bounded while streaming
`network_policy`	`SandboxNetworkPolicy.none()`; uses Docker’s `none` network without services or an internal topology bridge with services
`image` / `docker_path`	Supply exactly one; custom images must provide `python3` and must not declare volumes
`base_url`	Optional Docker daemon URL

options retains the allowlisted parsing/retry fields only for callers explicitly constructing a native ADK adapter with to_adk_executor(). Those fields do not change Docker limits or add model tools to named sandbox assignments. Your authored tool decides whether to retry.

Exports

Name	Kind
`DOCKER_SANDBOX_CAPABILITIES`	Namespace
`DockerNetwork`	Class
`DockerReadiness`	Class
`DockerScope`	Class
`DockerService`	Class
`DockerExtension`	Class
`DockerSandboxProvider`	Class
`docker`	Namespace
`docker_sandbox`	Function
`extension`	Namespace

DOCKER_SANDBOX_CAPABILITIES

Advertise network controls a provider enforces below agent code.

Example

from harnest.extensions.docker import DOCKER_SANDBOX_CAPABILITIES

DOCKER_SANDBOX_CAPABILITIES.require

DOCKER_SANDBOX_CAPABILITIES.require(policy: harnest.sandbox.SandboxNetworkPolicy) -> None

Fail closed when this provider cannot enforce requested authority.

Parameters and example

Parameter	Type	Default
`policy`	`harnest.sandbox.SandboxNetworkPolicy`	Required

from harnest.extensions.docker import DOCKER_SANDBOX_CAPABILITIES

DOCKER_SANDBOX_CAPABILITIES.require(policy=...)

DockerNetwork

Configure one extension-owned bridge shared only by this sandbox.

DockerNetwork(*, internal: bool = True) -> None

Fields (— means no declared default):

Field	Type	Default
`internal`	`bool`	`True`

Parameters and example

Parameter	Type	Default
`internal`	`bool`	`True`

from harnest.extensions.docker import DockerNetwork

network = DockerNetwork()

DockerReadiness

Wait for a declared Docker health command before sandbox execution.

DockerReadiness(
    *,
    command: tuple[str, ...],
    interval_seconds: float = 1.0,
    timeout_seconds: float = 2.0,
    retries: int = 30,
    start_period_seconds: float = 0.0,
) -> None

Fields (— means no declared default):

Field	Type	Default
`command`	`tuple[str, ...]`	`—`
`interval_seconds`	`float`	`1.0`
`timeout_seconds`	`float`	`2.0`
`retries`	`int`	`30`
`start_period_seconds`	`float`	`0.0`

Parameters and example

Parameter	Type	Default
`command`	`tuple[str, ...]`	Required
`interval_seconds`	`float`	`1.0`
`timeout_seconds`	`float`	`2.0`
`retries`	`int`	`30`
`start_period_seconds`	`float`	`0.0`

from harnest.extensions.docker import DockerReadiness

readiness = DockerReadiness(command=...)

DockerScope

Choose how long one owned Docker topology may be retained.

DockerScope(*values)

Member	Value
`EXECUTION`	`'execution'`
`INVOCATION`	`'invocation'`
`SESSION`	`'session'`

Example

from harnest.extensions.docker import DockerScope

value = DockerScope.EXECUTION

DockerService

Declare one bounded service container on the private sandbox network.

DockerService(
    *,
    name: str,
    image: str | None = None,
    docker_path: str | None = None,
    command: tuple[str, ...] = (),
    environment: Mapping[str, str] = ...,
    ports: tuple[int, ...] = (),
    aliases: tuple[str, ...] = (),
    readiness: DockerReadiness | None = None,
    budget: SandboxBudget = ...,
) -> None

Fields (— means no declared default):

Field	Type	Default
`name`	`str`	`—`
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`command`	`tuple[str, ...]`	`()`
`environment`	`Mapping[str, str]`	`dict()`
`ports`	`tuple[int, ...]`	`()`
`aliases`	`tuple[str, ...]`	`()`
`readiness`	`DockerReadiness \| None`	`None`
`budget`	`SandboxBudget`	`SandboxBudget()`

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`command`	`tuple[str, ...]`	`()`
`environment`	`Mapping[str, str]`	`...`
`ports`	`tuple[int, ...]`	`()`
`aliases`	`tuple[str, ...]`	`()`
`readiness`	`DockerReadiness \| None`	`None`
`budget`	`SandboxBudget`	`...`

from harnest.extensions.docker import DockerService

service = DockerService(name=...)

DockerExtension

Expose Docker sandbox definitions without owning framework resources.

DockerExtension(*args: object, **kwargs: object) -> 'Extension[ContextT]'

Parameters and example

Parameter	Type	Default
`*args`	`object`	Optional
`**kwargs`	`object`	Optional

from harnest.extensions.docker import DockerExtension

extension = DockerExtension()

DockerExtension.start

async DockerExtension.start(context: 'ExtensionStartContext') -> None

Initialize application-scoped resources after dependencies start.

Parameters and example

Parameter	Type	Default
`context`	`'ExtensionStartContext'`	Required

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
await extension.start(context=...)

DockerExtension.stop

async DockerExtension.stop() -> None

Release application-scoped resources before dependencies stop.

Example

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
await extension.stop()

DockerExtension.create_context

DockerExtension.create_context(context: ExtensionContext) -> ContextT

Adapt the managed invocation base to an extension-specific context.

Parameters and example

Parameter	Type	Default
`context`	`ExtensionContext`	Required

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
result = extension.create_context(context=...)

DockerExtension.context

Return the task-local extension context for the active invocation.

Example

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
value = extension.context

DockerExtension.sandbox

DockerExtension.sandbox(
    *,
    image: str | None = None,
    docker_path: str | None = None,
    base_url: str | None = None,
    network_policy: SandboxNetworkPolicy | None = None,
    services: tuple[DockerService, ...] | list[DockerService] = (),
    network: DockerNetwork | None = None,
    timeout_seconds: int = 300,
    options: Mapping[str, Any] | None = None,
    metadata: Mapping[str, Any] | None = None,
    max_output_bytes: int = 1048576,
    scope: DockerScope = <DockerScope.EXECUTION: 'execution'>,
    budget: SandboxBudget | None = None,
    max_scopes: int = 8,
) -> Sandbox

Create a portable Docker sandbox definition from authored options.

Parameters and example

Parameter	Type	Default
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`base_url`	`str \| None`	`None`
`network_policy`	`SandboxNetworkPolicy \| None`	`None`
`services`	`tuple[DockerService, ...] \| list[DockerService]`	`()`
`network`	`DockerNetwork \| None`	`None`
`timeout_seconds`	`int`	`300`
`options`	`Mapping[str, Any] \| None`	`None`
`metadata`	`Mapping[str, Any] \| None`	`None`
`max_output_bytes`	`int`	`1048576`
`scope`	`DockerScope`	`<DockerScope.EXECUTION: 'execution'>`
`budget`	`SandboxBudget \| None`	`None`
`max_scopes`	`int`	`8`

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
sandbox = extension.sandbox()

DockerExtension.service

DockerExtension.service(
    *,
    name: str,
    image: str | None = None,
    docker_path: str | None = None,
    command: tuple[str, ...] | list[str] = (),
    environment: Mapping[str, str] | None = None,
    ports: tuple[int, ...] | list[int] = (),
    aliases: tuple[str, ...] | list[str] = (),
    readiness: DockerReadiness | None = None,
    budget: SandboxBudget | None = None,
) -> DockerService

Declare one bounded service container without contacting Docker.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`command`	`tuple[str, ...] \| list[str]`	`()`
`environment`	`Mapping[str, str] \| None`	`None`
`ports`	`tuple[int, ...] \| list[int]`	`()`
`aliases`	`tuple[str, ...] \| list[str]`	`()`
`readiness`	`DockerReadiness \| None`	`None`
`budget`	`SandboxBudget \| None`	`None`

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
service = extension.service(name=...)

DockerExtension.network

DockerExtension.network(*, internal: bool = True) -> DockerNetwork

Declare the extension-owned bridge that joins a sandbox topology.

Parameters and example

Parameter	Type	Default
`internal`	`bool`	`True`

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
network = extension.network()

DockerExtension.readiness

DockerExtension.readiness(
    *,
    command: tuple[str, ...] | list[str],
    interval_seconds: float = 1.0,
    timeout_seconds: float = 2.0,
    retries: int = 30,
    start_period_seconds: float = 0.0,
) -> DockerReadiness

Declare a bounded Docker health command for one service.

Parameters and example

Parameter	Type	Default
`command`	`tuple[str, ...] \| list[str]`	Required
`interval_seconds`	`float`	`1.0`
`timeout_seconds`	`float`	`2.0`
`retries`	`int`	`30`
`start_period_seconds`	`float`	`0.0`

from harnest.extensions.docker import DockerExtension

extension: DockerExtension
readiness = extension.readiness(command=...)

DockerSandboxProvider

Bind one extension-owned Docker backend to its configured network policy.

DockerSandboxProvider(backend: Any, network_policy: SandboxNetworkPolicy) -> None

Parameters and example

Parameter	Type	Default
`backend`	`Any`	Required
`network_policy`	`SandboxNetworkPolicy`	Required

from harnest.extensions.docker import DockerSandboxProvider

provider = DockerSandboxProvider(backend=..., network_policy=...)

DockerSandboxProvider.sandbox_capabilities

Advertise network controls a provider enforces below agent code.

DockerSandboxProvider.sandbox_capabilities.require

DockerSandboxProvider.sandbox_capabilities.require(policy: harnest.sandbox.SandboxNetworkPolicy) -> None

Fail closed when this provider cannot enforce requested authority.

Parameters and example

Parameter	Type	Default
`policy`	`harnest.sandbox.SandboxNetworkPolicy`	Required

from harnest.extensions.docker import DockerSandboxProvider

provider: DockerSandboxProvider
provider.sandbox_capabilities.require(policy=...)

DockerSandboxProvider.execute

DockerSandboxProvider.execute(request: SandboxRequest) -> SandboxResult

Reject policy substitution before delegating generic Python execution.

Parameters and example

Parameter	Type	Default
`request`	`SandboxRequest`	Required

from harnest.extensions.docker import DockerSandboxProvider

provider: DockerSandboxProvider
result = provider.execute(request=...)

DockerSandboxProvider.close

DockerSandboxProvider.close() -> None

Release the extension backend when the owning sandbox runtime closes.

Example

from harnest.extensions.docker import DockerSandboxProvider

provider: DockerSandboxProvider
provider.close()

docker

Expose Docker sandbox definitions without owning framework resources.

Example

from harnest.extensions.docker import docker

docker.start

async docker.start(context: 'ExtensionStartContext') -> None

Initialize application-scoped resources after dependencies start.

Parameters and example

Parameter	Type	Default
`context`	`'ExtensionStartContext'`	Required

from harnest.extensions.docker import docker

await docker.start(context=...)

docker.stop

async docker.stop() -> None

Release application-scoped resources before dependencies stop.

Example

from harnest.extensions.docker import docker

await docker.stop()

docker.create_context

docker.create_context(context: ExtensionContext) -> ContextT

Adapt the managed invocation base to an extension-specific context.

Parameters and example

Parameter	Type	Default
`context`	`ExtensionContext`	Required

from harnest.extensions.docker import docker

result = docker.create_context(context=...)

docker.context

Return the task-local extension context for the active invocation.

Example

from harnest.extensions.docker import docker

value = docker.context

docker.sandbox

docker.sandbox(
    *,
    image: str | None = None,
    docker_path: str | None = None,
    base_url: str | None = None,
    network_policy: SandboxNetworkPolicy | None = None,
    services: tuple[DockerService, ...] | list[DockerService] = (),
    network: DockerNetwork | None = None,
    timeout_seconds: int = 300,
    options: Mapping[str, Any] | None = None,
    metadata: Mapping[str, Any] | None = None,
    max_output_bytes: int = 1048576,
    scope: DockerScope = <DockerScope.EXECUTION: 'execution'>,
    budget: SandboxBudget | None = None,
    max_scopes: int = 8,
) -> Sandbox

Create a portable Docker sandbox definition from authored options.

Parameters and example

Parameter	Type	Default
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`base_url`	`str \| None`	`None`
`network_policy`	`SandboxNetworkPolicy \| None`	`None`
`services`	`tuple[DockerService, ...] \| list[DockerService]`	`()`
`network`	`DockerNetwork \| None`	`None`
`timeout_seconds`	`int`	`300`
`options`	`Mapping[str, Any] \| None`	`None`
`metadata`	`Mapping[str, Any] \| None`	`None`
`max_output_bytes`	`int`	`1048576`
`scope`	`DockerScope`	`<DockerScope.EXECUTION: 'execution'>`
`budget`	`SandboxBudget \| None`	`None`
`max_scopes`	`int`	`8`

from harnest.extensions.docker import docker

sandbox = docker.sandbox()

docker.service

docker.service(
    *,
    name: str,
    image: str | None = None,
    docker_path: str | None = None,
    command: tuple[str, ...] | list[str] = (),
    environment: Mapping[str, str] | None = None,
    ports: tuple[int, ...] | list[int] = (),
    aliases: tuple[str, ...] | list[str] = (),
    readiness: DockerReadiness | None = None,
    budget: SandboxBudget | None = None,
) -> DockerService

Declare one bounded service container without contacting Docker.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`command`	`tuple[str, ...] \| list[str]`	`()`
`environment`	`Mapping[str, str] \| None`	`None`
`ports`	`tuple[int, ...] \| list[int]`	`()`
`aliases`	`tuple[str, ...] \| list[str]`	`()`
`readiness`	`DockerReadiness \| None`	`None`
`budget`	`SandboxBudget \| None`	`None`

from harnest.extensions.docker import docker

service = docker.service(name=...)

docker.network

docker.network(*, internal: bool = True) -> DockerNetwork

Declare the extension-owned bridge that joins a sandbox topology.

Parameters and example

Parameter	Type	Default
`internal`	`bool`	`True`

from harnest.extensions.docker import docker

network = docker.network()

docker.readiness

docker.readiness(
    *,
    command: tuple[str, ...] | list[str],
    interval_seconds: float = 1.0,
    timeout_seconds: float = 2.0,
    retries: int = 30,
    start_period_seconds: float = 0.0,
) -> DockerReadiness

Declare a bounded Docker health command for one service.

Parameters and example

Parameter	Type	Default
`command`	`tuple[str, ...] \| list[str]`	Required
`interval_seconds`	`float`	`1.0`
`timeout_seconds`	`float`	`2.0`
`retries`	`int`	`30`
`start_period_seconds`	`float`	`0.0`

from harnest.extensions.docker import docker

readiness = docker.readiness(command=...)

docker_sandbox

Create a lazy Docker sandbox without importing an agent framework.

docker_sandbox(
    *,
    image: str | None = None,
    docker_path: str | None = None,
    base_url: str | None = None,
    network_policy: SandboxNetworkPolicy | None = None,
    services: tuple[DockerService, ...] | list[DockerService] = (),
    network: DockerNetwork | None = None,
    timeout_seconds: int = 300,
    options: Mapping[str, Any] | None = None,
    metadata: Mapping[str, Any] | None = None,
    max_output_bytes: int = 1048576,
    scope: DockerScope = <DockerScope.EXECUTION: 'execution'>,
    budget: SandboxBudget | None = None,
    max_scopes: int = 8,
) -> Sandbox

Parameters and example

Parameter	Type	Default
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`base_url`	`str \| None`	`None`
`network_policy`	`SandboxNetworkPolicy \| None`	`None`
`services`	`tuple[DockerService, ...] \| list[DockerService]`	`()`
`network`	`DockerNetwork \| None`	`None`
`timeout_seconds`	`int`	`300`
`options`	`Mapping[str, Any] \| None`	`None`
`metadata`	`Mapping[str, Any] \| None`	`None`
`max_output_bytes`	`int`	`1048576`
`scope`	`DockerScope`	`<DockerScope.EXECUTION: 'execution'>`
`budget`	`SandboxBudget \| None`	`None`
`max_scopes`	`int`	`8`

from harnest.extensions.docker import docker_sandbox

sandbox = docker_sandbox()

extension

Expose Docker sandbox definitions without owning framework resources.

Example

from harnest.extensions.docker import extension

extension.start

async extension.start(context: 'ExtensionStartContext') -> None

Initialize application-scoped resources after dependencies start.

Parameters and example

Parameter	Type	Default
`context`	`'ExtensionStartContext'`	Required

from harnest.extensions.docker import extension

await extension.start(context=...)

extension.stop

async extension.stop() -> None

Release application-scoped resources before dependencies stop.

Example

from harnest.extensions.docker import extension

await extension.stop()

extension.create_context

extension.create_context(context: ExtensionContext) -> ContextT

Adapt the managed invocation base to an extension-specific context.

Parameters and example

Parameter	Type	Default
`context`	`ExtensionContext`	Required

from harnest.extensions.docker import extension

result = extension.create_context(context=...)

extension.context

Return the task-local extension context for the active invocation.

Example

from harnest.extensions.docker import extension

value = extension.context

extension.sandbox

extension.sandbox(
    *,
    image: str | None = None,
    docker_path: str | None = None,
    base_url: str | None = None,
    network_policy: SandboxNetworkPolicy | None = None,
    services: tuple[DockerService, ...] | list[DockerService] = (),
    network: DockerNetwork | None = None,
    timeout_seconds: int = 300,
    options: Mapping[str, Any] | None = None,
    metadata: Mapping[str, Any] | None = None,
    max_output_bytes: int = 1048576,
    scope: DockerScope = <DockerScope.EXECUTION: 'execution'>,
    budget: SandboxBudget | None = None,
    max_scopes: int = 8,
) -> Sandbox

Create a portable Docker sandbox definition from authored options.

Parameters and example

Parameter	Type	Default
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`base_url`	`str \| None`	`None`
`network_policy`	`SandboxNetworkPolicy \| None`	`None`
`services`	`tuple[DockerService, ...] \| list[DockerService]`	`()`
`network`	`DockerNetwork \| None`	`None`
`timeout_seconds`	`int`	`300`
`options`	`Mapping[str, Any] \| None`	`None`
`metadata`	`Mapping[str, Any] \| None`	`None`
`max_output_bytes`	`int`	`1048576`
`scope`	`DockerScope`	`<DockerScope.EXECUTION: 'execution'>`
`budget`	`SandboxBudget \| None`	`None`
`max_scopes`	`int`	`8`

from harnest.extensions.docker import extension

sandbox = extension.sandbox()

extension.service

extension.service(
    *,
    name: str,
    image: str | None = None,
    docker_path: str | None = None,
    command: tuple[str, ...] | list[str] = (),
    environment: Mapping[str, str] | None = None,
    ports: tuple[int, ...] | list[int] = (),
    aliases: tuple[str, ...] | list[str] = (),
    readiness: DockerReadiness | None = None,
    budget: SandboxBudget | None = None,
) -> DockerService

Declare one bounded service container without contacting Docker.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`image`	`str \| None`	`None`
`docker_path`	`str \| None`	`None`
`command`	`tuple[str, ...] \| list[str]`	`()`
`environment`	`Mapping[str, str] \| None`	`None`
`ports`	`tuple[int, ...] \| list[int]`	`()`
`aliases`	`tuple[str, ...] \| list[str]`	`()`
`readiness`	`DockerReadiness \| None`	`None`
`budget`	`SandboxBudget \| None`	`None`

from harnest.extensions.docker import extension

service = extension.service(name=...)

extension.network

extension.network(*, internal: bool = True) -> DockerNetwork

Declare the extension-owned bridge that joins a sandbox topology.

Parameters and example

Parameter	Type	Default
`internal`	`bool`	`True`

from harnest.extensions.docker import extension

network = extension.network()

extension.readiness

extension.readiness(
    *,
    command: tuple[str, ...] | list[str],
    interval_seconds: float = 1.0,
    timeout_seconds: float = 2.0,
    retries: int = 30,
    start_period_seconds: float = 0.0,
) -> DockerReadiness

Declare a bounded Docker health command for one service.

Parameters and example

Parameter	Type	Default
`command`	`tuple[str, ...] \| list[str]`	Required
`interval_seconds`	`float`	`1.0`
`timeout_seconds`	`float`	`2.0`
`retries`	`int`	`30`
`start_period_seconds`	`float`	`0.0`

from harnest.extensions.docker import extension

readiness = extension.readiness(command=...)

​Sandbox configuration

​Public API and limits

​Execution budgets

​Exports

​DOCKER_SANDBOX_CAPABILITIES

​DOCKER_SANDBOX_CAPABILITIES.require

​DockerNetwork

​DockerReadiness

​DockerScope

​DockerService

​DockerExtension

​DockerExtension.start

​DockerExtension.stop

​DockerExtension.create_context

​DockerExtension.context

​DockerExtension.sandbox

​DockerExtension.service

​DockerExtension.network

​DockerExtension.readiness

​DockerSandboxProvider

​DockerSandboxProvider.sandbox_capabilities

​DockerSandboxProvider.sandbox_capabilities.require

​DockerSandboxProvider.execute

​DockerSandboxProvider.close

​docker

​docker.start

​docker.stop

​docker.create_context

​docker.context

​docker.sandbox

​docker.service

​docker.network

​docker.readiness

​docker_sandbox

​extension

​extension.start

​extension.stop

​extension.create_context

​extension.context

​extension.sandbox

​extension.service

​extension.network

​extension.readiness

Sandbox configuration

Public API and limits

Execution budgets

Exports

DOCKER_SANDBOX_CAPABILITIES

DOCKER_SANDBOX_CAPABILITIES.require

DockerNetwork

DockerReadiness

DockerScope

DockerService

DockerExtension

DockerExtension.start

DockerExtension.stop

DockerExtension.create_context

DockerExtension.context

DockerExtension.sandbox

DockerExtension.service

DockerExtension.network

DockerExtension.readiness

DockerSandboxProvider

DockerSandboxProvider.sandbox_capabilities

DockerSandboxProvider.sandbox_capabilities.require

DockerSandboxProvider.execute

DockerSandboxProvider.close

docker

docker.start

docker.stop

docker.create_context

docker.context

docker.sandbox

docker.service

docker.network

docker.readiness

docker_sandbox

extension

extension.start

extension.stop

extension.create_context

extension.context

extension.sandbox

extension.service

extension.network

extension.readiness