第一章：DevOps 概念

1.1 DevOps 是什么？

  • DevOps 是 Development 和 Operations 的组合。

1.png

  • DevOps 可以看作是开发（软件工程）、技术运营和质量保障（QA）的交集。

2.png

  • DevOps 突出重视软件开发人员和运维人员的沟通合作，通过自动化流程来使得软件构建、测试、发布更加快捷、频繁和可靠。
  • DevOps 希望做到的是软件产品交付过程中 IT 工具链的打通，使得各个团队减少时间损耗，更加高效的协同工作。

1.2 CI 、CD 是什么？

1.2.1 基本理念

3.png

  • 持续集成（Continuous Integration）：持续集成是指软件个人研发的部分向软件整体部分交付，频繁进行集成以便更快、更早的发现其中的错误。持续集成源自于极限编程（XP），是 XP 最初的 12 种实践之一。持续集成需要具备：
    • ① 全面的自动化测试：这是实践持续集成 && 持续部署的基础，与此同时，选择合适的自动化测试工具也极为重要。
    • ② 灵活的基础设施：容器、虚拟机 的存在让开发人员和 QA 人员不必再大费周折。
    • ③ 版本工具工具：如 Git、SVN 等。
    • ④ 自动化的构建和软件发布流程工具：如 Jenkins 等。
    • ⑤ 反馈机制：构建、测试失败的时候，可以快速的反馈到相关负责人，以便尽快的解决问题，使得产品能更早的达到稳定的版本。
  • 持续交付（Continuous Delivery）：持续交付在持续集成的基础上，将集成后的代码部署到更贴近真实运行环境的『类生成环境』中。持续交付优先于整个产品生命周期的软件部署，建立在高水平自动化持续集成之上。持续交付的优点和持续集成非常类似：
    • ① 快速发布：能够应对业务需求，更快的实现软件价值。
    • ② 编码、测试、上线、交付的频繁迭代周期缩短，同时获得迅速反馈。
    • ③ 高质量的软件发布标准：整个交付过程标准化、可重复、可靠。
    • ④ 整个交付过程进度可视化：方便团队人员了解项目成熟度。
    • ⑤ 更先进的团队协作方式：从需求分析、产品的用户体验到交互设计、开发、测试、运维等角色的密切协作，相比于传统的瀑布式软件团队，更少浪费。
  • 持续部署（Continuous Deployment）：持续部署是指当交付的代码通过评审之后，自动部署到生产环境中。持续部署是持续交付的最高阶段。这意味着，所有通过了一系列的自动化测试的改动都将自动部署到生产环境。

开发人员提交代码，持续集成服务器获取代码，执行单元测试，根据测试结果决定是否部署到预演环境，如果成功部署到预演环境，进行整体验收测试，如果测试通过，自动部署到生产环境。整个过程自动化高效运转。

1.2.2 最佳实践

1.2.2.1 内循环和外循环

4.png

  • 内循环（开发）：编码、测试、运行、debug、提交。
  • 代码推送到代码仓库（Git、SVN）。
  • 进行 CI 流程（持续集成）：万物皆可容器化，所有应用打包成 Docker 镜像（符合 OCI 镜像规范即可）。
  • 镜像推送到镜像仓库。
  • 测试。
  • 进行 CD 流程（持续部署）：将应用部署到环境（测试、预发布、生产……）。
  • 外循环：
    • 运行时监控。
    • 生产环境的管理。
    • 监控。
    • 线上反馈到开发。
  • 来到内循环。

1.2.2.2 实践流程

5.png

  • ① 创建分支开发功能。
  • ② 提交分支的代码。
  • ③ 进入持续集成流程：
    • 当前分支代码功能性自动化构建和测试。
    • 自动化工具推送这次提交。
    • 自动化集成测试。
    • 人工确认此次功能是否发布到生产环境。
  • ④ 代码合并。
  • ⑤ 进入持续部署流程：
    • 构建。
    • 测试。
    • 发布。
    • ……

第二章：Jenkins

2.1 Jenkis 简介

  • Jenkins 是开源 CI&CD 软件领导者， 提供超过 1000 个插件来支持构建、部署、自动化， 满足任何项目的需要。

6.png

2.2 准备工作

  • 需要准备一个云服务器（阿里云、腾讯云、青云等），因为没有使用自建 gitlab 的形式来演示，而是使用 gitee 。

2.3 Docker 安装 Jenkins

  • 命令：
  1. # 端口是 8080
  2. docker run      \
  3.        -u root  \
  4.        --name=jenkins  \
  5.        -d \
  6.        -p 8080:8080 \
  7.        -p 50000:50000 \
  8.        -v jenkins-data:/var/jenkins_home \
  9.        -v /etc/localtime:/etc/localtime:ro \
  10.        -v /var/run/docker.sock:/var/run/docker.sock \
  11.        --restart=always \
  12.        jenkinsci/blueocean

7.gif

  • 初始密码在日志文件中可以找到，本次是 b219e31bceac42b6a1c7ab4fde14cf97 ，当然，也可以通过具名卷查找。

8.gif

  • 浏览器访问（端口是 8080）：

9.png

10.png

11.png

12.png

13.png

14.png

2.5 安装插件（必须）

  • Docker、Docker Pipeline：安装 Docker Pipeline 会自动安装 Docker 插件，Docker Pipeline 插件允许我们自定义 agent 使用 Docker 环境。
  • Git Parameter：解析 git 参数，允许我们选择分支进行构建。
  • Active Choices：可以做到参数的级联选择。
  • Generic Webhook Trigger：通用的 webhook 触发器，构建更强大的 webhook 功能。
  • Role-based Authorization Strategy：RBAC 权限控制。
  • List Git Branches Parameter：列出分支参数。
  • Build With Parameters：基于自定义参数构建。
  • Jersey 2 API、Gitee：Gitee 插件。

15.png

16.png

17.png

2.4 准备一个 git 项目进行测试

  • 以 gitee 为例，因为 github 实现是太慢了。
  • 步骤：
    • ① IDEA 创建 SpringBoot 项目。
    • ② VCS — 创建 git 仓库。
    • ③ gitee 创建一个空的公共仓库（略）。
    • ④ IDEA 提交内容到 gitee 。
    • ⑤ 开发项目基本功能，并在项目中创建一个名为 Jenkinsfile 的文件。
    • ⑥ 创建一个名为 devops-java-demo 的流水线项目，使用该项目自己的流水线。

18.png

2.5 Jenkis 关联 Gitee

2.5.1 Gitee 申请 Gitee API V5 的私人令牌

19.png

20.png

2.5.2 Jenkins 配置 Gitee API 令牌

21.png

22.png

23.png

24.png

25.png

26.png

2.5.3 Jenkins 关联 Gitee

27.png

28.png

2.6 Jenkis 新建 Pipeline（流水线）项目

29.png

30.png

31.png

Gitee webhook 中填写 http://139.198.179.119:8080/gitee-project/devops-java-demo。

32.png

33.png

34.png

  • 根据提示，在 gitee 项目中配置 webhook ：

35.png

2.7 在项目中新建配置文件

  • 配置文件：
    • Dockerfile：用来构建 Docker 镜像。
    • settings.xml：用来加速 Maven 依赖的构建。
    • Jenkinsfile：定义了 Jenkins 流水线。

36.png

  • 其中，Dockerfile 的内容如下：
  1. FROM java:8
  2. LABEL maintainer="xxxx@qq.com"
  3. COPY target/*.jar /app.jar
  4. RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone && touch /app.jar
  5. # 环境变量
  6. # docker run -e JAVA_OPTS="-Xmx512m -Xms64m" -e PARAMS="--spring.profiles.active=dev --server.port=8080" xxx
  7. ENV JAVA_OPTS=""
  8. ENV PARAMS=""
  9. # 运行 jar 包
  10. ENTRYPOINT [ "sh", "-c", "java -Djava.security.egd=file:/dev/./urandom $JAVA_OPTS -jar /app.jar $PARAMS" ]
  • settings.xml 的内容如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <!--
  4. Licensed to the Apache Software Foundation (ASF) under one
  5. or more contributor license agreements.  See the NOTICE file
  6. distributed with this work for additional information
  7. regarding copyright ownership.  The ASF licenses this file
  8. to you under the Apache License, Version 2.0 (the
  9. "License"); you may not use this file except in compliance
  10. with the License.  You may obtain a copy of the License at
  12.     http://www.apache.org/licenses/LICENSE-2.0
  14. Unless required by applicable law or agreed to in writing,
  15. software distributed under the License is distributed on an
  16. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17. KIND, either express or implied.  See the License for the
  18. specific language governing permissions and limitations
  19. under the License.
  20. -->
  22. <!--
  23.  | This is the configuration file for Maven. It can be specified at two levels:
  24.  |
  25.  |  1. User Level. This settings.xml file provides configuration for a single user,
  26.  |                 and is normally provided in ${user.home}/.m2/settings.xml.
  27.  |
  28.  |                 NOTE: This location can be overridden with the CLI option:
  29.  |
  30.  |                 -s /path/to/user/settings.xml
  31.  |
  32.  |  2. Global Level. This settings.xml file provides configuration for all Maven
  33.  |                 users on a machine (assuming they're all using the same Maven
  34.  |                 installation). It's normally provided in
  35.  |                 ${maven.conf}/settings.xml.
  36.  |
  37.  |                 NOTE: This location can be overridden with the CLI option:
  38.  |
  39.  |                 -gs /path/to/global/settings.xml
  40.  |
  41.  | The sections in this sample file are intended to give you a running start at
  42.  | getting the most out of your Maven installation. Where appropriate, the default
  43.  | values (values used when the setting is not specified) are provided.
  44.  |
  45.  |-->
  46. <settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
  47.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  48.           xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
  50.   <!-- 先这么配置，后面再详解 -->
  51.   <localRepository>/root/.m2</localRepository>
  53.   <pluginGroups>
  55.   </pluginGroups>
  58.   <proxies>
  60.   </proxies>
  62.   <servers>
  64.   </servers>
  66.   <mirrors>
  68.      <mirror>
  69.       <id>aliyunmaven</id>
  70.       <mirrorOf>*</mirrorOf>
  71.       <name>阿里云公共仓库</name>
  72.       <url>https://maven.aliyun.com/repository/public</url>
  73.     </mirror>
  74.   </mirrors>
  76.   <profiles>
  78.   </profiles>
  80. </settings>
  • Jenkinsfile 的文件的基本格式如下：
  1. pipeline {
  2.     agent any
  3.     environment {
  4.         CC = 'clang'
  5.     }
  6.     stages {
  7.         stage('Example') {
  8.             steps { 
  9.                 sh 'printenv'
  10.                 sh 'echo $CC'
  11.             }
  12.         }
  13.     }
  14. }

2.8 如何编写 Jenkinsfile 文件

2.8.1 Pipeline 语法概述

  • 官网地址。
  • 目前，都是推荐声明式流水线的写法，Jenkins 的 Pipeline 就是基于 Groovy 的，不过非常简单。

37.png

2.8.2 stages

  • stages：定义了流水线的阶段，如：Maven 项目中 clean 、test、package、install 等阶段，在 Jenkins 中称为阶段。

  • 示例： 

  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        // 需要注意的时候，这里不允许为空，其实 Jenkins 的每个步骤都不允许为空，如果此时没有需要定义的环境信息，那么就将 environment 删除即可，下面的 steps 类似
  11.        PROJECT_WS = "${WORKSPACE}"
  12.     }
  14.     // 定义流水线的加工流程
  15.     stages { // 流水线的阶段
  16.         // 环境检查
  17.         stage('环境检查') {
  18.             steps { // 步骤：要做的所有事情
  19.                 echo "环境检查..."
  20.                 sh 'printenv' // 打印环境变量
  21.                 echo "正在检测基本信息"
  22.                 sh 'java -version'
  23.                 sh 'git --version'
  24.                 sh 'docker version'
  25.                 sh 'pwd && ls -lah'
  26.             }
  27.         }
  28.         // 编译
  29.         stage('Maven 编译') {
  30.             steps { // 步骤：要做的所有事情
  31.                 echo "编译..."
  32.                 sh 'pwd && ls -lah'
  33.             }
  34.         }
  35.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  36.         stage('单元测试') { // 步骤
  37.             steps {
  38.                echo "单元测试..."
  39.                sh 'pwd && ls -lah'
  40.             }
  41.         }
  42.         // 生成镜像
  43.         stage('生成镜像') {
  44.             steps { // 步骤
  45.                 echo "生成镜像..."
  46.             }
  47.         }
  48.         // 推送镜像
  49.         stage('推送镜像') {
  50.             steps { // 步骤
  51.                 echo "推送镜像..."
  52.             }
  53.         }
  54.         // 部署
  55.         stage('部署') {
  56.             steps { // 步骤
  57.                 echo "部署..."
  59.             }
  60.         }
  62.     }
  64.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  65.         always { // 总是执行，比如：发送构建报告等。
  66.             echo "后置执行 ---> always..."
  67.         }
  68.         failure { // 错误的时候执行
  69.            echo "后置执行 ---> 失败..."
  70.         }
  71.         success { // 成功的时候执行
  72.            echo "后置执行 ---> 成功..."
  73.         }
  74.     }
  77. }

38.png

  • 坑：此时你会发现，好像还是有权限问题，那么因为 Jenkins 的安全设置。

39.png

40.png

2.8.3 Java 项目需要进行编译，那么应该怎么办？

  • 在流水线中使用 Docker （坑：如果不装 Docker Pipeline 插件，那么一定会出错）：

41.png

  • 示例：
  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        // 需要注意的时候，这里不允许为空，其实 Jenkins 的每个步骤都不允许为空，如果此时没有需要定义的环境信息，那么就将 environment 删除即可，下面的 steps 类似
  11.        PROJECT_WS = "${WORKSPACE}"
  12.     }
  14.     // 定义流水线的加工流程
  15.     stages { // 流水线的阶段
  16.         // 环境检查
  17.         stage('环境检查') {
  18.             steps { // 步骤：要做的所有事情
  19.                 echo "环境检查..."
  20.                 sh 'printenv' // 打印环境变量
  21.                 echo "正在检测基本信息"
  22.                 sh 'java -version'
  23.                 sh 'git --version'
  24.                 sh 'docker version'
  25.                 sh 'pwd && ls -lah'
  26.             }
  27.         }
  28.         // 编译
  29.         stage('Maven 编译') {
  30.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  31.             agent {
  32.                 docker {
  33.                    image 'maven:3.6.0-alpine'
  34.                 }
  35.             }
  36.             steps { // 步骤：要做的所有事情
  37.                 echo "编译..."
  38.                 sh 'pwd && ls -lah'
  39.                 sh "mvn clean package -Dmaven.test.skip=true"
  40.                 sh 'pwd && ls -lah'
  41.             }
  42.         }
  43.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  44.         stage('单元测试') { // 步骤
  45.             steps {
  46.                echo "单元测试..."
  47.                sh 'pwd && ls -lah'
  48.             }
  49.         }
  50.         // 生成镜像
  51.         stage('生成镜像') {
  52.             steps { // 步骤
  53.                 echo "生成镜像..."
  54.             }
  55.         }
  56.         // 推送镜像
  57.         stage('推送镜像') {
  58.             steps { // 步骤
  59.                 echo "推送镜像..."
  60.             }
  61.         }
  62.         // 部署
  63.         stage('部署') {
  64.             steps { // 步骤
  65.                 echo "部署..."
  67.             }
  68.         }
  70.     }
  72.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  73.         always { // 总是执行，比如：发送构建报告等。
  74.             echo "后置执行 ---> always..."
  75.         }
  76.         failure { // 错误的时候执行
  77.            echo "后置执行 ---> 失败..."
  78.         }
  79.         success { // 成功的时候执行
  80.            echo "后置执行 ---> 成功..."
  81.         }
  82.     }
  83. }

42.png

  • 但是，如果你多构建几次，你就会发现老是从阿里云镜像（Maven 的 pom.xml 中我配置了阿里云镜像）中拉取 jar 包，真烦？第一次从阿里云拉取就算了，第二次应该直接使用本地的，怎么办？

43.png

  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        PROJECT_WS = "${WORKSPACE}"
  11.     }
  13.     // 定义流水线的加工流程
  14.     stages { // 流水线的阶段
  15.         // 环境检查
  16.         stage('环境检查') {
  17.             steps { // 步骤：要做的所有事情
  18.                 echo "环境检查..."
  19.                 sh 'printenv' // 打印环境变量
  20.                 echo "正在检测基本信息"
  21.                 sh 'java -version'
  22.                 sh 'git --version'
  23.                 sh 'docker version'
  24.                 sh 'pwd && ls -lah'
  25.             }
  26.         }
  27.         // 编译
  28.         stage('Maven 编译') {
  29.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  30.             agent {
  31.                 docker {
  32.                    image 'maven:3.6.0-alpine'
  33.                    args '-v $HOME/.m2:/root/.m2' // 将 Maven 下载的依赖挂载到主机，用于解决 Maven 下一次还需要重新下载的问题。
  34.                 }
  35.             }
  36.             steps { // 步骤：要做的所有事情
  37.                 echo "编译..."
  38.                 sh 'pwd && ls -lah'
  39.                 script {
  40.                     if (!fileExists("/var/jenkins_home/workspace/appconfig/maven/settings.xml")){
  41.                         sh "mkdir -pv /var/jenkins_home/workspace/appconfig/maven/"
  42.                         sh "cp appconfig/maven/settings.xml /var/jenkins_home/workspace/appconfig/maven/settings.xml"
  43.                     }
  44.                 }
  45.                 sh "mvn clean package -s /var/jenkins_home/workspace/appconfig/maven/settings.xml  -Dmaven.test.skip=true"
  46.                 sh 'pwd && ls -lah'
  47.             }
  48.         }
  49.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  50.         stage('单元测试') { // 步骤
  51.             steps {
  52.                echo "单元测试..."
  53.                sh 'pwd && ls -lah'
  54.             }
  55.         }
  56.         // 生成镜像
  57.         stage('生成镜像') {
  58.             steps { // 步骤
  59.                 echo "生成镜像..."
  60.             }
  61.         }
  62.         // 推送镜像
  63.         stage('推送镜像') {
  64.             steps { // 步骤
  65.                 echo "推送镜像..."
  66.             }
  67.         }
  68.         // 部署
  69.         stage('部署') {
  70.             steps { // 步骤
  71.                 echo "部署..."
  73.             }
  74.         }
  75.     }
  77.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  78.         always { // 总是执行，比如：发送构建报告等。
  79.             echo "后置执行 ---> always..."
  80.         }
  81.         failure { // 错误的时候执行
  82.            echo "后置执行 ---> 失败..."
  83.         }
  84.         success { // 成功的时候执行
  85.            echo "后置执行 ---> 成功..."
  86.         }
  87.     }
  88. }

2.8.4 生成镜像

  • 直接在生成镜像的阶段中，使用 docker build 命令构建镜像即可，但是有坑，因为 Jenkins 在每一个阶段都是在临时容器中进行操作的， 当我们在 Maven 编译 阶段中将源码打包之后，形成的 target 目录，到了下一个阶段并不会复制进去，那么怎么办？在 Maven 编译 阶段中就在 /var/jenkins_home/workspace/项目/ 中对源码进行编译，这个目录的地址 Jenkins 已经给出了，就是 WORKSPACE 环境变量。

  • 示例： 

  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        PROJECT_WS = "${WORKSPACE}"
  11.     }
  13.     // 定义流水线的加工流程
  14.     stages { // 流水线的阶段
  15.         // 环境检查
  16.         stage('环境检查') {
  17.             steps { // 步骤：要做的所有事情
  18.                 echo "环境检查..."
  19.                 sh 'printenv' // 打印环境变量
  20.                 echo "正在检测基本信息"
  21.                 sh 'java -version'
  22.                 sh 'git --version'
  23.                 sh 'docker version'
  24.                 sh 'pwd && ls -lah'
  25.             }
  26.         }
  27.         // 编译
  28.         stage('Maven 编译') {
  29.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  30.             agent {
  31.                 docker {
  32.                    image 'maven:3.6.0-alpine'
  33.                    args '-v $HOME/.m2:/root/.m2' // 将 Maven 下载的依赖挂载到主机，用于解决 Maven 下一次还需要重新下载的问题。
  34.                 }
  35.             }
  36.             steps { // 步骤：要做的所有事情
  37.                 echo "编译..."
  38.                 sh 'pwd && ls -lah'
  39.                 script {
  40.                     if (!fileExists("/var/jenkins_home/workspace/appconfig/maven/settings.xml")){
  41.                         sh "mkdir -pv /var/jenkins_home/workspace/appconfig/maven/"
  42.                         sh "cp appconfig/maven/settings.xml /var/jenkins_home/workspace/appconfig/maven/settings.xml"
  43.                     }
  44.                 }
  45.                 // 之所以 cd ${PROJECT_WS} 是因为在构建是在临时容器中生成的，一旦构建完成之后容器将会销毁，而 target 目录也将丢失。
  46.                 sh "cd ${PROJECT_WS} && mvn clean package -s /var/jenkins_home/workspace/appconfig/maven/settings.xml  -Dmaven.test.skip=true"
  47.                 sh 'pwd && ls -lah'
  48.             }
  49.         }
  50.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  51.         stage('单元测试') { // 步骤
  52.             steps {
  53.                echo "单元测试..."
  54.                sh 'pwd && ls -lah'
  55.             }
  56.         }
  57.         // 生成镜像
  58.         stage('生成镜像') {
  59.             steps { // 步骤
  60.                 echo "生成镜像..."
  61.                 // 检查 Jenkins 的 Docker 命令是否能执行
  62.                 sh 'docker version'
  63.                 sh 'docker build -t devops-java-demo .'
  64.             }
  65.         }
  66.         // 推送镜像
  67.         stage('推送镜像') {
  68.             steps { // 步骤
  69.                 echo "推送镜像..."
  70.             }
  71.         }
  72.         // 部署
  73.         stage('部署') {
  74.             steps { // 步骤
  75.                 echo "部署..."
  77.             }
  78.         }
  80.     }
  82.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  83.         always { // 总是执行，比如：发送构建报告等。
  84.             echo "后置执行 ---> always..."
  85.         }
  86.         failure { // 错误的时候执行
  87.            echo "后置执行 ---> 失败..."
  88.         }
  89.         success { // 成功的时候执行
  90.            echo "后置执行 ---> 成功..."
  91.         }
  92.     }
  93. }

2.8.5 推送镜像

  • 在推送镜像的阶段中，我们可以询问开发者是否确认将镜像推送到阿里云镜像仓库中，以及将镜像推送到那个区域（当然，实际中一般就一个镜像仓库，而且也不会存放到阿里云镜像仓库（需要将仓库的用户名和密码配置到 Jenkins 中，不再演示）中，会搭建自己的私有仓库，如：Harbor 等），可以使用 input 来实现这类功能。

  • 示例： 

  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        PROJECT_WS = "${WORKSPACE}"
  11.     }
  13.     // 定义流水线的加工流程
  14.     stages { // 流水线的阶段
  15.         // 环境检查
  16.         stage('环境检查') {
  17.             steps { // 步骤：要做的所有事情
  18.                 echo "环境检查..."
  19.                 sh 'printenv' // 打印环境变量
  20.                 echo "正在检测基本信息"
  21.                 sh 'java -version'
  22.                 sh 'git --version'
  23.                 sh 'docker version'
  24.                 sh 'pwd && ls -lah'
  25.             }
  26.         }
  27.         // 编译
  28.         stage('Maven 编译') {
  29.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  30.             agent {
  31.                 docker {
  32.                    image 'maven:3.6.0-alpine'
  33.                    args '-v $HOME/.m2:/root/.m2' // 将 Maven 下载的依赖挂载到主机，用于解决 Maven 下一次还需要重新下载的问题。
  34.                 }
  35.             }
  36.             steps { // 步骤：要做的所有事情
  37.                 echo "编译..."
  38.                 sh 'pwd && ls -lah'
  39.                 script {
  40.                     if (!fileExists("/var/jenkins_home/workspace/appconfig/maven/settings.xml")){
  41.                         sh "mkdir -pv /var/jenkins_home/workspace/appconfig/maven/"
  42.                         sh "cp appconfig/maven/settings.xml /var/jenkins_home/workspace/appconfig/maven/settings.xml"
  43.                     }
  44.                 }
  45.                 // 之所以 cd ${PROJECT_WS} 是因为在构建是在临时容器中生成的，一旦构建完成之后容器将会销毁，而 target 目录也将丢失。
  46.                 sh "cd ${PROJECT_WS} && mvn clean package -s /var/jenkins_home/workspace/appconfig/maven/settings.xml  -Dmaven.test.skip=true"
  47.                 sh 'pwd && ls -lah'
  48.             }
  49.         }
  50.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  51.         stage('单元测试') { // 步骤
  52.             steps {
  53.                echo "单元测试..."
  54.                sh 'pwd && ls -lah'
  55.             }
  56.         }
  57.         // 生成镜像
  58.         stage('生成镜像') {
  59.             steps { // 步骤
  60.                 echo "生成镜像..."
  61.                 // 检查 Jenkins 的 Docker 命令是否能执行
  62.                 sh 'docker version'
  63.                 sh 'docker build -t devops-java-demo .'
  64.             }
  65.         }
  66.         // 推送镜像
  67.         stage('推送镜像') {
  68.              input {
  69.                 message "需要推送镜像到阿里云仓库吗？"
  70.                 ok "是的"
  71.                 parameters {
  72.                     // 手动输入的参数
  73.                     string(name: 'APP_VERSION', defaultValue: 'v1', description: '请指定生产版本号')
  74.                     choice choices: ['bj-01','bj-02','sh-03','js-05'], description: '部署的区域', name: 'DEPLOY_AREA'
  75.                 }
  76.             }
  77.             steps { // 步骤
  78.                 echo "推送镜像..."
  79.                 // 将镜像推送到阿里云仓库中
  80.                 script {
  81.                     def area = "${DEPLOY_AREA}"
  82.                     if (area.contains('sh')) {
  83.                         echo '推送镜像到到上海区'
  84.                         withCredentials([usernamePassword(credentialsId: 'aliyun-docker', passwordVariable: 'PWD', usernameVariable: 'USER')]) {
  85.                             sh "docker login --username=${USER} --password=${PWD} registry.cn-shanghai.aliyuncs.com"
  86.                             sh "docker tag devops-java-demo registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  87.                             sh "docker push registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  88.                         }
  89.                     } else if (area.contains('bj')) {
  90.                         echo '推送镜像到北京区'
  91.                     } else if (area.contains('js')) {
  92.                         echo '推送镜像到江苏区'
  93.                     } else {
  94.                         echo '抱歉，暂无此区域。'
  95.                     }
  96.                 }
  97.             }
  98.         }
  99.         // 部署
  100.         stage('部署') {
  101.             steps { // 步骤
  102.                 echo "部署..."
  104.             }
  105.         }
  107.     }
  109.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  110.         always { // 总是执行，比如：发送构建报告等。
  111.             echo "后置执行 ---> always..."
  112.         }
  113.         failure { // 错误的时候执行
  114.            echo "后置执行 ---> 失败..."
  115.         }
  116.         success { // 成功的时候执行
  117.            echo "后置执行 ---> 成功..."
  118.         }
  119.     }
  120. }

2.8.6 启动容器

  • 在实际开发中，将镜像推送到私有仓库中之后，就从私有仓库中将镜像拉取到指定的机器中，进行部署，你会觉得多此一举，其实未必？

44.png

  • 当然，本次就不这么麻烦，直接在一台机器上执行这些操作。

  • 示例： 

  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.        PROJECT_WS = "${WORKSPACE}"
  11.     }
  13.     // 定义流水线的加工流程
  14.     stages { // 流水线的阶段
  15.         // 环境检查
  16.         stage('环境检查') {
  17.             steps { // 步骤：要做的所有事情
  18.                 echo "环境检查..."
  19.                 sh 'printenv' // 打印环境变量
  20.                 echo "正在检测基本信息"
  21.                 sh 'java -version'
  22.                 sh 'git --version'
  23.                 sh 'docker version'
  24.                 sh 'pwd && ls -lah'
  25.             }
  26.         }
  27.         // 编译
  28.         stage('Maven 编译') {
  29.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  30.             agent {
  31.                 docker {
  32.                    image 'maven:3.6.0-alpine'
  33.                    args '-v $HOME/.m2:/root/.m2' // 将 Maven 下载的依赖挂载到主机，用于解决 Maven 下一次还需要重新下载的问题。
  34.                 }
  35.             }
  36.             steps { // 步骤：要做的所有事情
  37.                 echo "编译..."
  38.                 sh 'pwd && ls -lah'
  39.                 script {
  40.                     if (!fileExists("/var/jenkins_home/workspace/appconfig/maven/settings.xml")){
  41.                         sh "mkdir -pv /var/jenkins_home/workspace/appconfig/maven/"
  42.                         sh "cp appconfig/maven/settings.xml /var/jenkins_home/workspace/appconfig/maven/settings.xml"
  43.                     }
  44.                 }
  45.                 // 之所以 cd ${PROJECT_WS} 是因为在构建是在临时容器中生成的，一旦构建完成之后容器将会销毁，而 target 目录也将丢失。
  46.                 sh "cd ${PROJECT_WS} && mvn clean package -s /var/jenkins_home/workspace/appconfig/maven/settings.xml  -Dmaven.test.skip=true"
  47.                 sh 'pwd && ls -lah'
  48.             }
  49.         }
  50.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  51.         stage('单元测试') { // 步骤
  52.             steps {
  53.                echo "单元测试..."
  54.                sh 'pwd && ls -lah'
  55.             }
  56.         }
  57.         // 生成镜像
  58.         stage('生成镜像') {
  59.             steps { // 步骤
  60.                 echo "生成镜像..."
  61.                 // 检查 Jenkins 的 Docker 命令是否能执行
  62.                 sh 'docker version'
  63.                 sh 'docker build -t devops-java-demo .'
  64.             }
  65.         }
  66.         // 推送镜像
  67.         stage('推送镜像') {
  68.              input {
  69.                 message "需要推送镜像到阿里云仓库吗？"
  70.                 ok "是的"
  71.                 parameters {
  72.                     // 手动输入的参数
  73.                     string(name: 'APP_VERSION', defaultValue: 'v1', description: '请指定生产版本号')
  74.                     choice choices: ['bj-01','bj-02','sh-03','js-05'], description: '部署的区域', name: 'DEPLOY_AREA'
  75.                 }
  76.             }
  77.             steps { // 步骤
  78.                 echo "推送镜像..."
  79.                 // 将镜像推送到阿里云仓库中
  80.                 script {
  81.                     def area = "${DEPLOY_AREA}"
  82.                     if (area.contains('sh')) {
  83.                         echo '推送镜像到到上海区'
  84.                         withCredentials([usernamePassword(credentialsId: 'aliyun-docker', passwordVariable: 'PWD', usernameVariable: 'USER')]) {
  85.                             sh "docker login --username=${USER} --password=${PWD} registry.cn-shanghai.aliyuncs.com"
  86.                             sh "docker tag devops-java-demo registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  87.                             sh "docker push registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  88.                         }
  89.                     } else if (area.contains('bj')) {
  90.                         echo '推送镜像到北京区'
  91.                     } else if (area.contains('js')) {
  92.                         echo '推送镜像到江苏区'
  93.                     } else {
  94.                         echo '抱歉，暂无此区域。'
  95.                     }
  96.                 }
  97.             }
  98.         }
  99.         // 启动容器
  100.         stage('启动容器') {
  101.             steps { // 步骤
  102.                 echo "启动容器..."
  103.                 sh 'docker rm -f devops-java-demo'
  104.                 sh 'docker run -d -p 8888:8080 --name=devops-java-demo devops-java-demo'
  105.             }
  106. //             post { // 后置执行
  107. //               failure {
  108. //                  echo "启动容器失败..."
  109. //               }
  110. //               success {
  111. //                  echo "启动容器成功..."
  112. //               }
  113. //             }
  114.         }
  116.     }
  118.     post { // 后置执行，上面的阶段都执行完毕之后，就会执行此过程
  119.         always { // 总是执行，比如：发送构建报告等。
  120.             echo "后置执行 ---> always..."
  121.         }
  122.         failure { // 错误的时候执行
  123.            echo "后置执行 ---> 失败..."
  124.         }
  125.         success { // 成功的时候执行
  126.            echo "后置执行 ---> 成功..."
  127.         }
  128.     }
  129. }

2.8.7 构建报告

  • 构建报告，一般都需要通过 email 发送给开发人员，需要在 Jenkins 中配置 email 。
  • ① 在 Jenkis 中配置 email 的 凭证信息：

45.png

46.png

47.png

48.png

49.png

50.png

  • ② 在 Jenkins 中配置 QQ 邮箱：

51.png

52.png

53.png

54.png

  • ③ 在 Jenkinsfile 中设置推送报告阶段。
  1. // 流水线的脚本（声明式和脚本式，常用的是声明式）
  2. pipeline {
  3.     // 全部的 CI、CD 流程都需要在这里定义
  5.     // 任何一个代理可用，就能执行（多机器）。但是，目前是单机，所以只会在本地执行。固定写法。
  6.     agent any
  8.     // 定义一些环境信息
  9.     environment {
  10.       PROJECT_WS = "${WORKSPACE}"
  11.       // 引用 Jenkins 配置的全局凭证信息
  12.       ALIYUN_DOCKER_SECURITY = credentials('aliyun-docker')
  13.     }
  15.     // 定义流水线的加工流程
  16.     stages { // 流水线的阶段
  17.         // 环境检查
  18.         stage('环境检查') {
  19.             steps { // 步骤：要做的所有事情
  20.                 echo "环境检查..."
  21.                 sh 'printenv' // 打印环境变量
  22.                 echo "正在检测基本信息"
  23.                 sh 'java -version'
  24.                 sh 'git --version'
  25.                 sh 'docker version'
  26.                 sh 'pwd && ls -lah'
  27.             }
  28.         }
  29.         // 编译
  30.         stage('Maven 编译') {
  31.             // Jenkins 不配置任何环境的情况下，仅使用 Docker 兼容所有场景
  32.             agent {
  33.                 docker {
  34.                    image 'maven:3.6.0-alpine'
  35.                    args '-v $HOME/.m2:/root/.m2' // 将 Maven 下载的依赖挂载到主机，用于解决 Maven 下一次还需要重新下载的问题。
  36.                 }
  37.             }
  38.             steps { // 步骤：要做的所有事情
  39.                 echo "编译..."
  40.                 sh 'mvn -v'
  41.                 sh 'pwd && ls -lah'
  42.                 script {
  43.                     if (!fileExists("/var/jenkins_home/workspace/appconfig/maven/settings.xml")){
  44.                         sh "mkdir -pv /var/jenkins_home/workspace/appconfig/maven/"
  45.                         sh "cp appconfig/maven/settings.xml /var/jenkins_home/workspace/appconfig/maven/settings.xml"
  46.                     }
  47.                 }
  48.                 sh "cd ${PROJECT_WS} && mvn clean package -s /var/jenkins_home/workspace/appconfig/maven/settings.xml  -Dmaven.test.skip=true"
  49.                 sh 'pwd && ls -lah'
  50.             }
  51.         }
  52.         // 测试，每一个 stage 的开始，都会重置到默认的 workspace 的位置。
  53.         stage('单元测试') { // 步骤
  54.             steps {
  55.                echo "单元测试..."
  56.                sh 'pwd && ls -lah'
  57.             }
  58.         }
  59.         // 生成镜像
  60.         stage('生成镜像') {
  61.             steps { // 步骤
  62.                 echo "生成镜像..."
  63.                 // 检查 Jenkins 的 Docker 命令是否能执行
  64.                 sh 'docker version'
  65.                 sh 'docker build -t devops-java-demo .'
  66.             }
  67.         }
  68.         // 推送镜像
  69.         stage('推送镜像') {
  70.              input {
  71.                 message "需要推送镜像到阿里云仓库吗？"
  72.                 ok "是的"
  73.                 parameters {
  74.                     // 手动输入的参数
  75.                     string(name: 'APP_VERSION', defaultValue: 'v1', description: '请指定生产版本号')
  76.                     choice choices: ['bj-01','bj-02','sh-03','js-05'], description: '部署的区域', name: 'DEPLOY_AREA'
  77.                 }
  78.             }
  79.             steps { // 步骤
  80.                 echo "推送镜像..."
  81.                 // 将镜像推送到阿里云仓库中
  82.                 script {
  83.                     def area = "${DEPLOY_AREA}"
  84.                     if (area.contains('sh')) {
  85.                         echo '推送镜像到到上海区'
  86.                         withCredentials([usernamePassword(credentialsId: 'aliyun-docker', passwordVariable: 'PWD', usernameVariable: 'USER')]) {
  87.                             sh "docker login --username=${USER} --password=${PWD} registry.cn-shanghai.aliyuncs.com"
  88.                             sh "docker tag devops-java-demo registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  89.                             sh "docker push registry.cn-shanghai.aliyuncs.com/xudaxian/devops-java-demo:${APP_VERSION}"
  90.                         }
  91.                     } else if (area.contains('bj')) {
  92.                         echo '推送镜像到北京区'
  93.                     } else if (area.contains('js')) {
  94.                         echo '推送镜像到江苏区'
  95.                     } else {
  96.                         echo '抱歉，暂无此区域。'
  97.                     }
  98.                 }
  99.             }
  100.         }
  101.         // 启动容器
  102.         stage('启动容器') {
  103.             steps { // 步骤
  104.                 echo "启动容器..."
  105.                 sh 'docker rm -f devops-java-demo'
  106.                 sh 'docker run -d -p 8888:8080 --name=devops-java-demo devops-java-demo'
  107.             }
  108. //             post { // 后置执行
  109. //               failure {
  110. //                  echo "启动容器失败..."
  111. //               }
  112. //               success {
  113. //                  echo "启动容器成功..."
  114. //               }
  115. //             }
  117.         }
  119.         // 推送报告
  120.         stage('推送报告') {
  121.             steps { // 步骤
  122.                 echo "推送报告..."
  123.                 emailext body: '''<!DOCTYPE html>
  124.                                 <html>
  125.                                 <head>
  126.                                 <meta charset="UTF-8">
  127.                                 <title>${ENV, var="JOB_NAME"}-第${BUILD_NUMBER}次构建日志</title>
  128.                                 </head>
  130.                                 <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4"
  131.                                     offset="0">
  132.                                     <table width="95%" cellpadding="0" cellspacing="0"  style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
  133.                                 <h3>本邮件由系统自动发出，请勿回复！</h3>
  134.                                         <tr>
  135.                                            <br/>
  136.                                             各位同事，大家好，以下为${PROJECT_NAME }项目构建信息</br>
  137.                                             <td><font color="#CC0000">构建结果 - ${BUILD_STATUS}</font></td>
  138.                                         </tr>
  139.                                         <tr>
  140.                                             <td><br />
  141.                                             <b><font color="#0B610B">构建信息</font></b>
  142.                                             <hr size="2" width="100%" align="center" /></td>
  143.                                         </tr>
  144.                                         <tr>
  145.                                             <td>
  146.                                                 <ul>
  147.                                                     <li>项目名称 ： ${PROJECT_NAME}</li>
  148.                                                     <li>构建编号 ： 第${BUILD_NUMBER}次构建</li>
  149.                                                     <li>触发原因： ${CAUSE}</li>
  150.                                                     <li>构建状态： ${BUILD_STATUS}</li>
  151.                                                     <li>构建日志： <a href="${BUILD_URL}console">${BUILD_URL}console</a></li>
  152.                                                     <li>构建  Url ： <a href="${BUILD_URL}">${BUILD_URL}</a></li>
  153.                                                     <li>工作目录 ： <a href="${PROJECT_URL}ws">${PROJECT_URL}ws</a></li>
  154.                                                     <li>项目  Url ： <a href="${PROJECT_URL}">${PROJECT_URL}</a></li>
  155.                                                 </ul>
  158.                                 <h4><font color="#0B610B">最近提交</font></h4>
  159.                                 <ul>
  160.                                 <hr size="2" width="100%" />
  161.                                 ${CHANGES_SINCE_LAST_SUCCESS, reverse=true, format="%c", changesFormat="<li>%d [%a] %m</li>"}
  162.                                 </ul>
  163.                                 详细提交: <a href="${PROJECT_URL}changes">${PROJECT_URL}changes</a><br/>
  165.                                             </td>
  166.                                         </tr>
  167.                                     </table>
  168.                                 </body>
  169.                                 </html>''', subject: '${ENV, var="JOB_NAME"}-第${BUILD_NUMBER}次构建日志', to: '1900919313@qq.com'
  170.             }
  171.         }
  172.     }
  174.     post { // 后置执行，任意阶段成功或失败都会进入此流程
  175.         always {
  176.             echo "${currentBuild.result} ---> always..."
  177.         }
  178.         failure {
  179.            echo "${currentBuild.result} ---> 部署失败..."
  180.         }
  181.         success {
  182.            echo "${currentBuild.result} ---> 部署成功..."
  183.         }
  184.     }
  185. }