作者: 李镇伟

在Kubernetes里使用gradle缓存加速编译和docker in docker例子

需求

1.我们的代码编译需要用到gradle6.2版本,jdk13版本,docker in docker策略
2.因为是在CI环境中使用,所以gradle容器会因为流水线的触发,不停的启动和删除。下载jar包会非常消耗时间,我们需要持久化这些gradle缓存。
3.挂载这些gradle缓存文件到机器上,可以用ceph集群和NFS,这里我偷懒,先用NFS做,后期资源充足再换成ceph。
4.因为我们有并行流水线的可能,所以gradle容器可能一次不止一个,而gradle的caches一次只能被一个进程占用,为了避免多容器占用同一个gradle的caches,我们需要有策略。


已经踏过的坑

1.不能使用apline来制作gradle容器,因为我们的代码里有用到protoc,他会在gradle里安装protoc-3.10.1-linux-x86_64.exe,但是这个程序并不兼容alpine系统,最终会导致报错。报错信息如下图

2.不要使用adoptopenjdk/openjdk13:latest镜像来制作Dockerfile,这个镜像用的jdk版本是jdk13 ea版本。这个ea版本和正常的jdk13有一些细微的差点,这会导致gradle最后编译失败,报错信息如下图

3.不要直接把gradle缓存目录直接挂载进去,这会导致多任务时阻塞,同时编译失败,如下图


解决过程

1.创建NFS

NFS的搭建是比较简单的。在网上可以很容易搜索到教程,这里需要注意节点机器上也需要安装NFS工具,apt-get install nfs-common,不然会报错,导致K8S在这个节点上创建不了容器,因为挂载volume就失败了
我们在NFS服务器上创建一个目录,用于存放gradle的缓存

vi /etc/exports
添加
/nfsdata/gradle-cache/ *(rw,sync,no_root_squash,no_subtree_check)

2.创建gradle镜像,用于k8s中编译使用

使用Dockerfile,内容如下

FROM gradle:6.2.0-jdk13
# 因为需要docker in docker 所以这里用阿里云一键安装docker
RUN  curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
# 随意创建一个文件
RUN echo "test" > test.log
# 因为使用了私有仓库,所以之间拷贝docker配置文件进去
COPY daemon.json /etc/docker/daemon.json
# 原来的gradle命令是"jshell"这里我们替换掉,避免容器启动后,程序结束就消失
ENTRYPOINT ["tail","-f","test.log"]

docker build -t gradle_lzw .

3.使用这个gradle镜像运行起来,进行一次编译,把gradle caches拷贝出来,放到NFS中

#运行容器
docker run -d -v /var/run/docker.sock:/var/run/docker.sock gradle_lzw
# 进入容器编译代码, docker exec  -it gradle_lzw gradle XXXXX(gradle编译命令)
# 复制出缓存文件 docker cp gradle:/home/gradle/.gradle /home/temp/local/.gradle

关于gradle的缓存可以看这个https://github.com/keeganwitt/docker-gradle

4.把上一步获得的gradle缓存文件上传到NFS服务器上

scp -r root@{有gradle缓存的机器IP}:/home/temp/local/.gradle /nfsdata/gradle-cache/.

5.为了避免多容器并发占用gradle缓存目录,我们只能绕开直接挂载。我们先把缓存文件挂载到一个无用的目录中,然后再从这个目录复制到gradle指定的缓存目录中l

项目流水线配置

Jenkinsfile内容参考:

pipeline {
    agent {
        kubernetes {
            //label使用项目名称,因为不同的项目,build方式是不同的,如果错误的使用了相同的label。Jenkins就不会去读取BuildPod.yaml
            label 'jnlp-项目名称'
            //
            yamlFile 'BuildPod.yaml'
        }
    }
    stages {
        stage('build') {
         //使用gradle容器
		 container('gradle'){
		 sh '''
         //复制缓存文件
         cp -rf /opt/.gradle/caches /home/gradle/.gradle/caches
         gradle {build 命令}
          '''
          }
		}
	}
}

BuildPod.yaml配置,gradle-cache是缓存目录,dind是docker in docker的必要容器

kind: Pod
metadata:
  labels:
    some-label: some-label-value
spec:
  containers:
  - name: jnlp
    image: jenkins/jnlp-slave
    tty: true
    volumeMounts:
    - name: workspace-volume
      mountPath: /home/jenkins
  - name: gradle
    image: gradle_lzw:latest
    tty: true
    volumeMounts:
    - name: workspace-volume
      mountPath: /home/jenkins
    - name: gradle-cache
      mountPath: /opt/.gradle
    env:
    - name: DOCKER_HOST
      value: tcp://localhost:2375
  - name: dind
    image: docker:18.05-dind
    securityContext:
      privileged: true
    volumeMounts:
      - name: dind-storage
        mountPath: /var/lib/docker
  imagePullSecrets:
    - name: repok8s
  volumes:
  - name: gradle-cache
    nfs:
      server: {NFS服务器IP}
      path: "/nfsdata/gradle-cache/.gradle"
  - name: workspace-volume # pod中有一个volume让其中的多个容器共享
    emptyDir: {}
  - name: dind-storage
    emptyDir: {}

打造K8S与Jenkins的持续集成系统-CI部分

说明

持续集成系统包括CI和CD。在这篇文章里,我们只讨论CI的实现。关于K8S,Jenkins,私有仓库的安装这里不进行说明,只讲解如何将这些工具组合在一起。

1.拥有一个K8S集群

我的环境是6台虚拟机,3台Master,3台Slaver。如下图所示

运行结果如下图:

2.Jenkins中安装好了kubernetes插件


安装好之后,在系统设置中,能够添加kubernetes信息

3.根据Jenkins的配置要求,去自己的K8S平台上找到对应的信息。填入Jenkins中


我们根据图中的要求,可以在K8S里进行一个个的查找我们想要的信息

字段
查找方法
Kubernetes 地址
IP地址是在keepalived里配置的虚拟IP

在搭建k8S平台时,用到了haproxy,当时指向了**443端口
kubernetes名称 随意填写
kubernetes命名空间 需要在K8S里创建一个命名空间,然后在这个地方使用
凭据
1.进入K8S机器上,输入命令kubectl config view –minify –flatten查看凭据

2.把凭据信息复制成一个文件

3.在Jenkins里上传这个文件

4.这个凭据信息即可在Jenkins配置里使用
JENKINS地址 配置本次使用的Jenkins的url即可
Pod Retention 选择Never,Jenkins任务完成后就删除pod

4.添加私有密钥用于拉取我们的docker私有镜像

在K8S里输入如下命令
kubectl create secret docker-registry repo-k8s \
-n k8s-jx \
--docker-server='repo.local:5000' \
--docker-username='
zhenwei.li
' \
--docker-password='*******' \
--docker-email='357244849@qq
.com
'

5.在Jenkins里编写一个最简单的流水线任务。来测试Jenkins是否可以拉起K8S的节点,产生pod

5.1.从github上抄一段代码示例下来https://github.com/jenkinsci/kubernetes-plugin/blob/master/src/test/resources/org/csanchez/jenkins/plugins/kubernetes/pipeline/jnlpWorkingDir.groovy

podTemplate(label:'jnlp-slave',cloud: 'kubernetes',containers: [
    containerTemplate(name: 'busybox', image: 'nginx:latest', ttyEnabled: true)
],imagePullSecrets:['secret/repok8s']) {
    node ('jnlp-slave') {
        stage('Run') {
            sh 'env | sort'
            container('busybox') {
                sh 'echo "hello"'
                sh 'pwd'
                sh 'ls'
            }
        }
    }
}

5.2创建一个流水线任务

5.3运行这个流水线任务,查看结果

5.4在K8S上输入查找pod的命令,应该会发现有一个pod被运行起来了,名字中含有jnlp-slave的字样,2/2运行两个容器,一个是jnlp容器,一个是busybox容器

kubectl get pods --all-namespaces -o wide

6.在代码仓库中添加CI所需要的Jenkinsfile和BuildPod.yaml等流水线文件

文件名
用处
sonar-project.properties 定义代码需要执行什么语言的扫描,哪些目录需要剔除
JenkinsfileTag 定义打tag操作对应的流水线行为
Jenkinsfile 定义代码提交与合并的流水线行为
BuildPod.yaml K8S产生的pod中,包含哪些容器,容器的环境变量等参数设置

7.BuildPod.yaml中需要包含哪些内容(以nodejs代码举例)

8.Jenkinsfile中需要包含哪些内容

最后在Jenkins里查看运行效果


 

使用dd命令在linux系统里制作U盘装系统

需求

我们需要在一台全新的机器上安装一台新的debian机器。

准备工作:

1.一台已经有linux系统的机器(一般来说,linux机器都会有dd命令)
2.一个U盘
3.一个待安装的全新机器

实施步骤

1.在这台已经有linux系统的机器上下载debian的ISO镜像。放在指定目录下,如:

/home/sfere/debian-10.1.0-amd64-DVD-1.iso

2.把U盘插入这台linux电脑里,输入命令

fdisk -l

检查硬盘挂载情况

3.使用dd命令,把U盘做成启动盘。此步需要注意,上面看到我们的28.9G的U盘是/dev/sdb4。但是我们下面的命令里要用/dev/sdb而不要加最后的4。如果加了4会导致下一步安装失败

dd if=/home/sfere/debian-10.1.0-amd64-DVD-1.iso of=/dev/sdb bs=8M;sync

完成之后,效果如下:

root@debian:~# dd if=/home/sfere/debian-10.1.0-amd64-DVD-1.iso of=/dev/sdb bs=4M;sync
930+1 records in
930+1 records out
3901456384 bytes (3.9 GB, 3.6 GiB) copied, 563.589 s, 6.9 MB/s

4.把U盘拔下来,插入另外一台全新的电脑中,bios启动顺序中,选择USB为第一位启动。即可开始安装

sonarQube解决sonar.java.binarie必填参数的问题

问题阐述

新版的sonarQube在扫描java代码的时候,要求sonar-project.properties里sonar.java.binaries字段必须填写。这个sonar.java.binaries是“指向包含与源文件对应的已编译字节码文件的目录”,一般来说,maven框架的话,是target/classes。
但是!问题来了,有的时候,我们的代码静态扫描是在还没有编译之前就开始的。例如我们从Jenkins的pipeline里定义了git 拉取代码,然后直接执行SonarQube analysis。并不进行编译。这样我们的Jenkins里是会报错的。那我们该如何处理呢?

解决方案

1.错误的解决方案:网上流行的是去sonarQube的plugins下面的sonar-java替换成4.10版本。但是,这样做其实是不对的,这样会引发其他的不兼容报错
2.正确的解决方案是:先生成一个空的目录,然后把sonar-project.properties指向这个目录。这样就能避免这个错误。下面提供一段pipeline,以供参考

Talk is cheap,show me the code

stage('create empty folder') {
            steps {
                sh "mkdir /tmp/empty"
                sh "echo -e 'sonar.java.binaries=/tmp/empty' >> ./sonar-project.properties"
            }
        }
stage('SonarQube analysis') {
    steps {
        script {
            def scannerHome = tool 'sonarqubescanner4.0'
            withSonarQubeEnv('sonar') { // If you have configured more than one global server connection, you can specify its name
                sh "${scannerHome}/bin/sonar-scanner"
            }
        }
    }
}

Jenkins根据pipeline的运行结果,给gitea的合并请求pull-request进行评论

需求

Jenkins我们已经集成了sonarqube,并且通过sonarqube的gate能获取到结果,并且告知Jenkins是成功还是失败。但是这样还不够,我们需要限制队友向主分支提交代码。我们锁住了master分支,队友只能通过在gitea中向master分支提交pull-request并且通过了sonarqube的代码质量检查,我们才允许合并进主分支。我们急需要一个评论功能,告知我们,这次的合并请求是否允许合并

最终效果图

关键点

1.在gitea中创建一个用户,用这个用户专门进行评论,例如我这里的“guardian”账户
2.把该账户加入Jenkins的凭据管理里。如下图:

3.在gitea的官方文档里找到添加评论的API,链接如下:https://try.gitea.io/api/swagger#/issue/issueCreateComment
4.在Jenkins的pipeline中定义添加评论的方法,并且分别放在success和unsuccessful结果里。如下:

//这一段是添加评论的方法
def gitComment(String comment) {
        script {
                if (IS_PULL_REQUEST==true){
                     numb=env.BRANCH_NAME.split('-')[-1];
                    def check_result = '{"body": "'+comment+'"}';
                    def response = httpRequest httpMode: 'POST',
                    url: 'https://{服务器地址}/git/api/v1/repos/{所属人}/{仓库名}/issues/'+numb+'/comments',
                    authentication : '74849b03-79ba-43f5-b4b6-920',
                    acceptType: 'APPLICATION_JSON_UTF8', contentType: 'APPLICATION_JSON_UTF8',
                    requestBody : check_result
                }
        }
}
//根据执行结果,进行不同的评论
post {
        success {
            gitComment("通过CI检查,允许合并")
        }
        unsuccessful {
            gitComment("没有通过CI检查,建议不要合并"+env.RUN_DISPLAY_URL)
        }
    }

								

解决Sonarqube quality gate获取不到Sonarqube正确扫描结果的问题

问题

在Jenkins pipeline中,一般都会用到Sonar-scanner来扫描代码,扫描完之后,把结果上传到SonarQube中,SonarQube把结果与质量阀进行对比,然后通过Sonarqube quality gate来判断这次扫描结果是成功还是失败。
不少同学都遇到过Sonarqube quality gate 获得的最后结果不正确,明明SonarQube中的结果是success,而Sonarqube quality gate判断的结果是pending。
这是怎么一回事呢?
原因在于,SonarQube如果没有配置webhook的情况下,Sonarqube quality gate只会第一次主动去请求结果,如果这个时候SonarQube还没有分析完毕,那么就会返回一个in_progress.接下来,Sonarqube quality gate不会再去主动请求,而是被动等待webhook。如果没有配置webhook,那么就会进入一直等待的状态。
常用的解决方法有二:
1.在Sonarqube quality gate添加等待10秒的时间(治标不治本)

2.在SonarQube里添加Jenkins的webhook。(这种方法最好,不需要加等待时间)

添加之后。一切正常,可以正确获得Sonarqube的最新结果

nginx做LDAP端口转发

在nginx的配置文件/etc/nginx/nginx.conf中配置

stream {
    server {
        proxy_timeout 300s;
        proxy_connect_timeout 300s;
        listen       1234;
        proxy_pass 127.0.0.1:389;
        proxy_busy_buffers_size 64k;
    }
}

389是ldap原来的端口,1234是用nginx转发的新端口

SonarQube的LDAP配置

1.先登陆openldap的配置页面

添加一个组叫sonar-administrators,里面添加上自己的账户

在uniqueMember下假如有一个cn=lizhenwei,dc=lzwsoft,dc=com

2.在SonarQube里配置增加一个sonar-administrators的组,把这个组的权限设置成管理员

3.进入SonarQube的配置文件sonar.properties里修改LDAP相关的配置文件。参考如下

# LDAP configuration
# General Configuration
sonar.security.realm=LDAP
ldap.url=ldap://192.168.114.170:389
#这个bindDn一般用的管理员的用户名和密码
ldap.bindDn=cn=admin,dc=lzwsoft,dc=com
ldap.bindPassword=xx
# User Configuration
# 这个一般用的搜索路径
ldap.user.baseDn=dc=lzwsoft,dc=com
ldap.user.request=(&(objectClass=inetorgperson)(uid=${login}))
ldap.user.realNameAttribute=cn
ldap.user.emailAttribute=mail
# Group Configuration
ldap.group.baseDn=dc=lzwsoft,dc=com
# 这个地方很重要,grou的idAttribute用cn。cn是判断用户属于那个组的关键参数
ldap.group.idAttribute=cn

注意ldap.group.baseDn是基础搜索。

搜索出来之后,根据dn进行二次搜索,获得cn

然后根据cn与我们的权限系统相对应。所以后续我们可以用jira来管理sonar和其他的权限。以后jira上的前端和后端需要分开建立权限了

4.重启SonarQube,登录检查是否成功

一般来说,用lizhenwei对应的密码是可以成功的。而且登录进去之后,权限就是管理员。
后续如果想要添加组,重复上面1和2的操作,必须先在LDAP里面添加组,然后在sonarqube里添加组,然后把员工绑入这个组,才能生效,如果没有这样做,会导致这个员工登录之后,并没有对应组的权限。

GitOps时序图

gitops是现在一个比较火的话题,最近刚好我也在调研,根据我自己的理解,画了如下时序图。

git push


git merge

python-检查一个json是否包含另外一个json

需求:

有两个json文件。两个都是复杂嵌套格式。需要比对A.json里是否包含b.json。
例如A.json是

{
  "role": "admin",
  "routes": [
    "/Home",
    "/DeviceManagement",
    "/UserManagement"
  ]
}

B.json是

{
  "role": "admin",
  "routes": [
    "/Home",
    "/TemplateManagement",
    "/DataDictionary",
    "/ClassifyAndSubEntry",
    "/ProjectManagement",
    "/DeviceManagement",
    "/UserManagement"
  ]
}

要检查B文件是否包含A文件。这个json文件还好嵌套不多,当多个dict和list魂用,即[]和{}太多时,则会出现很难比对的问题。我考虑使用jsonpath来解决这个问题

代码实现

1.把json文件变成一个新的dict[jsonpath,value] ,例如’infos/0/item’: ‘direction’  表示jsonpath为”infos.0.item”对应的值是direction。具体的可以打印一下JsonPathValue这个类的final_dict就能明白了

#  filename : test1.py
#  description :
#
#  created by zhenwei.li at 2019/5/27 10:59
import json
class JsonPathValue(object):
    def __init__(self, datadict):
        self.stack = []
        self.final_dict = {}
        self.do_walk(datadict)
    def get_dict(self):
        return self.final_dict
    def do_walk(self, datadict):
        if isinstance(datadict, dict):
            for key, value in datadict.items():
                self.stack.append(key)
                # print("/".join(self.stack))
                if isinstance(value, dict) and len(value.keys()) == 0:
                    self.final_dict["/".join(self.stack)] = "EMPTY_DICT"
                if isinstance(value, list) and len(value) == 0:
                    self.final_dict["/".join(self.stack)] = 'EMPTY_LIST'
                if isinstance(value, dict):
                    self.do_walk(value)
                if isinstance(value, list):
                    self.do_walk(value)
                else:
                    self.final_dict["/".join(self.stack)] = value
                self.stack.pop()
        if isinstance(datadict, list):
            n = 0
            for key in datadict:
                self.stack.append(str(n))
                n = n + 1
                if isinstance(key, dict):
                    self.do_walk(key)
                if isinstance(key, list):
                    self.do_walk(key)
                if isinstance(key, str):
                    self.final_dict["/".join(self.stack)] = key
                self.stack.pop()
def json_contain(checkpoint, actual, assert_flag):
    """
    检查实际结果(json)中是否包含检查点(json)。两个必须是同种格式,比如同时是{}或者[]
    :param checkpoint: 检查点(期望结果)
    :param actual:  实际结果
    :param assert_flag: 是否启用assert检查
    :return: 匹配成功或失败
    """
    result = False
    if isinstance(checkpoint, list):
        '''如果期望的检查点是list[]格式,使用此方法检查'''
        find_count = 0
        check_lenth = len(checkpoint)
        for item in checkpoint:
            checkpoint_dict = JsonPathValue(item).get_dict()
            if isinstance(actual, list):
                find_flag = False
                for actual_item in actual:
                    actual_dict = JsonPathValue(actual_item).get_dict()
                    find_flag = list_contain(checkpoint_dict, actual_dict, False)
                    if find_flag:
                        find_count += 1
                        break
                print(find_flag)
            else:
                assert False, "返回的实际结果格式不正确"
            if assert_flag:
                assert find_flag, "期望结果中的\n%s\n匹配失败,实际结果是:\n%s" % (item, actual)
        if find_count == check_lenth:
            result = True
    elif isinstance(checkpoint, dict):
        '''
        如果期望的检查点是dict{}格式
        '''
        checkpoint_dict = JsonPathValue(checkpoint).get_dict()
        actual_dict = JsonPathValue(actual).get_dict()
        if list_contain(checkpoint_dict, actual_dict, True):
            result = True
    return result
def list_contain(checkpoint_dict, actual_dict, assert_flag):
    """
     检查实际结果(list)中是否包含期望结果(list)
    :param checkpoint_dict: 实际结果
    :param actual_dict: 期望结果
    :param assert_flag: 是否启用assert检查
    """
    result = set(checkpoint_dict.items()).issubset(set(actual_dict.items()))
    if assert_flag is True:
        different = set(checkpoint_dict.items()) - (set(actual_dict.items()))
        assert result, \
            "期望结果中的%s匹配失败,实际结果是:\n%s" % (different, actual_dict)
    return result
json_data = open('A.json', 'rb').read()
json_dict = json.loads(json_data)
json_data2 = open('B.json', 'rb').read()
json_dict2 = json.loads(json_data2)
res1 = json_contain(json_dict, json_dict2, True)
print(res1)

苏ICP备18047533号-1