Microsandbox: Secure, Self-Hosted Sandboxes for AI Agents and Untrusted Code

Introdução

Microsandbox é um projeto open-source inovador desenvolvido pela zerocore-ai, que oferece sandboxes auto-hospedadas e isoladas por hardware para a execução segura de código de usuário e IA não confiável. Construído em Rust, ele visa superar as limitações de soluções tradicionais como contêineres e máquinas virtuais, fornecendo uma combinação de forte isolamento, tempos de inicialização instantâneos e compatibilidade OCI. Isso o torna uma espinha dorsal ideal para a web agêntica, permitindo ambientes de execução rápidos, seguros e flexíveis para agentes de IA e outras cargas de trabalho exigentes. Com 4498 estrelas e 208 forks, está ganhando uma tração significativa na comunidade de desenvolvedores.

Instalação

Para começar com o Microsandbox, siga estes passos simples:

Baixe microsandbox:

curl -sSL https://get.microsandbox.dev | sh

Inicie o servidor:
```
msb server start --dev
```
Puxe uma imagem de ambiente (Opcional):
```
msb pull microsandbox/python
```

Exemplos

Microsandbox oferece maneiras flexíveis de gerenciar e acessar sandboxes, incluindo utilitários de linha de comando e SDKs para várias linguagens.

Exemplos de Linha de Comando:

Sandbox Temporário: Para tarefas únicas, crie um ambiente limpo que não deixa rastros na saída.
```
msx python # ou `msb exe --image python`
```
Sandboxes em todo o Sistema: Execute sandboxes de longa duração configuradas automaticamente como executáveis em todo o sistema.
```
msi python py-data # ou `msb install --image alpine py-data`
py-data # De qualquer diretório, execute a sandbox
```

Exemplos de SDK (BETA):

Microsandbox fornece SDKs para integrar capacidades de sandboxing diretamente em suas aplicações.

Python:

import asyncio
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="test") as sb:
        exec = await sb.run("name = 'Python'")
        exec = await sb.run("print(f'Hello {name}!')")

    print(await exec.output()) # prints Hello Python!

asyncio.run(main())

JavaScript:

import { NodeSandbox } from "microsandbox";

async function main() {
  const sb = await NodeSandbox.create({ name: "test" });

  try {
    let exec = await sb.run("var name = 'JavaScript'");
    exec = await sb.run("console.log(`Hello ${name}!`)");

    console.log(await exec.output()); // prints Hello JavaScript!
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);

Rust:

use microsandbox::{SandboxOptions, PythonSandbox};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let options = SandboxOptions::builder().name("test").build();
    let mut sb = PythonSandbox::create(options).await?;

    let exec = sb.run(r#"name = "Rust""#).await?;
    let exec = sb.run(r#"print(f"Hello {name}!")"#).await?;

    println!("{}", exec.output().await?); // prints Hello Rust!

    sb.stop().await?;

    Ok(())
}

Porquê usar Microsandbox

Microsandbox se destaca por oferecer uma combinação atraente de recursos que abordam necessidades críticas no desenvolvimento de software moderno, especialmente para aplicações de IA e agênticas:

Forte Isolamento: Atinge isolamento de VM em nível de hardware usando microVMs, garantindo que o código não confiável seja executado em um ambiente altamente seguro.
Inicialização Instantânea: Com tempos de inicialização abaixo de 200 ms, o Microsandbox fornece ambientes de execução quase instantâneos, cruciais para aplicações dinâmicas e responsivas.
Compatível com OCI: Pode executar imagens de contêiner padrão, permitindo que os desenvolvedores aproveitem os ecossistemas existentes de Docker e OCI.
Auto-Hospedado: Implante o Microsandbox dentro de sua própria infraestrutura, dando-lhe total autonomia e controle sobre seus ambientes de execução.
Pronto para IA: Integra-se perfeitamente com fluxos de trabalho de agentes e IA via MCP, tornando-o uma ferramenta poderosa para construir sistemas de IA seguros e escaláveis.

Seu design como a espinha dorsal de execução da web agêntica destaca seu foco em velocidade, segurança e flexibilidade para a próxima geração de aplicações impulsionadas por IA.