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
相关页面