← 返回首页 📖 📖 Wiki知识库
📐 学习维度 本篇是 📖 📖 Wiki知识库 🏠 首页 🛤️ 学习路径 📚 全部文章

AI Code Interpreter 与代码沙箱深度实战 - 11. Spring Boot 工程化实现

本文是 AI Code Interpreter 与代码沙箱深度实战 的分章阅读版。

11. Spring Boot 工程化实现

11.1 整体架构


┌──────────────────────────────────────────────────────────┐
│                    HTTP / WebSocket                      │
└────────────────────────────┬─────────────────────────────┘
                             │
                  ┌──────────▼──────────┐
                  │ CodeSandboxController│
                  └──────────┬──────────┘
                             │
                  ┌──────────▼──────────┐
                  │ CodeSandboxFacade   │
                  └──────────┬──────────┘
                             │
       ┌─────────────────────┼─────────────────────┐
       │                     │                     │
┌──────▼──────┐    ┌─────────▼─────────┐  ┌────────▼────────┐
│ Sandbox     │    │ Language          │  │ File            │
│ Router      │    │ Adapter Factory   │  │ Storage         │
│ Docker/FC/  │    │ Python/Java/Go/JS │  │ Local/S3        │
│ E2B         │    └───────────────────┘  └─────────────────┘
└─────────────┘
                             │
                  ┌──────────▼──────────┐
                  │ Resource Monitor    │
                  │ - CPU/Memory/Disk   │
                  │ - Timeout Enforcement│
                  └──────────┬──────────┘
                             │
                  ┌──────────▼──────────┐
                  │ Audit Log           │
                  └─────────────────────┘

11.2 核心 Facade


@Service
@RequiredArgsConstructor
public class CodeSandboxFacade {

    private final SandboxRouter sandboxRouter;
    private final LanguageAdapterFactory adapterFactory;
    private final ResourceMonitor resourceMonitor;
    private final AuditLogger auditLogger;
    private final QuotaService quotaService;

    public CodeExecutionResult execute(ExecutionRequest request, Principal principal) {
        String userId = principal.getName();
        long startMs = System.currentTimeMillis();

        // 1. 配额检查
        if (!quotaService.checkQuota(userId, request)) {
            throw new QuotaExceededException("Daily execution limit reached");
        }

        // 2. 代码静态分析 (检测明显恶意)
        StaticAnalysisResult analysis = CodeAnalyzer.analyze(request.code());
        if (analysis.isBlocked()) {
            auditLogger.logBlocked(userId, request, analysis.reason());
            throw new MaliciousCodeException(analysis.reason());
        }

        // 3. 选择沙箱后端
        CodeSandboxService sandbox = sandboxRouter.choose(request.sandboxType());

        // 4. 执行
        try {
            CodeExecutionResult result = sandbox.execute(
                request.code(),
                request.language(),
                request.config()
            );

            // 5. 监控 + 审计
            long durationMs = System.currentTimeMillis() - startMs;
            resourceMonitor.record(userId, request, durationMs, result);
            auditLogger.logSuccess(userId, request, result, durationMs);

            quotaService.consume(userId, request);
            return result;
        } catch (Exception e) {
            auditLogger.logFailure(userId, request, e);
            throw new SandboxException("Execution failed", e);
        }
    }

    public Flux<StreamOutput> executeStream(ExecutionRequest request, Principal principal) {
        return Flux.create(sink -> {
            CodeExecutionResult result = execute(request, principal);
            // 流式输出 stdout
            Arrays.stream(result.stdout().split("\n"))
                .forEach(line -> sink.next(StreamOutput.stdout(line)));
            sink.next(StreamOutput.complete(result.exitCode()));
            sink.complete();
        });
    }
}

public record ExecutionRequest(
    String code,
    Language language,
    ExecutionConfig config,
    SandboxType sandboxType  // DOCKER / FIRECRACKER / E2B / GVISOR
) {}

11.3 沙箱路由


@Service
public class SandboxRouter {

    private final DockerSandboxService dockerSandbox;
    private final GVisorSandboxService gvisorSandbox;
    private final FirecrackerSandboxService fcSandbox;
    private final E2BSandboxService e2bSandbox;

    public CodeSandboxService choose(SandboxType type) {
        return switch (type) {
            case DOCKER -> dockerSandbox;
            case GVISOR -> gvisorSandbox;
            case FIRECRACKER -> fcSandbox;
            case E2B -> e2bSandbox;
            case AUTO -> chooseAutomatic();
        };
    }

    private CodeSandboxService chooseAutomatic() {
        // 自动选择:优先 E2B (SaaS) → Firecracker (高性能) → gVisor (安全) → Docker
        if (e2bSandbox.isAvailable()) return e2bSandbox;
        if (fcSandbox.isAvailable()) return fcSandbox;
        if (gvisorSandbox.isAvailable()) return gvisorSandbox;
        return dockerSandbox;
    }
}

enum SandboxType { DOCKER, GVISOR, FIRECRACKER, E2B, AUTO }

11.4 Controller


@RestController
@RequestMapping("/api/sandbox")
public class CodeSandboxController {

    private final CodeSandboxFacade facade;

    @PostMapping("/execute")
    public CodeExecutionResult execute(@RequestBody ExecutionRequest req, Principal principal) {
        return facade.execute(req, principal);
    }

    @PostMapping(value = "/execute-stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<Object>> stream(@RequestBody ExecutionRequest req, Principal principal) {
        return facade.executeStream(req, principal)
            .map(out -> switch (out) {
                case StreamOutput.Stdout s -> ServerSentEvent.<Object>builder(s.line()).event("stdout").build();
                case StreamOutput.Stderr s -> ServerSentEvent.<Object>builder(s.line()).event("stderr").build();
                case StreamOutput.Complete c -> ServerSentEvent.<Object>builder(c.exitCode()).event("complete").build();
            });
    }

    @PostMapping("/jupyter/{sessionId}/execute")
    public ExecutionResult executeJupyter(@PathVariable String sessionId,
                                           @RequestBody JupyterRequest req,
                                           Principal principal) {
        return jupyterKernelClient.execute(sessionId, req.code());
    }

    @PostMapping("/jupyter/{sessionId}/restart")
    public ResponseEntity<Void> restartKernel(@PathVariable String sessionId) {
        jupyterKernelClient.restartKernel(sessionId);
        return ResponseEntity.noContent().build();
    }
}

11.5 资源监控


@Component
public class ResourceMonitor {

    private final MeterRegistry meterRegistry;

    public void record(String userId, ExecutionRequest req, long durationMs,
                       CodeExecutionResult result) {
        Tags tags = Tags.of(
            "user", userId,
            "language", req.language().name(),
            "sandbox", req.sandboxType().name(),
            "result", result.exitCode() == 0 ? "success" : "failed"
        );

        meterRegistry.counter("sandbox.executions.total", tags).increment();
        meterRegistry.timer("sandbox.execution.duration", tags)
            .record(durationMs, TimeUnit.MILLISECONDS);

        if (result.exitCode() != 0) {
            meterRegistry.counter("sandbox.failures.total", tags).increment();
        }
    }
}

11.6 配置


sandbox:
  default-type: AUTO
  docker:
    enabled: true
    pool-size: 10
    default-memory-mb: 512
    default-cpus: 1.0
    default-timeout-sec: 30
  gvisor:
    enabled: false  # 需要安装 gVisor
  firecracker:
    enabled: false  # 需要 KVM 支持
    kernel-image: /var/lib/firecracker/vmlinux
    rootfs: /var/lib/firecracker/rootfs.ext4
    pool-size: 20
  e2b:
    enabled: true
    api-key: ${E2B_API_KEY}
  jupyter:
    server-url: http://jupyter:8888
    default-kernel: python3
  quota:
    daily-executions: 100
    daily-cpu-seconds: 1800
    daily-memory-mb-hours: 10240


相关页面