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

作者：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);
        }
    }

五、总结

    以上内容是一个简单的实现在Java后端中通过DockerClient操作Docker生成python环境并执行代码，最后销毁的案例全过程，也是实现一个简单的在线编程后端API的完整流程，你可以在此基础上添加额外的辅助功能，比如上传文件、编辑文件、查阅文件、自定义安装等功能。

    只有锻炼思维才能可持续地解决问题，只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助，麻烦您点个赞支持一下，还可以收藏起来以备不时之需，有疑问和错误欢迎在评论区指出~

    更多优质内容，请关注：

    你真的会使用Vue3的onMounted钩子函数吗？Vue3中onMounted的用法详解

    通过array.filter()实现数组的数据筛选、数据清洗和链式调用

** **极致的灵活度满足工程美学：用Vue Flow绘制一个完美流程图

    el-table实现动态数据的实时排序，一篇文章讲清楚elementui的表格排序功能

    干货含源码！如何用Java后端操作Docker（命令行篇）

    JavaScript中闭包详解+举例，闭包的各种实践场景：高级技巧与实用指南

    PDF预览：利用vue3-pdf-app实现前端PDF在线展示

    Docker 入门全攻略：安装、操作与常用命令指南

    shpfile转GeoJSON且控制转化精度；如何获取GeoJSON？GeoJson结构详解

    巧用Array.forEach：简化循环与增强代码可读性

    通过array.reduce(）实现数据汇总、条件筛选和映射、对象属性的扁平化、转换数据格式等

    Mapbox添加行政区矢量图层、分级设色图层、自定义鼠标悬浮框、添加天地图底图等

标签： docker 容器微服务

本文转载自: https://blog.csdn.net/RenGJ010617/article/details/142051490
版权归原作者 watermelo37 所有，如有侵权，请联系我们删除。

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

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

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

二、安装Docker

1、安装Docker

2、启动Docker

三、DockerClient与CMD操作Docker的区别

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

1、前置工作

①引入并安装依赖

②构建Java与Docker的链接关系

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

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

⑤其他工作

2、生成并启动容器

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

4、执行脚本

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

五、总结

发表评论

“在线编程实现！如何在Java后端通过DockerClient操作Docker生成python环境”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航

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

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

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

二、安装Docker

1、安装Docker

2、启动Docker

三、DockerClient与CMD操作Docker的区别

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

1、前置工作

①引入并安装依赖

②构建Java与Docker的链接关系

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

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

⑤其他工作

2、生成并启动容器

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

4、 执行脚本

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

五、总结

发表评论

“在线编程实现！如何在Java后端通过DockerClient操作Docker生成python环境”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航

4、执行脚本