OJ平台远端代码沙箱开发第一周：需求拆解与Docker核心知识入门

作为DoReMiFaSo团队中负责Docker判题沙箱与系统工程化实现的开发人员，本周正式开启面向算法学习的智能OJ平台代码沙箱模块的开发工作。核心目标是完成远端RPC式代码沙箱的核心需求拆解、隔离方案选型，以及Docker容器化核心知识的系统学习与实操，为后续的架构设计和功能开发打下基础。本周的工作围绕“为什么做”和“用什么做”展开，理清了沙箱开发的核心方向，也掌握了Docker的基础使用和核心操作，以下是详细的学习与调研记录。

一、远端代码沙箱核心需求拆解

本次开发的代码沙箱并非嵌入OJ后端的模块，而是独立部署、可远端RPC调用的判题服务器，作为OJ平台的核心基础服务，承接所有代码判题请求，其核心需求可提炼为5个关键要点，总结如下：

1. 强隔离性：用户提交的代码相互隔离，防止恶意代码（死循环、恶意fork、文件读写）影响主系统或其他用户代码执行；
2. 资源可管控：精准限制代码运行的CPU核心数、内存大小、运行时间，避免单份代码耗尽服务器资源；
3. 远端可调用：作为独立服务，提供标准化的调用接口，OJ后端可跨网络远程调用，支持多连接请求；
4. 并行可处理：支持多判题请求同时执行，提升系统整体并发度，适配多用户同时提交代码的场景；
5. 结果精准化：能采集代码编译/运行的完整日志，返回标准化判题结果（AC/CE/RE等），并提供资源使用详情。

以上需求是后续沙箱开发的核心准则，所有技术选型和功能实现都将围绕这些点展开。

二、代码隔离方案选型：为什么最终选择Docker？

实现代码隔离的方案主要有三种：传统虚拟机、Linux原生namespace+cgroup、Docker容器化，本周通过调研和对比，结合实训项目的开发周期、技术栈匹配度、运维成本，最终选定Docker作为沙箱的隔离技术，三者核心对比如下：

隔离方案	隔离性	启动速度	资源占用	开发成本	生态/工具支持
传统虚拟机	强	慢（分钟级）	高（GB级）	低	差，无轻量调用SDK
Linux namespace+cgroup	中等	快（毫秒级）	低（MB级）	极高	差，需手动封装所有逻辑
Docker容器化	强（满足沙箱需求）	快（秒级）	低（MB级）	低	极优，Go有官方Docker SDK，配套工具完善

选型核心原因：

1. 实训项目开发周期有限，原生Linux namespace+cgroup需要手动实现隔离、资源限制、进程管理，开发成本过高；
2. 传统虚拟机资源占用大、启动慢，完全无法满足沙箱并行处理、高并发的需求；
3. Docker基于Linux namespace+cgroup实现，隔离性足够满足OJ沙箱需求，且轻量、启动快，同时Go语言有官方Docker SDK，能无缝对接项目后端Go技术栈，便于后续开发；
4. Docker的镜像、容器管理体系成熟，能快速实现多语言运行环境的构建，适配C++/Go的判题需求。

简单来说，Docker是兼顾开发效率、运行性能、隔离性的最优解，完全匹配本次远端代码沙箱的开发需求。

三、Docker核心知识系统学习与实操

本周的核心学习内容是Docker的核心概念和基础操作，重点掌握镜像/容器的管理、资源限制、Dockerfile编写、文件挂载四大核心点，这些都是后续沙箱开发的基础，所有操作均在Ubuntu 22.04环境下完成，以下是关键知识点和实操样例。

3.1 Docker核心概念认知

首先理清Docker的三个核心概念：镜像（Image）、容器（Container）、仓库（Repository），这是理解Docker的基础，三者的关系可通过一张架构图直观理解：

• 镜像：只读的模板，包含运行程序所需的所有依赖（系统、编译器、运行时），比如Alpine镜像、Ubuntu镜像，沙箱开发中会基于基础镜像构建自定义的多语言判题镜像；
• 容器：镜像的运行实例，是独立的隔离环境，用户代码将在容器中编译运行，运行完成后可直接销毁，做到一次判题一个容器，完全隔离；
• 仓库：用于存储和分发镜像的地方，比如Docker Hub，可拉取公共基础镜像，也可推送自定义构建的判题镜像。

简单总结：镜像是模板，容器是运行实例，仓库是镜像的仓库。

3.2 Docker基础命令实操：镜像与容器管理

Docker的基础操作围绕镜像和容器展开，以下是沙箱开发中高频使用的命令。

（1）镜像相关核心命令

# 1. 拉取基础镜像
docker pull alpine:3.19

# 2. 查看本地所有镜像
docker images

# 3. 删除指定镜像（IMAGE ID可通过docker images查看）
docker rmi <IMAGE ID>

# 4. 构建自定义镜像
docker build -t <镜像名:标签> <Dockerfile所在目录>

拉取镜像：

（2）容器相关核心命令

容器是沙箱的核心运行载体，重点掌握创建/启动/停止/删除/进入容器的命令：

# 1. 创建并启动容器（--rm表示容器退出后自动删除）
# 运行alpine镜像，进入交互式终端
docker run --rm -it alpine:3.19 /bin/sh

# 2. 查看运行中的容器
docker ps

# 3. 查看所有容器（包括已停止的）
docker ps -a

# 4. 停止运行中的容器（CONTAINER ID可通过docker ps查看）
docker stop <CONTAINER ID>

# 5. 强制删除容器（针对僵尸容器，沙箱需防止容器残留）
docker rm -f <CONTAINER ID>

关键参数说明：--rm是沙箱开发的核心参数，因为每次判题完成后，容器无需保留，自动删除可避免服务器残留大量僵尸容器，节省资源。

3.3 Docker容器资源限制：沙箱的核心需求实现

代码沙箱的核心需求之一是资源管控，Docker提供了原生的资源限制参数，可精准限制容器的CPU、内存、进程数，这是防止用户代码耗尽服务器资源的关键。以下是沙箱开发中高频使用的资源限制命令样例，直接在docker run中添加即可：

# 核心资源限制命令：限制CPU为0.5核，内存为128MB，进程数最大为10
# --cpus=0.5：限制CPU使用量，0.5表示半核
# --memory=128m：限制内存为128MB，超出则容器被杀死
# --pids-limit=10：限制容器内最大进程数，防止恶意fork
docker run --rm -it --cpus=0.5 --memory=128m --pids-limit=10 alpine:3.19 /bin/sh

实操验证：在上述限制的容器中，运行死循环代码或创建大量进程，容器会被Docker直接杀死，完美实现沙箱的资源管控需求。这部分参数后续会通过Go Docker SDK在代码中配置。

3.4 Dockerfile编写：构建自定义判题镜像

Docker的公共基础镜像仅包含基础系统环境，而OJ沙箱需要多语言的编译/运行环境（如C++的g++、Go的Go SDK），因此需要通过Dockerfile构建自定义镜像。Dockerfile是纯文本文件，包含构建镜像的一系列指令，本周重点学习了Dockerfile的基础编写，并实现了C++判题基础镜像的构建，以下是核心内容。

（1）Dockerfile核心基础指令

指令	作用	常用示例
FROM	指定基础镜像	FROM alpine:3.19
RUN	执行终端命令	RUN apk add --no-cache g++
WORKDIR	指定容器工作目录	WORKDIR /app
EXPOSE	声明容器暴露端口	EXPOSE 8080
CMD	容器启动默认命令	CMD ["/bin/sh"]

（2）C++判题基础镜像Dockerfile编写

基于Alpine 3.19构建，仅安装g++编译器和必要依赖，保证镜像轻量（最终体积约80MB），Dockerfile命名为Dockerfile-cpp，内容如下：

# 基础镜像：轻量的Alpine 3.19
FROM alpine:3.19

# 更换Alpine镜像源，加速依赖安装（国内源）
RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories

# 安装g++编译器和libstdc++（C++运行依赖），--no-cache不缓存，减小镜像体积
RUN apk add --no-cache g++ libstdc++

# 指定容器工作目录，后续挂载用户代码到该目录
WORKDIR /judge

# 容器启动默认命令
CMD ["/bin/sh"]

（3）构建自定义镜像并测试

在Dockerfile所在目录执行以下命令，构建名为sandbox-cpp:v1.0的C++判题镜像：

# 构建镜像，-t指定镜像名和标签
docker build -f Dockerfile-cpp -t sandbox-cpp:v1.0 .

# 启动容器，测试g++是否安装成功
docker run --rm -it sandbox-cpp:v1.0 g++ --version

至此，完成了C++判题环境的自定义镜像构建，后续会基于此实现Go语言的判题镜像，通过配置化管理多语言镜像。

3.5 Docker文件挂载：实现代码/测试用例的传递

沙箱运行时，需要将用户提交的代码和测试用例传递到容器内部，Docker的文件挂载功能（-v参数）可实现宿主机与容器的文件共享，这是沙箱开发的核心操作之一，命令样例如下：

# 挂载宿主机的/root/code目录到容器的/judge目录（容器工作目录）
# 宿主机的代码文件会同步到容器中，容器内的运行结果也会同步到宿主机
docker run --rm -it -v /root/code:/judge sandbox-cpp:v1.0 /bin/sh

核心意义：后续沙箱开发中，会将用户提交的代码保存到宿主机的临时目录，然后通过挂载将该目录映射到容器内部，容器内编译运行该代码，运行结果再通过挂载同步回宿主机，最终采集并返回给OJ后端。

四、Go Docker SDK入门初探

本周除了手动实操Docker命令，还初步学习了Go官方Docker SDK（https://pkg.go.dev/github.com/docker/docker/client ），这是后续通过Go代码实现Docker容器的创建、启动、资源限制、销毁的核心工具，简单的入门样例如下（实现通过Go代码查看本地镜像）：

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)

func main() {
	// 创建Docker客户端，适配Docker环境
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		fmt.Fprintf(os.Stderr, "创建Docker客户端失败: %v\n", err)
		os.Exit(1)
	}
	defer cli.Close()

	// 查看本地所有镜像
	images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
	if err != nil {
		fmt.Fprintf(os.Stderr, "获取镜像列表失败: %v\n", err)
		os.Exit(1)
	}

	// 遍历并打印镜像信息
	for _, img := range images {
		fmt.Printf("镜像ID: %s, 标签: %v\n", img.ID[:10], img.RepoTags)
	}
}

运行效果：该代码可直接获取本地Docker的镜像列表，与docker images命令效果一致。这是Go操作Docker的基础，后续会基于该SDK实现所有沙箱的核心逻辑，将手动的Docker命令转化为代码调用。

五、学习总结与下周规划

5.1 学习总结

本周完成了远端代码沙箱的核心需求拆解和隔离方案选型，明确了“Docker容器化+Go Docker SDK”的技术路线，同时系统学习了Docker的核心概念、基础命令、资源限制、Dockerfile编写、文件挂载等关键知识，实现了C++判题基础镜像的构建，也初步掌握了Go Docker SDK的入门使用，为后续开发打下了坚实的基础。

5.2 下周规划

下周的核心工作将围绕远端RPC式沙箱的整体架构设计和gRPC+Protobuf的学习展开，具体目标：

1. 设计独立远端沙箱的整体架构，明确与OJ后端的交互逻辑、请求处理流程；
2. 系统学习gRPC核心原理和Protobuf语法，定义沙箱与OJ后端的RPC调用接口；
3. 搭建gRPC服务端基础工程，实现简单的空接口调用测试，完成“远端调用”的基础框架；
4. 初步梳理Go Docker SDK与gRPC的结合思路，为后续的核心功能开发做准备。

参考资料：

1. Docker官方文档：https://docs.docker.com/engine/reference/commandline/cli/
2. Go Docker SDK官方文档：https://pkg.go.dev/github.com/docker/docker/client
3. Alpine Linux官方镜像：https://hub.docker.com/_/alpine
4. Dockerfile编写最佳实践：https://docs.docker