jenkins 持续部署 docker服务到堡垒机

淩亂°似流年 2023-07-25 09:44 122阅读 0赞

简介

公司原来的项目发布很繁琐也很普通，最近捣鼓一下jenkins+docker，做一下一键发布，由于公司服务器都加了堡垒机，所以需要解决不能远程ssh部署，整体的思路如下：

  1. jenkins使用pipeline脚本编写（更灵活，方便多套环境复制使用）；
  2. 拉取代码并编译成jar包；
  3. 将jar包编译为docker镜像；
  4. 将镜像上传到本地私有仓库（速度快）
  5. 调用写好的跑脚本的服务接口实现在堡垒机中实现docker镜像的新版本发布；

关于jenkins的安装方式一开始尝试了很多种方案：

  • jenkins部署在docker容器内，使用远程docker rest api进行镜像打包上传，但是遇到很大的问题就是阿里云私有镜像仓库登录方式不一样，导致登录失败，而且不能使用脚本操作docker，因为jenkins容器内没有docker环境，如果安装docker in docker，这样就太麻烦了，在容器外面就有一套docker环境；(如果不依赖阿里云私有仓库，这种方案就没有关系了)
  • jenkins安装在有docker环境的服务器内，那么可以使用shell脚本灵活的进行编译上传等操作（适用于比较灵活的使用场景）

开始：

依赖环境：

  • jenkins
  • docker

jenkins安装

安装步骤请查询相关文档，这里就略过

jenkins安装插件提速

  1. cd {你的Jenkins工作目录}/updates  #进入更新配置位置
  3. vim default.json
  5. ##替换软件源
  6. :1,$s/http:\/\/updates.jenkins-ci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g

安装jenkins插件 HTTP Request

这个插件用于jenkins将docker镜像push到目标仓库之后调用堡垒机中发布服务进行docker镜像的发布

编写jenkins发布脚本

步骤：新建item -> 选择pipeline（流水线） -> 编辑流水线脚本

注意：

  • 在输入框的左下角有：流水线语法，可以根据某些你需要用到的插件生成模板脚本，非常方便

  • 脚本有一点需要注意，单引号内只能为文本不能使用变量，如果需要使用变量，使用双引号；

    pipeline {
    agent any

    tools {

    1.   // Install the Maven version configured as "M3" and add it to the path.
    2.   maven "maven3.6.3"

    }

    //环境变量，一下变量名称都可以自定义，在后面的脚本中使用
    environment {

    1.   //git仓库
    2.   GIT_REGISTRY = 'https://github.com/WinterChenS/my-site.git'
    3.   //分支
    4.   GIT_BRANCH = 'sit'
    5.   //profile
    6.   PROFILES = 'sit'
    7.   //如果仓库是私有的需要在凭证中添加凭证，然后把id写到这里
    8.   GITLAB_ACCESS_TOKEN_ID = '85465d36-4c3a-469f-b92f-f53dae47fd0c'
    9.   //服务名称
    10.   SERVICE_NAME = 'my-site'
    11.   //镜像名称,aaa_sit是命名空间，可以区分不同的环境
    12.   IMAGE_NAME = "127.0.0.1:8999/aaa_sit/${SERVICE_NAME}"
    13.   //镜像tag
    14.   TAG = "latest"
    15.   //远程发布服务的地址
    16.   REMOTE_EXECUTE_HOST = 'http://10.85.54.33:7017/shell'
    17.   //服务开放的端口
    18.   SERVER_PORT = '19070'
    19.   //日志目录，容器内目录
    20.   LOG_DIR = '/var/logs'
    21.   //宿主机目录
    22.   MAIN_VOLUME = "${LOG_DIR}/jar_${env.SERVER_PORT}"
    23.   //jvm参数
    24.   JVM_ARG = "-server -Xms512m -Xmx512m  -XX:+HeapDumpOnOutOfMemoryError  -XX:HeapDumpPath=${LOG_DIR}/dump/dump-yyy.log  -XX:ErrorFile=${LOG_DIR}/jvm/jvm-crash.log"

    }

  1.    stages {
  2.       stage('Build') {
  3.          steps {
  4.             // 获取代码
  5.             git credentialsId: "${env.GITLAB_ACCESS_TOKEN_ID}", url: "${env.GIT_REGISTRY}", branch: "${env.GIT_BRANCH}"
  7.             // maven 打包
  8.             sh "mvn -Dmaven.test.failure.ignore=true clean package -P ${env.PROFILES}"
  10.          }
  12.       }
  14.       stage('Execute shell') {
  15.         // 将jar包拷贝到Dockerfile所在目录
  16.         steps {
  17.             //注意，这里的目录一定要跟项目实际的目录结构要对应上
  18.             sh "cp ${env.WORKSPACE}/${env.SERVICE_NAME}/target/*.jar ${env.WORKSPACE}/${env.SERVICE_NAME}/src/main/docker/${env.SERVICE_NAME}.jar"
  20.         }
  21.       }
  26.       stage('Image Build And Push') {
  28.         steps {
  29.             //运行这些脚本的条件就是jenkins运行的服务器有docker环境
  30.             //如果jdk版本是你自己编译成的docker镜像，那么首次编译的时候需要pull
  31.             sh "echo '================开始拉取基础镜像jdk1.8================'"    
  32.             //这里根据你的私有仓库而定，如果是使用公共镜像的openjdk那么可以略过这一步
  33.             sh "docker pull 127.0.0.1:8999/jdk/jdk1.8:8u171"
  34.             sh "echo '================基础镜像拉取完毕================'"
  36.             sh "echo '================开始编译并上传镜像================'"
  37.             //注意目录结构
  38.             sh "cd ${env.WORKSPACE}/${env.SERVICE_NAME}/src/main/docker/ && docker build -t ${env.IMAGE_NAME}:${env.TAG} . && docker push ${env.IMAGE_NAME}:${env.TAG}"
  39.             sh "echo '================镜像上传成功================'"
  41.             sh "echo '================删除本地镜像================'"
  42.             //删除本地镜像防止占用资源
  43.             sh "docker rmi ${env.IMAGE_NAME}:${env.TAG}"
  45.         }
  48.       }
  50.       stage('Execute service') {
  52.         //请求堡垒机内的发布服务，具体代码后面会给出
  53.         steps {
  54.             //以下整个脚本都依赖jenkins插件：HTTP Request
  55.             //将body转换为json
  56.             script {
  57.               def toJson = {
  58.                 input ->
  59.                 groovy.json.JsonOutput.toJson(input)
  60.             }
  61.             //body定义,根据实际情况而定
  62.             def body = [
  63.                 imageName: "${env.IMAGE_NAME}",
  64.                 tag:"${env.TAG}",
  65.                 port:"${env.SERVER_PORT}",
  66.                 simpleImageName: "${env.SERVICE_NAME}",
  67.                 envs: [
  68.                     JVM_ARGS: "${env.JVM_ARG}"
  69.                 ],
  70.                 volumes: ["${env.MAIN_VOLUME}:${env.LOG_DIR}"]
  71.             ]
  73.             sh "echo '================开始调用目标服务器发布================'"
  74.             response = httpRequest acceptType: 'APPLICATION_JSON', consoleLogResponseBody: true, contentType: 'APPLICATION_JSON', httpMode: 'POST', requestBody: toJson(body), responseHandle: 'NONE', url: "${env.REMOTE_EXECUTE_HOST}"
  75.             sh "echo '================结束调用目标服务器发布================'"            
  76.         }
  79.       }
  80.    }
  81. }
  82. }

远程堡垒机发布服务

远程发布服务其实是一个很简单的执行脚本的服务

ShellRequestDTO.java

  1. package com.winterchen.jenkinsauto.dto;
  3. import javax.validation.constraints.NotBlank;
  4. import java.util.List;
  5. import java.util.Map;
  7. public class ShellRequestDTO { 
  9.     @NotBlank
  10.     private String imageName;
  12.     @NotBlank
  13.     private String tag;
  15.     @NotBlank
  16.     private String simpleImageName;
  18.     @NotBlank
  19.     private String port;
  21.     /** * 环境变量列表 */
  22.     private Map<String, String> envs;
  24.     private List<String> volumes;
  26.     public String getImageName() { 
  27.         return imageName;
  28.     }
  30.     public void setImageName(String imageName) { 
  31.         this.imageName = imageName;
  32.     }
  34.     public String getTag() { 
  35.         return tag;
  36.     }
  38.     public void setTag(String tag) { 
  39.         this.tag = tag;
  40.     }
  42.     public String getPort() { 
  43.         return port;
  44.     }
  46.     public void setPort(String port) { 
  47.         this.port = port;
  48.     }
  50.     public String getSimpleImageName() { 
  51.         return simpleImageName;
  52.     }
  54.     public void setSimpleImageName(String simpleImageName) { 
  55.         this.simpleImageName = simpleImageName;
  56.     }
  58.     public Map<String, String> getEnvs() { 
  59.         return envs;
  60.     }
  62.     public void setEnvs(Map<String, String> envs) { 
  63.         this.envs = envs;
  64.     }
  66.     public List<String> getVolumes() { 
  67.         return volumes;
  68.     }
  70.     public void setVolumes(List<String> volumes) { 
  71.         this.volumes = volumes;
  72.     }
  74.     @Override
  75.     public String toString() { 
  76.         final StringBuilder sb = new StringBuilder("ShellRequestDTO{");
  77.         sb.append("imageName='").append(imageName).append('\'');
  78.         sb.append(", tag='").append(tag).append('\'');
  79.         sb.append(", simpleImageName='").append(simpleImageName).append('\'');
  80.         sb.append(", port='").append(port).append('\'');
  81.         sb.append(", envs=").append(envs);
  82.         sb.append(", volumes=").append(volumes);
  83.         sb.append('}');
  84.         return sb.toString();
  85.     }
  86. }

APIResponse.java

  1. package com.winterchen.jenkinsauto.dto;
  4. public class APIRespose<T> { 
  6.     private Integer code;
  8.     private T data;
  10.     private String message;
  12.     private Boolean success;
  15.     public static APIRespose success(){ 
  16.         APIRespose apiRespose = new APIRespose();
  17.         apiRespose.setCode(200);
  18.         apiRespose.setSuccess(true);
  19.         return apiRespose;
  20.     }
  22.     public static APIRespose success(Object data) { 
  23.         APIRespose apiRespose = new APIRespose();
  24.         apiRespose.setCode(200);
  25.         apiRespose.setSuccess(true);
  26.         apiRespose.setData(data);
  27.         return apiRespose;
  28.     }
  30.     public static APIRespose fail(String message) { 
  31.         APIRespose apiRespose = new APIRespose();
  32.         apiRespose.setCode(500);
  33.         apiRespose.setSuccess(false);
  34.         apiRespose.setMessage(message);
  35.         return apiRespose;
  36.     }
  38.    //get,set省略
  39. }

BaseController.java

  1. package com.winterchen.jenkinsauto.controller;
  3. import com.winterchen.jenkinsauto.dto.APIRespose;
  4. import com.winterchen.jenkinsauto.dto.ShellRequestDTO;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.validation.annotation.Validated;
  8. import org.springframework.web.bind.annotation.PostMapping;
  9. import org.springframework.web.bind.annotation.RequestBody;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RestController;
  13. import java.io.BufferedReader;
  14. import java.io.IOException;
  15. import java.io.InputStreamReader;
  16. import java.text.MessageFormat;
  17. import java.util.List;
  18. import java.util.Map;
  20. @RestController
  21. @RequestMapping("/shell")
  22. public class BaseController { 
  24.     private static final Logger LOGGER = LoggerFactory.getLogger(BaseController.class);
  26.     @PostMapping("")
  27.     public APIRespose executeShell(
  28.         @RequestBody
  29.         @Validated
  30.         ShellRequestDTO requestDTO
  31.     ) { 
  32.         LOGGER.info("当前请求参数：" + requestDTO.toString());
  33.         StringBuilder sb = new StringBuilder();
  34.         try { 
  35.             doExecuteShell(requestDTO, sb);
  36.             return APIRespose.success(sb.toString());
  37.         } catch (Exception e) { 
  38.             return APIRespose.fail(e.getMessage());
  39.         }
  40.     }
  42.     private synchronized void doExecuteShell(ShellRequestDTO requestDTO, StringBuilder sb) throws Exception{ 
  43.         //停止旧的容器
  44.         stopContainer(requestDTO.getSimpleImageName(), sb);
  45.         //stopContainerByImageId(requestDTO.getImageName(), sb);
  46.         //删除旧的容器
  47.         removeContainer(requestDTO.getSimpleImageName(), sb);
  48.         //removeContainerByImageId(requestDTO.getImageName(),sb);
  49.         //删除旧的镜像
  50.         removeImage(requestDTO.getImageName(), sb);
  51.         removeNoneImages(sb);
  52.         //拉取最新的镜像
  53.         pullImage(requestDTO.getImageName(), requestDTO.getTag(), sb);
  54.         //运行最新镜像
  55.         runImage(requestDTO, sb);
  56.         /** * TODO 扩展：如果需要等服务可用再返回，可以在服务中增加一个检查接口，循环的调用该接口直至成功返回为止（注意需要有超时机制，如果服务启动失败会一直进入死循环） * TODO 该拓展主要是为了集成测试准备，自动化测试脚本运行的前提是该服务可以正常提供服务 */
  57.     }
  60.     private void pullImage(String imageName, String tag, StringBuilder sb) throws Exception{ 
  61.         execute(MessageFormat.format("docker pull {0}:{1}", imageName, tag), sb);
  62.     }
  64.     private void stopContainer(String simpleImageName, StringBuilder sb) { 
  65.         try { 
  66.             execute("docker stop " + simpleImageName, sb);
  67.         } catch (Exception e) { 
  68.             LOGGER.error("停止容器失败", e);
  69.         }
  70.     }
  74.     private void removeImage(String imageName, StringBuilder sb)  { 
  75.         try { 
  76.             execute("docker rmi -f " + imageName, sb);
  77.         } catch (Exception e) { 
  78.             LOGGER.error("删除镜像失败", e);
  79.         }
  80.     }
  82.     private void removeNoneImages(StringBuilder sb) { 
  83.         try{ 
  84.             execute("docker ps -a | grep `docker images -f 'dangling=true' -q` | awk '{print $1}'", sb);
  85.             execute("docker stop $(docker ps -a | grep `docker images -f 'dangling=true' -q` | awk '{print $1}')", sb);
  86.             execute("docker ps -a | grep `docker images -f 'dangling=true' -q` | awk '{print $1}'",sb);
  87.             execute("docker rm $(docker ps -a | grep `docker images -f 'dangling=true' -q` | awk '{print $1}')", sb);
  88.             execute("docker images -f 'dangling=true'|awk '{print $3}'", sb);
  89.             execute("docker image rm -f `docker images -f 'dangling=true'|awk '{print $3}'`", sb);
  90.         } catch (Exception e) { 
  91.             LOGGER.error("删除none镜像失败", e);
  92.         }
  93.     }
  96.     private void removeContainer(String simpleImageName, StringBuilder sb) { 
  97.         try { 
  98.             execute("docker rm " + simpleImageName, sb);
  99.         } catch (Exception e) { 
  100.             LOGGER.error("删除容器失败", e);
  101.         }
  102.     }
  105.     private void runImage(ShellRequestDTO requestDTO, StringBuilder sb) throws Exception{ 
  106.         StringBuilder shell = new StringBuilder();
  107.         shell.append("docker run -p ").append(requestDTO.getPort()).append(":").append(requestDTO.getPort());
  108.         shell.append(" --network=host ");
  109.         shell.append(" --name=").append(requestDTO.getSimpleImageName());
  110.         shell.append(" -d ");
  111.         formatEnv(requestDTO.getEnvs(), shell);
  112.         formatVolumes(requestDTO.getVolumes(), shell);
  113.         shell.append(requestDTO.getImageName()).append(":").append(requestDTO.getTag());
  114.         execute(shell.toString(), sb);
  115.     }
  117.     private void formatVolumes(List<String> volumes, StringBuilder shell) { 
  118.         if (volumes == null || 0 == volumes.size()) { 
  119.             return;
  120.         }
  121.         volumes.forEach(volume -> { 
  122.             shell.append(" -v ");
  123.             shell.append(" '").append(volume).append("' ");
  124.         });
  125.     }
  127.     private void formatEnv(Map<String, String> env, StringBuilder shell) { 
  128.         if (env == null || env.isEmpty()) { 
  129.             return;
  130.         }
  131.         for (Map.Entry<String, String> entry : env.entrySet()) { 
  132.             shell.append(" -e ");
  133.             shell.append(entry.getKey()).append("='").append(entry.getValue()).append("' ");
  134.         }
  135.     }
  138.     private void execute(String command, StringBuilder sb) throws Exception { 
  139.         BufferedReader infoInput = null;
  140.         BufferedReader errorInput = null;
  141.         try { 
  142.             LOGGER.info("======================当前执行命令======================");
  143.             LOGGER.info(command);
  144.             LOGGER.info("======================当前执行命令======================");
  145.             //执行脚本并等待脚本执行完成
  146.             String[] commands = {  "/bin/sh", "-c", command };
  147.             Process process = Runtime.getRuntime().exec(commands);
  148.             //写出脚本执行中的过程信息
  149.             infoInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
  150.             errorInput = new BufferedReader(new InputStreamReader(process.getErrorStream()));
  151.             String line = "";
  152.             while ((line = infoInput.readLine()) != null) { 
  153.                 sb.append(line).append(System.lineSeparator());
  154.                 LOGGER.info(line);
  155.             }
  156.             while ((line = errorInput.readLine()) != null) { 
  157.                 sb.append(line).append(System.lineSeparator());
  158.                 LOGGER.error(line);
  159.             }
  160.             //阻塞执行线程直至脚本执行完成后返回
  161.             process.waitFor();
  162.         } finally { 
  163.             try { 
  164.                 if (infoInput != null) { 
  165.                     infoInput.close();
  166.                 }
  167.                 if (errorInput != null) { 
  168.                     errorInput.close();
  169.                 }
  170.             } catch (IOException e) { 
  172.             }
  173.         }
  174.     }
  175. }

相关资源

  • docker rest api 官方文档
  • jenkins 官方文档
  • docker 官方文档

微信公众号：CodeD
微信公众号

发表评论

表情：
评论列表 （有 0 条评论，122人围观）

还没有评论，来说两句吧...

相关阅读