--- title: Execution description: Rust SDK - Command execution API reference --- Run commands inside a running sandbox: buffer the output in one call, stream it event by event, drive a shell, or bridge your terminal to an interactive PTY session. See [Commands](/sandboxes/commands) for usage examples.

Run · buffered4

sb.exec()run, wait, collect output sb.exec_with()run with per-exec options sb.shell()run through the shell sb.shell_with()shell with options

Run · streaming4

sb.exec_stream()stream stdout/stderr events sb.exec_stream_with()stream with options sb.shell_stream()stream a shell command sb.shell_stream_with()stream shell with options

Attach · interactive3

sb.attach()bridge terminal to a process sb.attach_with()attach with options sb.attach_shell()attach to the default shell

Builder · ExecOptionsBuilder14

.arg() .args() .cwd() .user() .env() .envs() .timeout() .tty() .stdin_null() .stdin_pipe() .stdin_bytes() .rlimit() .rlimit_range() .build()

Builder · AttachOptionsBuilder10

.arg() .args() .cwd() .user() .env() .envs() .detach_keys() .rlimit() .rlimit_range() .build()

Types

ExecHandle ExecControl ExecSink ExecEvent ExecOutput ExitStatus Rlimit RlimitResource

Typical flow

```rust use microsandbox::Sandbox; let sb = Sandbox::builder("api").image("python").create().await?; // Buffered: run and collect everything let out = sb.exec("python", ["-c", "print('hi')"]).await?; println!("{}", out.stdout()?); // Streaming: process output as it arrives let mut handle = sb.exec_stream("tail", ["-f", "/var/log/app.log"]).await?; while let Some(event) = handle.recv().await { if let microsandbox::ExecEvent::Stdout(chunk) = event { print!("{}", String::from_utf8_lossy(&chunk)); } } sb.stop().await?; ``` ## Run methods --- #### sb.exec()
instanceasync
```rust async fn exec( &self, cmd: impl Into, args: impl IntoIterator>, ) -> MicrosandboxResult ``` Run a command inside the sandbox and wait for it to complete. Collects all stdout and stderr into memory and returns them along with the exit status. `cmd` is passed literally to the guest agent: the image ENTRYPOINT is **not** consulted, and `args` are not shell-interpreted. For long-running processes or large output, use [`exec_stream()`](#sb-exec_stream); for shell syntax like pipes and redirects, use [`shell()`](#sb-shell).

Parameters

cmdimpl Into<String>
Command to execute, e.g. "python" or "/usr/bin/node".
argsimpl IntoIterator
Command arguments, e.g. ["-c", "print('hi')"].

Returns

Collected stdout, stderr, and exit status.
```rust let out = sb.exec("python", ["-V"]).await?; println!("{}", out.stdout()?); ``` --- #### sb.exec_with()
instanceasync
```rust async fn exec_with( &self, cmd: impl Into, f: impl FnOnce(ExecOptionsBuilder) -> ExecOptionsBuilder, ) -> MicrosandboxResult ``` Run a command with per-execution overrides and wait for completion. The closure receives an [`ExecOptionsBuilder`](#execoptionsbuilder) to set args, working directory, environment variables, user, timeout, resource limits, stdin mode, and TTY allocation. These overrides apply only to this execution and don't change the sandbox's defaults.

Parameters

cmdimpl Into<String>
Command to execute.
Configure execution options.

Returns

Collected stdout, stderr, and exit status.
```rust use std::time::Duration; let out = sb.exec_with("python", |e| e .args(["compute.py"]) .cwd("/app") .env("LOG_LEVEL", "debug") .timeout(Duration::from_secs(30))) .await?; ``` --- #### sb.shell()
instanceasync
```rust async fn shell(&self, script: impl Into) -> MicrosandboxResult ``` Run a command through the sandbox's configured shell (default: `/bin/sh`, set via [`SandboxBuilder::shell()`](/sdk/rust/sandbox#shell)). The script is run as ` -c "