编辑

作者：watermelo37

涉及领域：Vue、SpingBoot、Docker、LLM、python等

---------------------------------------------------------------------

温柔地对待温柔的人，包容的三观就是最大的温柔。

---------------------------------------------------------------------

编辑

在线编程实现！如何在Java后端通过DockerClient操作Docker生成python环境

编辑

一、为什么要用后端程序操作Docker

Docker 是现代开发和部署流程中不可或缺的一部分。它简化了应用程序的环境配置、打包和分发，使得在不同机器上运行相同的应用变得更加轻松和一致。本文将详细介绍如何使用命令行工具（CMD）操控 Docker 来配置环境。

实现后端操作docker，可以用来实现云端IDE、一键环境搭建、多人协作环境、互动编程教学、可视化部署和管理等等功能。是Docker从服务器走向客户端的必经之路。

二、安装Docker

1、安装Docker

我写过一份详细的博客，请移步：Docker 入门全攻略：安装、操作与常用命令指南

2、启动Docker

安装完成后，启动 Docker Desktop，并确保其正常运行。可以在 CMD 中通过以下命令来验证：

docker --version

三、DockerClient与CMD操作Docker的区别

说实话，我去年开始做在线编程的时候，入门就是用的DockerClient，后来又做了一个进阶项目自动化配置环境的开发，改成了用Java执行cmd指令来操控Docker，前不久看cmd指令不顺眼，又重新改成了DockerClient。

为什么？因为DockerClient高度封装，将很多细小的指令封装成若干个参数，你看到的就只是一小块含参的链式调用，但其实相当于执行了相当多的“cmd命令”，这样带来的结果就是提升了入门难度，并且长期维护和二次开发需要对DockerClient有较高的熟练度和较深的理解，不像cmd，一行有一行的作用，一行比一行清晰，大致有一个印象就能马上知道它的含义。比如docker cp是复制，比如docker build是镜像生成，再比如docker run用来启动容器，指令后面的参数也高度语义化，非常好理解，最最最关键的是，用cmd指令的时候如果有bug，只需要在终端里面输入执行，查看返回内容以及Docker engine里面的状态，就能知道哪里有bug，非常方便。

但是cmd的缺点也很明显，比如命令执行较散乱，要注意异步请求的时间节点控制、及时使用websocket返回流式数据等...

“cmd是这样的，DockerClient只需要把你要执行的命令写到链式调用的参数里面就行了，用cmd要考虑的可就多了”（套公式解题就是快）来看一个例子：

public void buildImageAndContainer(){
        try {
            // 设置第一个命令：构建Docker镜像
            ProcessBuilder buildProcessBuilder = new ProcessBuilder("docker", "build", "-t", "test0419", ".");
            // 设置工作目录为 "E:\\code\\docker\\test"
            buildProcessBuilder.directory(new File("E:\\code\\docker\\test"));
            // 启动构建镜像的命令并等待其完成
            Process buildProcess = buildProcessBuilder.start();
            buildProcess.waitFor();
            // 读取并打印出构建镜像的输出
            printProcessOutput(buildProcess);
            // 检查构建是否成功
            if (buildProcess.exitValue() == 0) {
                // 设置第二个命令：运行Docker容器
                ProcessBuilder runProcessBuilder = new ProcessBuilder("docker", "run", "-v", "E:/code/docker/test:/app", "-p", "80:80", "test0419");
                // 启动运行容器的命令
                Process runProcess = runProcessBuilder.start();
                // 读取并打印出运行容器的输出
                printProcessOutput(runProcess);
                // 可以在这里等待容器运行的进程结束，或者根据需要进行其他操作
                // runProcess.waitFor();
            } else {
                System.out.println("Docker image build failed.");
            }
        } catch (IOException | InterruptedException e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }

这一大段代码包括根据Dockerfile文件创建镜像并生成一个容器，并获取执行时的日志信息，以及错误抛出。但是如果使用DockerClient就一两行代码，区别就是这么大。

这里有一篇基础的使用cmd调用Java后端操作Docker的博文，感兴趣请移步：干货含源码！如何用Java后端操作Docker（命令行篇）

综上所述，如果你对Docker的原理和执行逻辑比较熟悉，并且需要较多的副产物（日志数据，错误抛出，容器复用，用户管理等），可以考虑使用cmd指令，开发反馈非常好。如果你对Docker的运作机理还不太了解，或者你对Docker已经熟悉透了，都可以使用DockerClient来开发，流程更加整体，代码简洁。

本篇文章将带大家来看看如何使用DockerClient操作Docker生成python环境，该思路同样适用于所有在线编程的开发过程。

其他Docker相关文章请上划到文章标题下，在专栏中查阅，希望您能找到您的开发思路，有疑问的也欢迎大家前来沟通：

编辑

四、干货！如何使用DockerClient实现在线编程

编辑

1、前置工作

①引入并安装依赖

<dependency>
            <groupId>com.github.docker-java</groupId>
            <artifactId>docker-java</artifactId>
            <version>3.2.5</version> 
        </dependency>

②构建Java与Docker的链接关系

首先你需要让你的java拥有Docker的访问权限，如果是linux系统比较简单，但如果是windows就需要先做好Docker的配置，配置代码如下（我稍后会写一篇博文介绍如何在各种系统上正确的使用Java连接Docker，敬请期待，如果我忘了请踢我的屁股）：

package edu.njnu.opengms.r2.config;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.core.DefaultDockerClientConfig;
import com.github.dockerjava.core.DockerClientImpl;
import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;
import com.github.dockerjava.transport.DockerHttpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;
@Configuration
public class dockerConfig {
    @Value("${docker.clientHost}")
    private String clientHost;
    @Value("${docker.clientPort}")
    private String clientPort;
    @Bean(name = "dockerClient")
    DockerClient dockerClient() {
        return connect();
//        return DockerClientBuilder.getInstance().build();
    }
    //    连接docker
    private DockerClient connect() {
        String host = "tcp://" + clientHost + ":" + clientPort;
        DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                .withDockerHost(host)
                .build();
        DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
                .dockerHost(config.getDockerHost())
                .maxConnections(100)
                .connectionTimeout(Duration.ofSeconds(30))
                .responseTimeout(Duration.ofSeconds(180))
                .build();
        DockerClient client = DockerClientImpl.getInstance(config, httpClient);
        return client;
//        log.info("docker initialize successfully");
    }
}

在需要使用到DockerClient的位置（比如Controller或者Service）注入依赖

@Autowired
    DockerClient dockerClient;

③在宿主机上安装一个基础镜像

随便安装一个你需要的基础镜像，比如python:3.9，但如果是从github上拉取的话，有魔法会更快一些，不然有time out 的风险

docker pull python:3.9

④在宿主机上准备一个工作目录

新建一个docker专用的文件夹，记录路径，在Java中定义为常量，比如：

private static final String WORKING_DIRECTORY = "E:\\code\\docker\\workDirectory\\";

这一步是为了做卷挂载，卷挂载后容器内指定文件夹的内容会与宿主机上指定文件夹的内容完全一致

⑤其他工作

写好api、返回数据结构等。

2、生成并启动容器

有了基础镜像就可以开始生成容器了，这里是接收一个id，然后根据id生成对应的容器和映射文件夹。如果你的在线编程开发不需要涉及多用户功能，就可以舍去获取id、生成文件夹、检查文件夹是否存在这些步骤。

这里有个细节是指令：.withCmd("tail", "-f", "/dev/null")

这个指令的作用是让容器持续的运行下去，这样一个容器可以反复调用不同的脚本，而不是运行完某一个脚本立刻停止。

@PostMapping("/createContainer")
    public JsonResult createContainer(@RequestParam("scenarioId") String scenarioId,@RequestParam("env") String image) {
        // 检查WORKING_DIRECTORY+"\\scenarioId"这个文件夹是否存在，如果不存在就创建一个
        String fullDirectoryPath = WORKING_DIRECTORY + File.separator + scenarioId;
        File directory = new File(fullDirectoryPath);
        if (!directory.exists()) {
            boolean isCreated = directory.mkdirs();
            if (!isCreated) {
                return ResultUtils.error("Failed to create directory");
            }
        }
        // 检查data子文件夹是否存在，如果不存在就创建一个
        File dataDirectory = new File(fullDirectoryPath + File.separator + "data");
        if (!dataDirectory.exists()) {
            boolean isCreated = dataDirectory.mkdirs();
            if (!isCreated) {
                return ResultUtils.error("Failed to create data directory");
            }
        }
        // 生成容器，并绑定卷挂载目录
        try {
            CreateContainerResponse container = dockerClient.createContainerCmd(image)
                    // 容器持久化运行，这样可以多次使用某个容器调用不同的python脚本
                    .withCmd("tail", "-f", "/dev/null")
                    // 卷挂载，将宿主机文件夹与容器文件夹绑定起来
                    .withHostConfig(new HostConfig().withBinds(new Bind(fullDirectoryPath, new Volume("/app"))))
                    .exec();
            // 启动容器
            dockerClient.startContainerCmd(container.getId()).exec();
            return ResultUtils.success(container.getId());
        }catch(DockerException | DockerClientException e){
            System.out.println(e.getMessage());
            return ResultUtils.error("Error occurred while creating or starting the container: " + e.getMessage());
        }
    }

3、安装python脚本所需的依赖

@PostMapping("/installRequires")
    public JsonResult installRequires(@RequestParam("containerId") String containerId){
        try {
            ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(containerId)
                    .withCmd("pip", "install", "-r", "/app/requirements.txt")
                    .withAttachStdout(true)
                    .withAttachStderr(true)
                    .exec();
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            dockerClient.execStartCmd(execCreateCmdResponse.getId())
                    .exec(new ExecStartResultCallback(outputStream, System.err))
                    .awaitCompletion();
            return ResultUtils.success(outputStream.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
            return ResultUtils.error("Error installing dependencies: " + e.getMessage());
        }
    }

执行这一步骤前需要将requirements.txt文件放入宿主机的对应文件夹中（在该案例中是WORKING_DIRECTORY + File.separator + scenarioId;），我写了一个文件上传的api和python代码解析的api，这两种方式都可以生成requirements.txt文件，如果不涉及用户操作，可以直接手动把requirements.txt文件放入对应文件夹中。

requirements.txt文件里面是需要装的依赖库的安装别名，可以指定版本，内容就是这样：

pandas
scikit-learn
matplotlib
numpy

4、执行脚本

这个api可以多次执行，容器执行完毕后不会立刻停止。

@PostMapping("/executeScript")
    public JsonResult executeScript(@RequestParam("containerId") String containerId,@RequestParam("scriptName") String scriptName,@RequestParam("scenarioId") String scenarioId) throws IOException {
        try {
            ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(containerId)
                    .withCmd("python", "/app/" + scriptName)
                    .withAttachStdout(true)
                    .withAttachStderr(true)
                    .exec();
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            dockerClient.execStartCmd(execCreateCmdResponse.getId())
                    .exec(new ExecStartResultCallback(outputStream, System.err))
                    .awaitCompletion();
            return ResultUtils.success(outputStream);
        } catch (InterruptedException | IOException e) {
            e.printStackTrace();
            return ResultUtils.success(outputStream);
        }
    }

5、删除容器，清空工作目录

容器使用完毕后，可以删除容器释放资源。

@PostMapping("/destroyContainer")
    public JsonResult destroyContainer(@RequestParam("containerId") String containerId){
        // 关闭并删除容器
        String containerState = "";
        try{
            dockerClient.stopContainerCmd(containerId).exec();
            dockerClient.removeContainerCmd(containerId).exec();
            containerState = "容器已成功移除";
        }catch (Exception e){
            containerState = "容器删除失败，错误原因： " +e.getMessage();
        }
        //清空工作目录
        String filesState = pythonEnvironmentalService.cleanWorkingDirectory();
        return ResultUtils.success(containerState+filesState);
    }

清除工作目录的Service层函数

// 清除工作目录内容
    public String cleanWorkingDirectory(){
        Path workingDirectoryPath = Paths.get(WORKING_DIRECTORY);
        try {
            deleteDirectoryRecursively(workingDirectoryPath);
            return "工作目录及其所有内容已被删除: " + WORKING_DIRECTORY;
        } catch (IOException e) {
            return e.getMessage();
        }
    }
    // 清空文件夹中非文件夹的方法，同时通过递归清除文件夹
    private static void deleteDirectoryRecursively(Path path) throws IOException {
        if (Files.notExists(path)) {
            // 如果路径不存在，则不需要删除
            return;
        }
        if (Files.isDirectory(path)) {
            // 如果是目录，则获取目录中的所有条目
            Files.list(path).forEach(child -> {
                try {
                    // 对每个条目递归调用此方法
                    deleteDirectoryRecursively(child);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
        // 删除当前文件或目录（此时它应该是空的）
        if (!path.equals(Paths.get(WORKING_DIRECTORY))&&!path.equals(Paths.get(WORKING_DIRECTORY+"\\data"))) {
            Files.delete(path);
        }
    }