Jenkins流水线自动化构建部署k8s实践

本文阅读量: 2021-02-04

一自动化构建部署的必要性

现如今，自动化构建部署在研发流程中，已经占据了很重要的位置。除非你们公司还是单体架构，每次只需要构建一个大单体系统即可，那自动化构建可能对你们的用处不大。

但是，目前大部分的互联网公司或者传统转型互联网的公司，几乎都会使用微服务架构，微服务架构的微服务少的十几个，多的几十个或者几百个都很正常。如果这么多的微服务，都靠人工去构建部署，效率得多低，可想而知。所以我们都会考虑通过自动化构建部署手段去做这些重复劳动，对于有些大厂，可能会自研一些自动化部署的系统。而对于大部分公司，几乎都会通过Jenkins和Jenkins的一些插件来实现自动化部署。

而且，这么多的微服务，如果靠运维去管理这些服务，工作量也会很大，所以，目前大部分互联网公司都会用上k8s。

我们这篇文章不会介绍如何安装k8s，但是会介绍如何通过Jenkins流水线自动化构建部署前后端应用到k8s。

二依赖的Jenkins插件

Jackson 2 API v2.11.0
Kubernetes v1.21.3
Kubernetes Client API v4.6.3-1
Kubernetes Credentials v0.5.0
Kubernetes Continuous Deploy v2.1.2
Last Changes Plugin(最新版本插件即可)
Pipeline Utility Steps(最新版本插件即可)
Docker Pipeline(最新版本插件即可)

如果遇到一些版本冲突，大概率是Jackson2API造成的，调整版本也许即可解决。

三 Jenkins流水线构建流程如下

流水线的流程如下：

-> Gitlab配置Jenkins钩子

-> 触发Jenkins流水线构建

-> 拉取代码

-> 编译

-> 打镜像

-> push镜像

-> 发布到开发环境k8s

-> 发送钉钉消息通知

流水线groovy脚本如下：

vars/bootCD.groovy

// spring boot项目标准化构建及部署
// 参数说明：
// k开头的参数为kubernetes相关的参数

def call(body) {

    def config = [
            "kSkip"            : false,             // 是否跳过kubernetes部署
            "kSshServer"       : "192.168.90.220",  // 可以是任何能使用kubectl操作kubernetes的主机IP
            "kSshCredentialsId": "dev-k8s",   // Jenkins中配置的kubernetes操作主机的Credentials
            "kConfigs"         : "kubernetes/*.yaml", // kubernetes的配置文件
            "kNamespace"       : "mafgwo-dev",        // kubernetes部署的命名空间
            "projectVersion"   : "1.0",       // 支持外部传入版本号
            "gradleVersion"    : "5.6.4",
            "robotKey"         : "[钉钉机器人ID]"
    ]
    body.resolveStrategy = Closure.DELEGATE_FIRST
    body.delegate = config
    body()

    node {
        // 是否主分支，只有主分支的包才能部署到Maven，也只有主分支的镜像才能发布到生产环境

        def context = [
                "config"    : config,
                "gitRepo"   : "",
                "branchName": "",
                "webhook"   : "https://oapi.dingtalk.com/robot/send?access_token=" + config.robotKey,
                "username"  : "",
        ]

        try {
            stage('准备') {
                checkout scm
                print "gitlab branch: " + env.gitlabSourceBranch
                context.gitRepo = sh(label: '', returnStdout: true, script: 'git config remote.origin.url').trim()
//                context.branchName = sh(label: '', returnStdout: true, script: 'git name-rev --name-only HEAD').trim()
                context.branchName = env.gitlabSourceBranch
                context.username = env.gitlabUserName
                lastChanges format: 'SIDE', matchWordsThreshold: '0.25', matching: 'LINE', matchingMaxComparisons: '1000', showFiles: true, since: 'PREVIOUS_REVISION', specificBuild: '', specificRevision: '', synchronisedScroll: true, vcsDir: ''
            }

            // 编译、构建、部署
            gradleStages(context)

            buildProject(context)

            if (!context.config.kSkip) {
                deployToKubernetes(context)
            }
            tagBuild()
            notifySuccess(context)
        } catch (e) {
            e.printStackTrace()
            notifyFailed(context, "${e}")
        }
    }
}

private void gradleStages(context) {
    config = context.config
    def gradleHome = tool "Gradle ${config.gradleVersion}"
    env.PATH = "${gradleHome}/bin:${env.PATH}"
    stage('编译和打包') {
        sh 'gradle -v'
        sh 'gradle clean build -x test --refresh-dependencies'
    }
}

private void tagBuild() {
    stage('打Gitlab标签') {
        def tagName = "BUILD${env.BUILD_NUMBER}"
        sh "git tag ${tagName} && git push origin ${tagName}"
    }
}

private void deployToKubernetes(context) {
    stage('部署K8S') {
        config = context.config
        env.NAMESPACE = config.kNamespace
        env.IMAGE_TAG = getImageTag(context)

        kubernetesDeploy(
                credentialsType: 'SSH',
                ssh: [sshCredentialsId: "${config.kSshCredentialsId}", sshServer: "${config.kSshServer}"],
                configs: "${config.kConfigs}"
        )
    }
}

private void buildProject(context) {

    def stepsForParallel = [:]
    for (module in getDockerModules()) {
        sh "cp -f ${module}/src/main/docker/* ${module}/build/libs/"
        stash name: getStashName(module), includes: "${module}/build/libs/*"
        transformIntoDockerStep([
                "module"  : module,
                "imageTag": getImageTag(context)
        ])
    }
}

def transformIntoDockerStep(settings) {
    def stashName = getStashName(settings.module)
    def fullImageName;
    stage("构建推送镜像: ${settings.module} ") {
        dir(stashName) {
            unstash stashName
        }
        dir("${stashName}/${settings.module}/build/libs") {
            docker.build("${getImageName(settings.module)}")
        }

        docker.withRegistry('http://10.0.35.243', 'mafgwo-docker-register') {
            docker.image("${getImageName(settings.module)}").push("${settings.imageTag}")
            fullImageName = docker.image("${getImageName(settings.module)}").imageName() + ":" + settings.imageTag
        }
    }
}

/**
 * 通过钉钉群机器人发送构建成功信息
 *
 * @param webhook
 */
private void notifySuccess(context) {
    content = "项目【${env.JOB_NAME}】构建<font color=\\\"info\\\">成功</font> \\n\\n " +
            ">构建仓库: <font color=\\\"comment\\\">${context.gitRepo}</font> \\n\\n " +
            ">构建用户: <font color=\\\"comment\\\">${context.username}</font> \\n\\n " +
            ">构建分支: <font color=\\\"comment\\\">${context.branchName}</font> \\n\\n " +
            ">构建版本: <font color=\\\"comment\\\">${env.BUILD_NUMBER}</font> \\n\\n " +
            ">镜像版本: <font color=\\\"comment\\\">${env.IMAGE_TAG}</font> \\n\\n " +
            ">构建详情: [点击查看](${env.BUILD_URL})"
    message =
            """
{
    "msgtype": "markdown",
    "markdown": {
        "title": "构建成功(${env.JOB_NAME})",
        "text": "${content}"
    }
}
"""

    stage('发布成功通知') {
        invokeWebhook(context.webhook, message)
        if (env.CHANGE_AUTHOR_DISPLAY_NAME) {
            invokeWebhook(context.webhook, "@" + env.CHANGE_AUTHOR_DISPLAY_NAME)
        }
    }
}

/**
 * 通过企业微信群机器人发送构建异常信息
 * @param webhook
 * @param e
 */
private void notifyFailed(context, e) {


    content = "项目【${env.JOB_NAME}】构建<font color=\\\"warning\\\">失败</font>，请相关同学注意 \\n\\n " +
            ">构建仓库: <font color=\\\"comment\\\">${context.gitRepo}</font> \\n\\n " +
            ">构建用户: <font color=\\\"comment\\\">${context.username}</font> \\n\\n " +
            ">构建分支: <font color=\\\"comment\\\">${context.branchName}</font> \\n\\n " +
            ">构建版本: <font color=\\\"comment\\\">${env.BUILD_NUMBER}</font> \\n\\n " +
            ">构建详情: [点击查看](${env.BUILD_URL}) \\n\\n " +
            ">异常信息: <font color=\\\"comment\\\">${e}</font>"
    message =
            """
{
    "msgtype": "markdown",
    "markdown": {
        "title": "构建失败(${env.JOB_NAME})",
        "text": "${content}"
    }
}
"""

    stage('发布失败通知') {
        print "sending message: " + message
        invokeWebhook(context.webhook, message)
        if (env.CHANGE_AUTHOR_DISPLAY_NAME) {
            invokeWebhook(context.webhook, "@" + env.CHANGE_AUTHOR_DISPLAY_NAME)
        }
    }
}

private void invokeWebhook(String webhook, String body) {
    sh("curl -s -XPOST -H 'Content-Type: application/json' ${webhook} -d '${body}'")
}

// 查找有Docker配置的模块
String[] getDockerModules() {

    def relativePath = "/src/main/docker/Dockerfile"
    def result = []
    for (file in findFiles(glob: '**/src/main/docker/Dockerfile')) {
        result << file.path.substring(0, file.path.lastIndexOf("${relativePath}"))
    }

    result
}

// 根据module构造Docker镜像的URL
String getImageName(module) {
    module = module.substring(module.lastIndexOf("/") + 1)
    "mafgwo-server/${module}"
}

// 获取版本号 x.x.x.x
String getImageTag(context) {
    version = context.config.projectVersion;
    if (version.lastIndexOf("-") > 0) {
        version = version.substring(0, version.lastIndexOf("-"))
    }
    if (isMasterBranch(context.branchName)) {
        return "${version}.${BUILD_NUMBER}"
    } else {
        return "${version}.${BUILD_NUMBER}-dev"
    }
}

// 获取暂存名称，主要是去除名称中的非规范字符
String getStashName(name) {
    name = name.replaceAll("\\\\", "-").replaceAll("/", "-")
    "stash-${name}"
}

boolean isEmpty(string) {
    string != null && string != ""
}

private boolean isMasterBranch(branchName) {
    "master".equals(branchName)
}

Jenkins配置流水线lib

代码中配置Jenkinsfile

直接在项目的根目录下创建Jenkinsfile，如下：

library 'mafgwo-library@master'

bootCD {
    projectVersion = "1.0"
    gradleVersion = "5.6.4"
}

代码中配置Dockerfile

Dockerfile放在模块下的main/docker/Dockerfile，如下：

FROM xxxxx.com/openjdk:8
ENV JAVA_APP_JAR app.jar
ADD xxxx-server-1.0.jar $JAVA_APP_JAR
RUN touch -c $JAVA_APP_JAR

代码中配置k8s的yaml文件

根目录下增加目录 kubernetes，在该目录下，增加k8s的yaml文件，如下：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: xxxx-server
  namespace: $NAMESPACE
  labels:
    app: xxxx-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: xxxx-server
  revisionHistoryLimit: 10
  minReadySeconds: 10
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  template:
    metadata:
      labels:
        app: xxxx-server
        boot-app: "true"
        use-javaopts: "true"
        use-eureka: "true"
    spec:
      containers:
        - name: xxxx-server
          image: registry.xxx.com/my-server/xxxx-server:$IMAGE_TAG
          imagePullPolicy: Always
          lifecycle:
            preStop:
              exec:
                command: ["/usr/bin/curl","-X","POST", "http://localhost:8081/actuator/shutdown"]
          livenessProbe:
            tcpSocket:
              port: 8081
            initialDelaySeconds: 10
            periodSeconds: 5
            failureThreshold: 20
            successThreshold: 1
            timeoutSeconds: 3
          readinessProbe:
            httpGet:
              path: /actuator/health
              port: 8081
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 5
            failureThreshold: 20
            successThreshold: 1
            timeoutSeconds: 3
          ports:
            - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: xxxx-server
  namespace: $NAMESPACE
spec:
  ports:
    - name: http
      port: 8080
      protocol: TCP
  selector:
    app: xxxx-server

---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: xxxx-server
  namespace: $NAMESPACE
spec:
  rules:
    - host: xxxx-server.dev.xxx.com
      http:
        paths:
          - path: /
            backend:
              serviceName: xxxx-server
              servicePort: 8080

Jenkins中创建流水线任务

新增任务选择流水线

关键配置：

1 选择不允许并发构建

2 配置gitlab钩子：Build when a change is pushed to GitLab. GitLab webhook URL: xxxx

3 配置scm如下

依赖其他组件部署文档如下：

k8s的部署请参考文章：https://mafgwo.cn/2021/01/22/7307_kubeadm%E6%96%B9%E5%BC%8F%E5%AE%89%E8%A3%85k8s%E9%9B%86%E7%BE%A4/
Jenkins的部署请参考文章：https://mafgwo.cn/2021/01/31/2012_Jenkins%E7%9A%84Docker%E6%96%B9%E5%BC%8F%E9%83%A8%E7%BD%B2/
harbor仓库部署请参考文章：https://mafgwo.cn/2021/02/01/2013_Docker%E4%BB%93%E5%BA%93Harbor%E9%83%A8%E7%BD%B2/
Gitlab仓库部署请参考官方文档：https://about.gitlab.com/install/

一 自动化构建部署的必要性

二 依赖的Jenkins插件

三 Jenkins流水线构建流程如下

依赖其他组件部署文档如下：

一自动化构建部署的必要性

二依赖的Jenkins插件