快速入门：使用 MXC SDK 运行工作负荷

使用 .NET、TypeScript 或 Rust SDK 在Windows进程隔离中运行命令。每个示例创建一个示例输入，允许工作负荷读取它，并授予对单独输出文件夹的写入权限。网络和 UI 权限仍未被授予。

主机应用创建策略并处理结果。该命令在 MXC 内运行；主机应用的其余部分则不会在 MXC 内运行。

这些示例使用 MXC 1.0 V1 SDK API。 V1 SDK 在内部使用稳定的 1.0.0 架构，因此您无需在请求中指定架构版本。请参阅选择兼容的架构。

Prerequisites

您需要：

Windows 11版本 24H2 或更高版本，并具有受支持的 ProcessContainer 环境。
对于 C#，需要 .NET 8 SDK 或更高版本以及 Microsoft.Mxc.Sdk NuGet 包。
对于 TypeScript、npm、@microsoft/mxc-sdk 包，以及 Node.js 24 版本系列中的 Node.js 24.21.0 或更高版本，或 Node.js 26.8.0 或更高版本。
对于 Rust，需要稳定的 Rust 工具链、MSVC 生成工具以及 mxc-sdk crate。请参阅在 Windows 上设置你的 Rust 开发环境。
需要可写的工作目录和 PowerShell 来运行安装命令。

这些说明使用来自 NuGet.org、npm 和 crates.io 的 MXC 1.0 包。无需 MXC 源代码构建。

运行示例之前，请检查平台支持。受支持的Windows版本不能保证每个可选功能都可用。

在某些主机上，MXC 在基于 AppContainer 的回退层中运行进程隔离。该层需要对系统驱动器和空设备进行一次性准备，且空设备设置在每次重启时都会重置。在未完成准备工作的情况下，MXC 的主机探测将返回一条警告，指出要运行的 wxc-host-prep.exe 子命令。 TypeScript 示例会打印来自 getPlatformSupport() 的这些警告，还可以通过运行 wxc-exec.exe --probe 来检查主机。由于 wxc-host-prep.exe 需要获得管理员批准，因此让管理员运行建议的命令，而不是从应用中运行它。有关详细信息，请参阅主机准备。

1.创建项目

创建控制台应用并从 NuGet.org 添加 MXC 包：

dotnet new console -n MxcQuickstart
Set-Location MxcQuickstart
dotnet add package Microsoft.Mxc.Sdk

创建 Node.js 项目、安装 MXC 并添加 tsx 以运行 TypeScript 示例：

New-Item -ItemType Directory MxcQuickstart
Set-Location MxcQuickstart
npm init -y
npm pkg set type=module
npm install @microsoft/mxc-sdk
npm install --save-dev tsx

创建二进制包并从 crates.io 添加 MXC 包：

cargo new mxc-quickstart
Set-Location mxc-quickstart
cargo add mxc-sdk

2. 定义并运行工作负载

进程隔离适用于此生存期较短的命令，因为它仅需要选定的主机文件且无需保留环境。其他工作负荷可能需要不同的包含类型。

主机在项目目录下创建 workspace\input 和 workspace\output。包含的命令读取 input.txt 和写入 result.txt。它没有对其输入目录的写入访问权限，也无权访问其他项目文件。

主机提供一个小型的显式环境，而不是继承其自身的变量。为 Windows ProcessContainer 工作负荷提供环境时，请同时包含 SystemRoot 和 LOCALAPPDATA。如果两者中任一缺失，MXC 会在启动前拒绝该请求。该示例将 LOCALAPPDATA、TEMP 和 TMP 指向已授予的输出目录，以便将临时文件和每用户文件限制在策略范围内。

替换为 Program.cs ：

using Microsoft.Mxc.Sdk.V1;

if (!OperatingSystem.IsWindows())
{
    Console.Error.WriteLine("This example requires Windows.");
    return 1;
}

try
{
    var support = MxcPlatform.GetPlatformSupport();
    if (!support.IsSupported ||
        !support.AvailableMethods.Contains(ContainmentBackend.ProcessContainer))
    {
        Console.Error.WriteLine(support.Reason ?? "Windows ProcessContainer is unavailable.");
        return 1;
    }

    string inputDirectory = Path.GetFullPath(@"workspace\input");
    string outputDirectory = Path.GetFullPath(@"workspace\output");
    string outputFile = Path.Combine(outputDirectory, "result.txt");
    string commandInterpreter = Path.Combine(Environment.SystemDirectory, "cmd.exe");

    Directory.CreateDirectory(inputDirectory);
    Directory.CreateDirectory(outputDirectory);
    File.WriteAllText(Path.Combine(inputDirectory, "input.txt"), "Hello from MXC!\n");

    var request = new ContainerRequest(
        $"\"{commandInterpreter}\" /d /c type input.txt > \"{outputFile}\"")
    {
        Containment = new Containment.Process(),
        Filesystem = new FilesystemPolicy
        {
            ReadonlyPaths = { inputDirectory, commandInterpreter },
            ReadwritePaths = { outputDirectory },
        },
        // Omitted network and UI permissions remain denied.
        WorkingDirectory = inputDirectory,
        Environment = new()
        {
            ["SystemRoot"] = Environment.GetFolderPath(Environment.SpecialFolder.Windows),
            ["LOCALAPPDATA"] = outputDirectory,
            ["TEMP"] = outputDirectory,
            ["TMP"] = outputDirectory,
        },
        TimeoutMs = 30_000,
    };

    ExecutionResult result = await MxcContainer.RunAsync(request);
    Console.Write(result.Stdout);
    Console.Error.Write(result.Stderr);
    foreach (string warning in result.Warnings)
    {
        Console.Error.WriteLine(warning);
    }

    if (result.TimedOut)
    {
        Console.Error.WriteLine("The workload exceeded its timeout.");
        return 1;
    }

    Console.WriteLine($"Sandbox exited with code {result.ExitCode}");
    if (result.ExitCode == 0)
    {
        Console.Write(File.ReadAllText(outputFile));
    }
    return result.ExitCode;
}
catch (MxcException ex)
{
    Console.Error.WriteLine(ex);
    if (ex.Remediation is not null)
    {
        Console.Error.WriteLine(ex.Remediation);
    }
    return 1;
}

运行应用：

dotnet run

创建 sandbox.ts ：

import {
  getPlatformSupport,
  MxcError,
  run,
  type ContainerRequest,
} from '@microsoft/mxc-sdk/v1';
import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { join, resolve } from 'node:path';

try {
  const systemRoot = process.env.SystemRoot;
  if (process.platform !== 'win32' || !systemRoot) {
    throw new Error('This example requires Windows and SystemRoot.');
  }

  const support = getPlatformSupport();
  if (!support.isSupported || !support.availableMethods.includes('processcontainer')) {
    throw new Error(support.reason ?? 'Windows ProcessContainer is unavailable.');
  }
  for (const warning of support.isolationWarnings ?? []) {
    console.error(warning);
  }

  const inputDirectory = resolve('workspace', 'input');
  const outputDirectory = resolve('workspace', 'output');
  const outputFile = join(outputDirectory, 'result.txt');
  const commandInterpreter = join(systemRoot, 'System32', 'cmd.exe');

  mkdirSync(inputDirectory, { recursive: true });
  mkdirSync(outputDirectory, { recursive: true });
  writeFileSync(join(inputDirectory, 'input.txt'), 'Hello from MXC!\n');

  const request: ContainerRequest = {
    command: `"${commandInterpreter}" /d /c type input.txt > "${outputFile}"`,
    containment: { type: 'process' },
    filesystem: {
      readonlyPaths: [inputDirectory, commandInterpreter],
      readwritePaths: [outputDirectory],
    },
    // Omitted network and UI permissions remain denied.
    workingDirectory: inputDirectory,
    environment: {
      SystemRoot: systemRoot,
      LOCALAPPDATA: outputDirectory,
      TEMP: outputDirectory,
      TMP: outputDirectory,
    },
    timeoutMs: 30_000,
  };

  const result = await run(request);
  process.stdout.write(result.stdout);
  process.stderr.write(result.stderr);
  for (const warning of result.warnings) {
    console.error(warning);
  }

  if (result.timedOut) {
    throw new Error('The workload exceeded its timeout.');
  }

  console.log(`Sandbox exited with code ${result.exitCode}`);
  if (result.exitCode === 0) {
    process.stdout.write(readFileSync(outputFile, 'utf8'));
  }
  process.exitCode = result.exitCode;
} catch (error) {
  console.error(error);
  if (error instanceof MxcError && error.remediation) {
    console.error(error.remediation);
  }
  process.exitCode = 1;
}

运行应用：

npx tsx sandbox.ts

替换为 src\main.rs ：

use std::env;
use std::error::Error;
use std::fs;
use std::io::{self, Write};
use std::path::Path;

use mxc_sdk::v1::{self, ContainerRequest, Containment, FilesystemPolicy, WaitResult};

fn main() {
    match run() {
        Ok(code) => std::process::exit(code),
        Err(error) => {
            eprintln!("{error}");
            std::process::exit(1);
        }
    }
}

fn run() -> Result<i32, Box<dyn Error>> {
    if !cfg!(windows) {
        return Err("This example requires Windows.".into());
    }

    let support = v1::platform_support();
    if !support.is_supported
        || !support.available_methods.iter().any(|method| method == "processcontainer")
    {
        let reason = support
            .reason
            .unwrap_or_else(|| "Windows ProcessContainer is unavailable.".into());
        return Err(reason.into());
    }

    let system_root = env::var("SystemRoot")?;
    let project_directory = env::current_dir()?;
    let input_directory = project_directory.join("workspace").join("input");
    let output_directory = project_directory.join("workspace").join("output");
    let output_file = output_directory.join("result.txt");
    let command_interpreter = Path::new(&system_root).join("System32").join("cmd.exe");

    fs::create_dir_all(&input_directory)?;
    fs::create_dir_all(&output_directory)?;
    fs::write(input_directory.join("input.txt"), "Hello from MXC!\n")?;

    let input_path = input_directory.display().to_string();
    let output_path = output_directory.display().to_string();
    let request = ContainerRequest {
        containment: Containment::Process,
        filesystem: Some(FilesystemPolicy {
            readonly_paths: vec![input_path.clone(), command_interpreter.display().to_string()],
            readwrite_paths: vec![output_path.clone()],
            ..Default::default()
        }),
        // Omitted network and UI permissions remain denied.
        working_directory: Some(input_path),
        environment: Some(vec![
            ("SystemRoot".into(), system_root),
            ("LOCALAPPDATA".into(), output_path.clone()),
            ("TEMP".into(), output_path.clone()),
            ("TMP".into(), output_path),
        ]),
        timeout_ms: Some(30_000),
        ..ContainerRequest::new(format!(
            "\"{}\" /d /c type input.txt > \"{}\"",
            command_interpreter.display(),
            output_file.display()
        ))
    };

    let result = match v1::run(request, Default::default()) {
        Ok(result) => result,
        Err(error) => {
            eprintln!("{error}");
            if let Some(remediation) = &error.remediation {
                eprintln!("{remediation}");
            }
            return Ok(1);
        }
    };
    io::stdout().write_all(&result.stdout)?;
    io::stderr().write_all(&result.stderr)?;
    for warning in &result.warnings {
        eprintln!("{warning}");
    }

    let exit_code = match result.outcome {
        WaitResult::Exited(code) => code,
        WaitResult::TimedOut => return Err("The workload exceeded its timeout.".into()),
    };

    println!("Sandbox exited with code {exit_code}");
    if exit_code == 0 {
        print!("{}", fs::read_to_string(&output_file)?);
    }
    Ok(exit_code)
}

运行应用：

cargo run

每个版本输出如下：

Sandbox exited with code 0
Hello from MXC!

还可以检查 workspace\output\result.txt。

3.验证被拒绝的操作

仅更改输出文件声明，以便命令尝试写入只读输入目录：

string outputFile = Path.Combine(inputDirectory, "blocked.txt");

const outputFile = join(inputDirectory, 'blocked.txt');

let output_file = input_directory.join("blocked.txt");

在不更改策略的情况下再次运行应用。预期出现访问被拒绝错误和非零退出代码，没有新 workspace\input\blocked.txt 文件。还原原始输出文件声明，并确认该允许的操作仍可成功执行。

如果获准执行失败，请将主机设置或配置错误与资源拒绝区分开来。使用学习模式调查后者;不要自动扩大策略。

4. 使示例适配

将示例命令和输入替换为受信任的代表性工作负荷。查看所需的工具二进制文件、库、临时文件和输出。仅当任务需要网络或 UI 访问权限，且所选后端能够强制实施预期限制时，才添加这些访问权限。

在每个目标主机上测试允许和拒绝的操作。使用学习模式优化策略时，请查看每个观察结果，并在不启用学习或审核设置的情况下完成强制运行。

可选：使用编码助手

为代理提供目标平台、SDK 语言和版本、命令、所需的资源、生命周期和隔离目标。可以调整此提示：

Use the MXC Learn quickstart and the documentation for my installed SDK release.
Integrate this workload through the .NET, TypeScript, or Rust SDK used by this project.

First identify the command, target platforms, input and output paths, network
and UI requirements, and whether state must persist between commands.
Explain the containment choice and create the narrowest policy that fits.
Run both permitted and denied cases and report the effective permissions.

Do not execute the workload outside MXC to get around a failure. Ask for my
approval before expanding access, changing host settings, or using permissive
Learning Mode. Treat observed resource access as evidence, not automatic grants.

审阅智能体的假设和生成的策略。代理可以协助集成，但受信任的主机代码或人员必须批准对工作负荷权限的更改。

后续步骤

在使用永久性或专用后端之前，请查看 MXC 体系结构和包含模型。
了解如何编写和验证 MXC 策略。
对比 MXC 包含选项和平台支持。
查看完整的学习模式工作流。
根据其他工作负荷调整 MXC 策略示例。
在 MXC 版本中查找 SDK 包和发行说明。

反馈

此页面是否有帮助？

上次更新时间为 2026-10-30

快速入门：使用 MXC SDK 运行工作负荷

Prerequisites

1.创建项目

2. 定义并运行工作负载

3.验证被拒绝的操作

4. 使示例适配

可选：使用编码助手

后续步骤

反馈

其他资源