Jenkins是用Java语言编写的，是目前使用最多和最受欢迎的持续集成工具，使用Jenkins，可以自动监测到git或者svn存储库代码的更新，基于最新的代码进行构建，把构建好的源码或者镜像发布到生产环境。Jenkins还有个非常好的功能：它可以在多台机器上进行分布式地构建和负载测试

2. TeamCity

3. Travis CI

4. Go CD

5. Bamboo

6. GitLab CI

7. Codeship

它的好处主要有以下几点：

1）较早的发现错误：每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，哪个环节出现问题都可以较早的发现

2）快速的发现错误：每完成一部分代码的更新，就会把代码集成到主干中，这样就可以快速的发现错误，比较容易的定位错误

3）提升团队绩效：持续集成中代码更新速度快，能及时发现小问题并进行修改，使团队能创造出更好的产品

4）防止分支过多的偏离主干：经常持续集成，会使分支代码经常向主干更新，当单元测试失败或者出现bug，如果开发者需要在没有调试的情况下恢复仓库的代码到没有bug的状态，只有很小部分的代码会丢失

持续集成的目的是提高代码质量，让产品快速的更新迭代。它的核心措施是，代码集成到主干之前，必须通过自动化测试。只要有一个测试用例失败，就不能集成。

Martin Fowler说过，"持续集成并不能消除Bug，而是让它们非常容易发现和改正。"

互动：Martin Fowler是谁？

马丁·福勒

马丁·福勒是一个软件开发方面的著作者和国际知名演说家，专注于面向对象分析与设计，统一建模语言，领域建模，以及敏捷软件开发方法，包括极限编程。

与持续集成相关的还有持续交付和持续部署。

1.5.3 持续交付

持续交付在持续集成的基础上，将集成后的代码部署到更贴近真实运行环境的「类生产环境」（production-like environments）中。交付给质量团队或者用户，以供评审。如果评审通过，代码就进入生产阶段。

如果所有的代码完成之后一起交付，会导致很多问题爆发出来，解决起来很麻烦，所以持续集成，也就是没更新一次代码，都向下交付一次，这样可以及时发现问题，及时解决，防止问题大量堆积。

1.5.4 持续部署

持续部署是指当交付的代码通过评审之后，自动部署到生产环境中。持续部署是持续交付的最高阶段。

Puppet，SaltStack和Ansible是这个阶段使用的流行工具。容器化工具在部署阶段也发挥着重要作用。 Docker和k8s是流行的工具，有助于在开发，测试和生产环境中实现一致性。除此之外，k8s还可以实现自动扩容缩容等功能。

互动：举个例子，形象说明持续集成、持续交付、持续部署之间的关系

2.为什么大厂都在用DevOps？

2.1 神州泰岳DevOps生态体系建设与实践-神州泰岳云资源运营事业部经理张凯分享

传统软件服务企业的痛点?

解决之道：DevOps

本图摘自：张乐-《DevOps道法术器》

2.2 DevOps在金融行业的应用-张安全分享

标准的敏捷开发流程：

2.3 哪些企业在用DevOps？

2.4 DevOps在5G领域的的展望

3.K8S在DevOps中的核心作用

Docker和K8S的出现使DevOps变得更加普及，更加容易实现。在传统运维中我们服务时需要针对不同的环境去安装不同的版本，部署方式也杂、多。那么有了docker之后，一次构建、到处运行，我们只需要要构建一次镜像，那么只要有docker的主机，就可以基于镜像把应用跑起来。

互动：docker可以实现DevOps的这个思想，但是存在一个问题，什么问题呢？

在众多微服务中，我们每天可能需要去处理各种服务的崩溃，而服务间的依赖调用关系也及其复杂，这对我们解决问题带来了很大的复杂度。要很好的解决这个问题。我们就需要用到容器编排工具。

Kubernetes 的出现主宰了容器编排的市场，也进化了过去的运维方式，将开发与运维联系的更加紧密。而且让 DevOps 这一角色变得更加清晰，它是目前可用的很流行的容器解决方案之一。

3.1 自动化

敏捷开发->持续集成->持续交付->持续部署

3.2 多集群管理

可以根据客户需求对开发，测试，生产环境部署多套kubernetes集群，每个环境使用独立的物理资源，相互之间避免影响

3.3 多环境一致性

Kubernetes是基于docker的容器编排工具，因为容器的镜像是不可变的，所以镜像把 OS、业务代码、运行环境、程序库、目录结构都包含在内，镜像保存在我们的私有仓库，只要用户从我们提供的私有仓库拉取镜像，就能保证环境的一致性。

3.4 实时反馈和智能化报表

每次集成或交付，都会第一时间将结果通过多途径的方式反馈给你，也可以定制适合企业专用的报表平台。

4.基于Jenkins+K8S+harbor+git等技术链助力DevOps在企业落地实践

4.1 神州泰岳k8s+DevOps+微服务生态体系建设与实践

开发代码->提交代码到代码仓库->Jenkins调k8s API->动态生成Jenkins Slave Pod->Slave Pod拉取git上的代码->编译代码->打包镜像->推送镜像到镜像仓库harbor或者docker hub->通过k8s编排服务发布到测试、生产平台-> Slave Pod工作完成之后自动删除>通过Ingress发布服务

4.2 百度：基于k8s构建亿级PV流量的DevOps平台

功能图：

架构图：

4.3 发布应用到测试环境

4.4 发布应用到生产环境

4.5 整个DevOps流程图

5.基于Jenkins+k8s+Git+DockerHub等技术链构建企业级DevOps容器云平台

K8s版本：

[root@xianchaomaster1 ~]# kubectl get nodes

NAME STATUS ROLES AGE VERSION

xianchaomaster1 Ready control-plane,master 76d v1.23.1

xianchaonode1 Ready <none> 76d v1.23.1

jenkins版本：

最新版

5.1 安装Jenkins

5.1.1 安装nfs服务，可以选择自己的任意一台机器，我选择的是k8s的控制节点xianchaomaster1

（1）在xianchaomaster1和xianchaonode1上安装nfs服务

注意：如果已经安装过nfs，这个步骤可以忽略

[root@xianchaomaster1 ~]# yum install nfs-utils -y

[root@xianchaomaster1 ~]# systemctl start nfs

[root@xianchaomaster1 ~]# systemctl enable nfs

[root@xianchaonode1 ~]# yum install nfs-utils -y

[root@xianchaonode1 ~]# systemctl start nfs

[root@xianchaonode1 ~]# systemctl enable nfs

（2）在xianchaomaster1上创建一个nfs共享目录

[root@xianchaomaster1 ~]# mkdir /data/v2 -p

[root@xianchaomaster1 ~]# vim /etc/exports

/data/v1 *(rw,no_root_squash)

/data/v2 *(rw,no_root_squash)

#新增加一行/data/v2 *

#使配置文件生效

[root@xianchaomaster1 ~]# exportfs -arv

5.1.2 在kubernetes中部署jenkins

（1）创建名称空间

[root@xianchaomaster1 ~]# kubectl create namespace jenkins-k8s

（2）创建pv

#更新资源清单文件

[root@xianchaomaster1]# kubectl apply -f pv.yaml

#查看pv是否创建成功

[root@xianchaomaster1]# kubectl get pv

pv.yaml文件内容如下：

apiVersion: v1

kind: PersistentVolume

metadata:

name: jenkins-k8s-pv

spec:

capacity:

storage: 10Gi

accessModes:

- ReadWriteMany

nfs:

server: 192.168.40.180

path: /data/v2

（3）创建pvc

#更新资源清单文件

[root@xianchaomaster1]# kubectl apply -f pvc.yaml

#查看pvc是否创建成功

[root@xianchaomaster1]# kubectl get pvc -n jenkins-k8s

pvc.yaml文件内容如下：

kind: PersistentVolumeClaim

apiVersion: v1

metadata:

name: jenkins-k8s-pvc

namespace: jenkins-k8s

spec:

resources:

requests:

storage: 10Gi

accessModes:

- ReadWriteMany

（4）创建一个sa账号

[root@xianchaomaster1]# kubectl create sa jenkins-k8s-sa -n jenkins-k8s

（5）把上面的sa账号做rbac授权

[root@xianchaomaster1]# kubectl create clusterrolebinding jenkins-k8s-sa-cluster -n jenkins-k8s --clusterrole=cluster-admin --serviceaccount=jenkins-k8s:jenkins-k8s-sa

（6）通过deployment部署jenkins

[root@xianchaonode1 ~]# docker pull jenkins/jenkins:2.394

[root@xianchaonode1 ~]# docker save -o jenkins2.394 jenkins/jenkins:2.394

[root@xianchaonode1 ~]# ctr -n=k8s.io images import jenkins2.394

备注：jenkins安装的时候，每次镜像都要下载最新的，安装最新版jenkins，如何下载最新的镜像？

去dockerhub上按照我视频方式去获取

[root@xianchaonode1 ~]# docker load -i jenkins-slave-latest.tar.gz

[root@xianchaonode1 ~]# ctr -n=k8s.io images import jenkins-slave-latest.tar.gz

备注：jenkins-slave-latest.tar.gz这个里面封装的镜像是jenkins-slave-latest:v1，这个jenkins-slave-latest:v1镜像制作方法如下：

[root@xianchaomaster1]#cd /root/slave

[root@xianchaomaster1 slave]# cat dockerfile

FROM jenkins/jnlp-slave:4.13.3-1-jdk11

USER root

# 安装Docker

RUN apt-get update && apt-get install -y \

docker.io

# 将当前用户加入docker用户组

RUN usermod -aG docker jenkins

RUN curl -LO https://dl.k8s.io/release/stable.txt

RUN curl -LO https://dl.k8s.io/release/$(cat stable.txt)/bin/linux/amd64/kubectl

RUN chmod +x kubectl

RUN mv kubectl /usr/local/bin/

ENV DOCKER_HOST unix:///var/run/docker.sock

[root@xianchaomaster1 slave]# docker build -t=jenkins-slave-latest:v1 .

[root@xianchaomaster1 slave]# docker save -o jenkins-slave-latest.tar.gz jenkins-slave-latest:v1

#更新资源清单文件

[root@xianchaomaster1]# kubectl apply -f jenkins-deployment.yaml

#查看jenkins是否创建成功

[root@xianchaomaster1 jenkins]# kubectl get pods -n jenkins-k8s

NAME READY STATUS RESTARTS AGE

jenkins-74b4c59549-g5j9t 0/1 CrashLoopBackOff 3 67s

#看到jenkins-74b4c59549-g5j9t是CrashLoopBackOff状态，查看日志：

[root@xianchaomaster1]# kubectl logs jenkins-74b4c59549-g5j9t -n jenkins-k8s

日志信息显示：

touch: cannot touch '/var/jenkins_home/copy_reference_file.log': Permission denied

Can not write to /var/jenkins_home/copy_reference_file.log. Wrong volume permissions?

#报错显示没有权限操作/var/jenkins_home/copy_reference_file.log文件，解决办法如下：

[root@xianchaomaster1]# kubectl delete -f jenkins-deployment.yaml

[root@xianchaomaster1]# chown -R 1000.1000 /data/v2

[root@xianchaomaster1]# kubectl apply -f jenkins-deployment.yaml

#查看pod是否创建成功:

[root@xianchaomaster1]# kubectl get pods -n jenkins-k8s

显示如下，说明部署成功了：

NAME READY STATUS RESTARTS AGE

jenkins-74b4c59549-6xpnk 1/1 Running 0 66

jenkins-deployment.yaml文件内容如下：

kind: Deployment

apiVersion: apps/v1

metadata:

name: jenkins

namespace: jenkins-k8s

spec:

replicas: 1

selector:

matchLabels:

app: jenkins

template:

metadata:

labels:

app: jenkins

spec:

serviceAccount: jenkins-k8s-sa

containers:

- name: jenkins

image: jenkins/jenkins:2.394

imagePullPolicy: IfNotPresent

ports:

- containerPort: 8080

name: web

protocol: TCP

- containerPort: 50000

name: agent

protocol: TCP

resources:

limits:

cpu: 1000m

memory: 1Gi

requests:

cpu: 500m

memory: 512Mi

livenessProbe:

httpGet:

path: /login

port: 8080

initialDelaySeconds: 60

timeoutSeconds: 5

failureThreshold: 12

readinessProbe:

httpGet:

path: /login

port: 8080

initialDelaySeconds: 60

timeoutSeconds: 5

failureThreshold: 12

volumeMounts:

- name: jenkins-volume

subPath: jenkins-home

mountPath: /var/jenkins_home

volumes:

- name: jenkins-volume

persistentVolumeClaim:

claimName: jenkins-k8s-pvc

（7）把jenkins前端加上service，提供外部网络访问

#更新资源清单文件

[root@xianchaomaster1]# kubectl apply -f jenkins-service.yaml

#查看service是否创建成功

[root@xianchaomaster1]# kubectl get svc -n jenkins-k8s

#通过上面可以看到service的8080端口在物理机映射的端口是30002

jenkins-service.yaml文件内容如下：

apiVersion: v1

kind: Service

metadata:

name: jenkins-service

namespace: jenkins-k8s

labels:

app: jenkins

spec:

selector:

app: jenkins

type: NodePort

ports:

- name: web

port: 8080

targetPort: web

nodePort: 30002

- name: agent

port: 50000

targetPort: agent

5.2 配置Jenkins

在浏览器访问jenkins的web界面：

http://192.168.40.180:30002/login?from=%2F

5.2.1 获取管理员密码

在nfs服务端，也就是我们的master1节点获取密码：

[root@xianchaomaster1 ~]# cat /data/v2/jenkins-home/secrets/initialAdminPassword

把上面获取到的密码拷贝到上面管理员密码下的方框里

点击继续，出现如下界面

5.2.2 安装插件

安装推荐的插件

插件安装好之后显示如下

5.2.3 创建第一个管理员用户

用户名和密码都设置成admin，线上环境需要设置成复杂的密码

修改好之后点击保存并完成，出现如下界面

点击保存并完成，出现如下界面

点击开始使用Jenkins

5.3 测试jenkins的CI/CD

5.3.1 在Jenkins中安装kubernetes插件

（1）在jenkins中安装k8s插件

Manage Jnekins------>插件管理------>可选插件------>搜索kubernetes------>出现如下

选中kubernetes之后------>点击下面的直接安装------>安装之后选择重新启动jenkins---> http://192.168.40.180:30002/restart-->重启之后登陆jenkins，插件即可生效

（2）安装blueocean插件

Manage Jnekins------>插件管理------>可选插件------>搜索blueocean------>出现如下

选中BlueOcean之后------>点击下面的直接安装------>安装之后选择重新启动jenkins---> http://192.168.40.180:30002/restart-->重启之后登陆jenkins，插件即可生效

5.3.2 配置jenkins连接到我们存在的k8s集群

（1）访问http://192.168.40.180:30002/configureClouds/

新增一个云,在下拉菜单中选择kubernets并添加

（2）填写云kubernetes配置内容

名称： kubernetes

Kubernetes地址：

https://192.168.40.180:6443

（3）测试jenkins和k8s是否可以通信

Kubernetes名称空间： jenkins-k8s-sa

点击连接测试，如果显示Connected to Kubernetes v1.23.1，说明测试成功，Jenkins可以和k8s进行通信

Jenkins地址:

http://jenkins-service.jenkins-k8s.svc.cluster.local:8080

5.3.3 配置pod-template

（1）配置pod template

添加Pod模板

点击Pod Template details

点击容器列表下的添加容器

名称：jnlp

Docker镜像：jenkins-slave-latest:v1

给上面的pod template添加卷

/var/run/docker.sock

/root/.kube

/home/jenkins/.kube

[root@xianchaomaster1 ~]# scp -r /root/.kube/ xianchaonode1:/root/

在Service Account处输入jenkins-k8s-sa，这个sa就是我们最开始安装jenkins时的sa

上面配置好之后，Apply(应用)------>Save(保存)

5.3.4 添加自己的dockerhub凭据

首页------>系统管理àManage Credentials（管理凭据）------>点击Stores scoped to Jenkins下的第一行jenkins后的全局，显示如下

点击添加凭据，出现如下------>

username：xianchao

password：1989*****

ID：dockerhub

描述：随意写一段描述即可

上面改好之后选择确定即可

5.3.5 测试通过Jenkins部署应用发布到k8s开发环境、测试环境、生产环境

开发提交代码到代码仓库gitlab-àjenkins检测到代码更新-à调用k8s api在k8s中创建jenkins slave pod：

Jenkins slave pod拉取代码---à通过maven把拉取的代码进行构建成war包或者jar包--->上传代码到Sonarqube，进行静态代码扫描- -->基于war包构建docker image-->把镜像上传到harbor镜像仓库-->基于镜像部署应用到开发环境-->部署应用到测试环境--->部署应用到生产环境。

#下面在Pipeline Script输入的脚本内容在课件里面，大家可以找到

jenkins-pipeline-script.txt文件，复制里面内容到Pipeline Script

在k8s的控制节点创建名称空间：

[root@xianchaomaster1 ~]# kubectl create ns devlopment

[root@xianchaomaster1 ~]# kubectl create ns production

[root@xianchaomaster1 ~]# kubectl create ns qatest

回到首页：

开始创建一个新任务------>

输入一个任务名称：jenkins-variable-test-deploy------>

流水线------>

确定------>

在Pipeline script处输入如下内容

node('testhan') {

stage('Clone') {

echo "1.Clone Stage"

git url: "https://github.com/luckylucky421/jenkins-sample.git"

script {

build_tag = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()

}

stage('Test') {

echo "2.Test Stage"

}

stage('Build') {

echo "3.Build Docker Image Stage"

sh "docker build -t xianchao/jenkins-demo:${build_tag} ."

}

stage('Push') {

echo "4.Push Docker Image Stage"

withCredentials([usernamePassword(credentialsId: 'dockerhub', passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {

sh "docker login -u ${dockerHubUser} -p ${dockerHubPassword}"

sh "docker push xianchao/jenkins-demo:${build_tag}"

}

stage('Deploy to dev') {

echo "5. Deploy DEV"

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-dev.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-dev.yaml"

// sh "bash running-devlopment.sh"

sh "kubectl apply -f k8s-dev.yaml --validate=false"

}

stage('Promote to qa') {

def userInput = input(

id: 'userInput',

message: 'Promote to qa?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-qa.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-qa.yaml"

// sh "bash running-qa.sh"

sh "kubectl apply -f k8s-qa.yaml --validate=false"

sh "sleep 6"

sh "kubectl get pods -n qatest"

} else {

//exit

}

stage('Promote to pro') {

def userInput = input(

id: 'userInput',

message: 'Promote to pro?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-prod.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-prod.yaml"

// sh "bash running-production.sh"

sh "cat k8s-prod.yaml"

sh "kubectl apply -f k8s-prod.yaml --record --validate=false"

}

应用------>保存------>立即构建,在#1的Console Output可看到构建过程：

#在Console Output如果看到如下：

点击Input requested

点击继续

#上面可以看到已经把应用部署到dev环境了

#点击Input requested

点击继续

#通过上面可以看到把应用部署到了pro环境了

#验证是否在devlopment和production名称空间下有应用

[root@xianchaomaster1 ~]# kubectl get pods -n production

NAME READY STATUS RESTARTS AGE

jenkins-demo-784885d9c9-w6zlt 1/1 Running 0 60s

[root@xianchaomaster1 ~]# kubectl get pods -n devlopment

NAME READY STATUS RESTARTS AGE

jenkins-demo-784885d9c9-9wkcx 1/1 Running 0 5m38s

[root@xianchaomaster1 ~]# kubectl get pods -n qatest

NAME READY STATUS RESTARTS AGE

jenkins-demo-784885d9c9-wshpj 1/1 Running 0 3m56s

#通过上面可以看到jenkins对接k8s，可以把应用发布到k8s集群的开发、测试、生产环境了。

6. 基于Jenkins+k8s+Git+harbor构建DevOps容器云平台

需要有一台harbor服务，我的harbor安装在了192.168.40.182机器上

1.添加凭据

首页------>系统管理à管理凭据------>点击Stores scoped to Jenkins下的第一行jenkins，显示如下

点击这个全局凭据,出现如下------>

点击左侧的添加凭据，出现如下------>

username：admin

password：Harbor12345

ID：dockerharbor

描述：随意

上面改好之后选择确定即可

2.编写jenkins pipeline

因为镜像要上传到harbor私有镜像仓库，所以需要在harbor上创建一个项目，项目名称是jenkins-demo，如下所示：

上面项目创建成功之后，执行如下步骤：

#下面在Pipeline Script输入的脚本内容在课件里面，大家可以找到

jenkins-pipeline-harbor-script.txt文件，复制里面内容到Pipeline Script

新建一个任务------>输入一个任务名称处输入jenkins-harbor------>流水线------>确定------>在Pipeline script处输入如下内容

node('testhan') {

stage('Clone') {

echo "1.Clone Stage"

git url: "https://github.com/luckylucky421/jenkins-sample.git"

script {

build_tag = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()

}

stage('Test') {

echo "2.Test Stage"

}

stage('Build') {

echo "3.Build Docker Image Stage"

sh "docker build -t 192.168.40.182/jenkins-demo/jenkins-demo:${build_tag} ."

}

stage('Push') {

echo "4.Push Docker Image Stage"

withCredentials([usernamePassword(credentialsId: 'dockerharbor', passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {

sh "docker login 192.168.40.182 -u ${dockerHubUser} -p ${dockerHubPassword}"

sh "docker push 192.168.40.182/jenkins-demo/jenkins-demo:${build_tag}"

}

stage('Deploy to dev') {

echo "5. Deploy DEV"

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-dev-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-dev-harbor.yaml"

// sh "bash running-devlopment.sh"

sh "kubectl apply -f k8s-dev-harbor.yaml --validate=false"

}

stage('Promote to qa') {

def userInput = input(

id: 'userInput',

message: 'Promote to qa?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-qa-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-qa-harbor.yaml"

// sh "bash running-qa.sh"

sh "kubectl apply -f k8s-qa-harbor.yaml --validate=false"

sh "sleep 6"

sh "kubectl get pods -n qatest"

} else {

//exit

}

stage('Promote to pro') {

def userInput = input(

id: 'userInput',

message: 'Promote to pro?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-prod-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-prod-harbor.yaml"

// sh "bash running-production.sh"

sh "cat k8s-prod-harbor.yaml"

sh "kubectl apply -f k8s-prod-harbor.yaml --record --validate=false"

}

应用------>保存------>立即构建即可,打开blue ocean会看到如下流程，可以手动点击确认

Jenkins实现k8s应用按照指定版本回滚

回到首页：

新建一个任务------>输入一个任务名称处输入jenkins-variable-test-deploy-rollout------>流水线------>确定------>在Pipeline script处输入如下内容

node('testhan') {

stage('git clone') {

git url: "https://github.com/luckylucky421/jenkins-rollout"

sh "ls -al"

sh "pwd"

}

stage('select env') {

def envInput = input(

id: 'envInput',

message: 'Choose a deploy environment',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "devlopment\nqatest\nproduction",

name: 'Env'

]

)

echo "This is a deploy step to ${envInput}"

sh "sed -i 's/<namespace>/${envInput}/' getVersion.sh"

sh "sed -i 's/<namespace>/${envInput}/' rollout.sh"

sh "bash getVersion.sh"

// env.WORKSPACE = pwd()

// def version = readFile "${env.WORKSPACE}/version.csv"

// println version

}

stage('select version') {

env.WORKSPACE = pwd()

def version = readFile "${env.WORKSPACE}/version.csv"

println version

def userInput = input(id: 'userInput',

message: '选择回滚版本',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "$version\n",

name: 'Version'

]

)

sh "sed -i 's/<version>/${userInput}/' rollout.sh"

}

stage('rollout deploy') {

sh "bash rollout.sh"

}

点击应用->保存-立即构建

7. Jenkins Pipeline语法介绍

7.1 Jenkins Pipeline介绍

Jenkins pipeline （流水线）是一套运行于jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排与可视化。它把持续提交流水线（Continuous Delivery Pipeline）的任务集成到Jenkins中。

pipeline 是jenkins2.X 最核心的特性，帮助jenkins 实现从CI到CD与DevOps的转变。

持续提交流水线（Continuous Delivery Pipeline）会经历一个复杂的过程：从版本控制、向用户和客户提交软件，软件的每次变更（提交代码到仓库）到软件发布（Release）。这个过程包括以一种可靠并可重复的方式构建软件，以及通过多个测试和部署阶段来开发构建好的软件（称为Build）。

总结：

1.Jenkins Pipeline是一组插件，让Jenkins可以实现持续交付管道的落地和实施。
2.持续交付管道(CD Pipeline)是将软件从版本控制阶段到交付给用户或客户的完
整过程的自动化表现。
3.软件的每一次更改（提交到源代码管理系统）都要经过一个复杂的过程才能被发布。

7.2 为什么用Jenkins Pipeline？

本质上，Jenkins 是一个自动化引擎，它支持许多自动模式。 Pipeline向Jenkins中添加了一组强大的工具, 支持简单的CI到全面的CD pipeline。通过对一系列的相关任务进行建模, 用户可以利用pipeline的很多特性:

1、代码：Pipeline以代码的形式实现，使团队能够编辑，审查和迭代其CD流程。
    2、可持续性：Jenkins重启或者中断后都不会影响Pipeline Job。
    3、停顿：Pipeline可以选择停止并等待人工输入或批准，然后再继续Pipeline运行。
    4、多功能：Pipeline支持现实复杂的CD要求，包括循环和并行执行工作的能力。
    5、可扩展：Pipeline插件支持其DSL的自定义扩展以及与其他插件集成的多个选项。

DSL 是什么？

DSL 其实是 Domain Specific Language 的缩写，中文翻译为领域特定语言（下简称 DSL）；而与 DSL相对的就是GPL，这里的GPL并不是我们知道的开源许可证，而是 General Purpose Language的简称，即通用编程语言，也就是我们非常熟悉的 Objective-C、Java、Python 以及 C 语言等等。

7.3 Jenkins pipeline 入门

pipeline脚本是由groovy 语言实现的

但无需专门学习 groovy

pipeline支持两种语法：

-Declarative：声明式

-Scripted pipeline ：脚本式

声明式pipeline语法：

官网：

https://www.jenkins.io/doc/book/pipeline/syntax/

声明式语法包括以下核心流程：

1.pipeline : 声明其内容为一个声明式的pipeline脚本
2.agent: 执行节点（job运行的slave或者master节点）
3.stages: 阶段集合，包裹所有的阶段（例如：打包，部署等各个阶段）
4.stage: 阶段，被stages包裹，一个stages可以有多个stage
5.steps: 步骤,为每个阶段的最小执行单元,被stage包裹
6.post: 执行构建后的操作，根据构建结果来执行对应的操作

根据上面流程创建一个简单的pipeline

pipeline{

agent any

stages{

stage("This is first stage"){

steps("This is first step"){

echo "I am xianchao"

}

post{

always{

echo "The process is ending"

}

Pipeline：

作用域：应用于全局最外层，表明该脚本为声明式pipeline
是否必须：必须

agent：

作用域：可用在全局与stage内

agent表明此pipeline在哪个节点上执行
是否必须：是
参数：any,none, label, node,docker,dockerfile

agent any

#运行在任意的可用节点上

agent none

#全局不指定运行节点，由各自stage来决定

agent { label 'master' }

#运行在指定标签的机器上,具体标签名称由agent配置决定

agent {

node {

label 'my-defined-label'

customWorkspace 'xxxxxxx'

}

#node{ label 'master'} 和agent { label 'master' }一样，但是node可以扩展节点信息，允许额外的选项 (比如 customWorkspace )。

agent { docker 'python' }

#使用指定的容器运行流水线

如：

agent {

docker {

image 'maven:3-alpine'

label 'my-defined-label'

args '-v /tmp:/tmp'

}

#定义此参数时，执行Pipeline或stage时会动态的在具有label 'my-defined-label'标签的node提供docker节点去执行Pipelines。 docker还可以接受一个args，直接传递给docker run调用。

agent {

// Equivalent to "docker build -f Dockerfile.build --build-arg version=1.0.2 ./build/

dockerfile {

filename 'Dockerfile.build'

dir 'build'

label 'my-defined-label'

additionalBuildArgs '--build-arg version=1.0.2'

}

7.4 Pipeline 声明式语法Declarative

7.4.1 environment

environment指令指定一系列键值对，这些键值对将被定义为所有step或stage-specific step的环境变量，具体取决于environment指令在Pipeline中的位置。该指令支持一种特殊的方法credentials()，可以通过其在Jenkins环境中的标识符来访问预定义的凭据。对于类型为“Secret Text”的凭据，该 credentials()方法将确保指定的环境变量包含Secret Text内容；对于“标准用户名和密码”类型的凭证，指定的环境变量将被设置为username:password并且将自动定义两个附加的环境变量：MYVARNAME_USR和MYVARNAME_PSW。

pipeline {

agent any

environment {

CC = 'clang'

}

stages {

stage('Example') {

steps {

sh 'printenv'

}

7.4.2 options

options指令允许在Pipeline本身内配置Pipeline专用选项。Pipeline本身提供了许多选项，例如buildDiscarder，但它们也可能由插件提供，例如 timestamps。

可用选项

buildDiscarder： pipeline保持构建的最大个数。用于保存Pipeline最近几次运行的数据，例如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }
disableConcurrentBuilds： 不允许并行执行Pipeline,可用于防止同时访问共享资源等。例如：options { disableConcurrentBuilds() }
skipDefaultCheckout：跳过默认设置的代码check out。例如：options { skipDefaultCheckout() }
skipStagesAfterUnstable： 一旦构建状态进入了“Unstable”状态，就跳过此stage。例如：options { skipStagesAfterUnstable() }
timeout： 设置Pipeline运行的超时时间，超过超时时间，job会自动被终止，例如：options { timeout(time: 1, unit: 'HOURS') }
retry： 失败后，重试整个Pipeline的次数。例如：options { retry(3) }
timestamps： 预定义由Pipeline生成的所有控制台输出时间。例如：options { timestamps() }

pipeline {

agent any

options {

timeout(time: 1, unit: 'HOURS')

}

stages {

stage('Example') {

steps {

echo 'Hello World'

}

7.4.3 parameters

parameters指令提供用户在触发Pipeline时的参数列表。这些参数值通过该params对象可用于Pipeline stage中，具体用法如下：

作用域：被最外层pipeline所包裹，并且只能出现一次，参数可被全局使用

好处：使用parameters好处是能够使参数也变成code,达到pipeline as code，pipeline中设置的参数会自动在job构建的时候生成，形成参数化构建

可用参数
string
A parameter of a string type, for example: parameters { string(name: 'DEPLOY_ENV', defaultValue: 'staging', description: '') }
booleanParam
A boolean parameter, for example: parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }
　　目前只支持[booleanParam, choice, credentials, file, text, password, run, string]这几种参数类型，其他高级参数化类型还需等待社区支持。

pipeline{

agent any

parameters {

string(name: 'xianchao', defaultValue: 'my name is xianchao', description: 'My name is xiancaho')

booleanParam(name: 'luckylucky421302', defaultValue: true, description: 'This is my wechat')

}

stages{

stage("stage1"){

steps{

echo "$xianchao"

echo "$luckylucky421302"

}

开始构建

控制台输出观察构建结果：

7.4.4 triggers

triggers指令定义了Pipeline自动化触发的方式。目前有三个可用的触发器：cron和pollSCM和upstream。

用域：被pipeline包裹，在符合条件下自动触发pipeline

cron
　　接受一个cron风格的字符串来定义Pipeline触发的时间间隔，例如：

triggers { cron('H 4/* 0 0 1-5') }
pollSCM

　　接受一个cron风格的字符串来定义Jenkins检查SCM源更改的常规间隔。如果存在新的更改，则Pipeline将被重新触发。例如：triggers { pollSCM('H 4/* 0 0 1-5') }

pipeline {

agent any

triggers {

cron('H 4/* 0 0 1-5')

}

stages {

stage('Example') {

steps {

echo 'Hello World'

}

7.4.5 tools

通过tools可自动安装工具，并放置环境变量到PATH。如果agent none，这将被忽略。

Supported Tools(Global Tool Configuration)
maven
jdk
gradle

pipeline {

agent any

tools {

#工具名称必须在Jenkins 管理Jenkins → 全局工具配置中预配置。

maven 'apache-maven-3.0.1'

}

stages {

stage('Example') {

steps {

sh 'mvn --version'

}

# The tool name must be pre-configured in Jenkins under Manage Jenkins → Global Tool Configuration

7.4.6 input

stage 的 input 指令允许你使用 input step提示输入。在应用了 options 后，进入 stage 的 agent 或评估 when 条件前，stage 将暂停。如果 input 被批准, stage 将会继续。作为 input 提交的一部分的任何参数都将在环境中用于其他 stage

配置项

message

必需的。这将在用户提交 input 时呈现给用户。

input 的可选标识符，默认为 stage 名称。

`input`表单上的"ok" 按钮的可选文本。

submitter

可选的以逗号分隔的用户列表或允许提交 input 的外部组名。默认允许任何用户。

submitterParameter

环境变量的可选名称。如果存在，用 submitter 名称设置。

parameters

提示提交者提供的一个可选的参数列表。

pipeline {

agent any

stages {

stage('Example') {

input {

message "Should we continue?"

ok "Yes, we should."

submitter "xianchao,lucky"

parameters {

string(name: 'PERSON', defaultValue: 'xianchao', description: 'Who should I say hello to?')

}

steps {

echo "Hello, ${PERSON}, nice to meet you."

}

7.4.7 when

when指令允许Pipeline根据给定的条件确定是否执行该阶段。该when指令必须至少包含一个条件。如果when指令包含多个条件，则所有子条件必须为stage执行返回true。这与子条件嵌套在一个allOf条件中相同（见下面的例子）。
更复杂的条件结构可使用嵌套条件建：not，allOf或anyOf。嵌套条件可以嵌套到任意深度。

内置条件

branch
　　　　当正在构建的分支与给出的分支模式匹配时执行，例如：when { branch 'master' }。请注意，这仅适用于多分支Pipeline。
environment
　　　　当指定的环境变量设置为给定值时执行，例如： when { environment name: 'DEPLOY_TO', value: 'production' }
expression
　　　　当指定的Groovy表达式求值为true时执行，例如： when { expression { return params.DEBUG_BUILD } }
not
　　　　当嵌套条件为false时执行。必须包含一个条件。例如：when { not { branch 'master' } }
allOf
　　　　当所有嵌套条件都为真时执行。必须至少包含一个条件。例如：when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }
anyOf
　　　　当至少一个嵌套条件为真时执行。必须至少包含一个条件。例如：when { anyOf { branch 'master'; branch 'staging' } }

pipeline {

agent any

stages {

stage('Example Build') {

steps {

echo 'Hello World'

}

stage('Example Deploy') {

when {

allOf {

branch 'production'

environment name: 'DEPLOY_TO', value: 'production'

}

steps {

echo 'Deploying'

}

7.4.8 Parallel

Declarative Pipeline近期新增了对并行嵌套stage的支持，对耗时长，相互不存在依赖的stage可以使用此方式提升运行效率。除了parallel stage，单个parallel里的多个step也可以使用并行的方式运行。

pipeline {

agent any

stages {

stage('Non-Parallel Stage') {

steps {

echo 'This stage will be executed first.'

}

stage('Parallel Stage') {

when {

branch 'master'

}

parallel {

stage('Branch A') {

agent {

label "for-branch-a"

}

steps {

echo "On Branch A"

}

stage('Branch B') {

agent {

label "for-branch-b"

}

steps {

echo "On Branch B"

}

7.5 Pipeline Scripted语法

Groovy脚本不一定适合所有使用者，因此jenkins创建了Declarative pipeline，为编写Jenkins管道提供了一种更简单、更有主见的语法。但是由于脚本化的pipeline是基于groovy的一种DSL语言，所以与Declarative pipeline相比为jenkins用户提供了更巨大的灵活性和可扩展性。

1.流程控制

pipeline脚本同其它脚本语言一样，从上至下顺序执行，它的流程控制取决于Groovy表达式，如if/else条件语句，举例如下：

node {

stage('Example') {

if (env.BRANCH_NAME == 'master') {

echo 'I only execute on the master branch'

} else {

echo 'I execute elsewhere'

}

2.Declarative pipeline和Scripted pipeline的比较

共同点：
　　两者都是pipeline代码的持久实现，都能够使用pipeline内置的插件或者插件提供的stage，两者都可以利用共享库扩展。
区别：
　　两者不同之处在于语法和灵活性。Declarative pipeline对用户来说，语法更严格，有固定的组织结构，更容易生成代码段，使其成为用户更理想的选择。但是Scripted pipeline更加灵活，因为Groovy本身只能对结构和语法进行限制，对于更复杂的pipeline来说，用户可以根据自己的业务进行灵活的实现和扩展。

8、jenkins+k8s+harbor实现DevOps

1.添加凭据

首页------>系统管理à管理凭据------>点击Stores scoped to Jenkins下的第一行jenkins，显示如下

点击这个全局凭据,出现如下------>

点击左侧的添加凭据，出现如下------>

username：admin

password：Harbor12345

ID：dockerharbor

描述：随意

上面改好之后选择确定即可

2.编写jenkins pipeline

因为镜像要上传到harbor私有镜像仓库，所以需要在harbor上创建一个项目，项目名称是jenkins-demo，如下所示：

上面项目创建成功之后，执行如下步骤：

新建一个任务------>输入一个任务名称处输入jenkins-harbor------>流水线------>确定------>在Pipeline script处输入如下内容

node('testhan') {

stage('Clone') {

echo "1.Clone Stage"

git url: "https://github.com/luckylucky421/jenkins-sample.git"

script {

build_tag = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()

}

stage('Test') {

echo "2.Test Stage"

}

stage('Build') {

echo "3.Build Docker Image Stage"

sh "docker build -t 192.168.40.132/jenkins-demo/jenkins-demo:${build_tag} ."

}

stage('Push') {

echo "4.Push Docker Image Stage"

withCredentials([usernamePassword(credentialsId: 'dockerharbor', passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {

sh "docker login 192.168.40.132 -u ${dockerHubUser} -p ${dockerHubPassword}"

sh "docker push 192.168.40.132/jenkins-demo/jenkins-demo:${build_tag}"

}

stage('Deploy to dev') {

echo "5. Deploy DEV"

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-dev-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-dev-harbor.yaml"

// sh "bash running-devlopment.sh"

sh "kubectl apply -f k8s-dev-harbor.yaml --validate=false"

}

stage('Promote to qa') {

def userInput = input(

id: 'userInput',

message: 'Promote to qa?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-qa-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-qa-harbor.yaml"

// sh "bash running-qa.sh"

sh "kubectl apply -f k8s-qa-harbor.yaml --validate=false"

sh "sleep 6"

sh "kubectl get pods -n qatest"

} else {

//exit

}

stage('Promote to pro') {

def userInput = input(

id: 'userInput',

message: 'Promote to pro?',

parameters: [

[

$class: 'ChoiceParameterDefinition',

choices: "YES\nNO",

name: 'Env'

]

)

echo "This is a deploy step to ${userInput}"

if (userInput == "YES") {

sh "sed -i 's/<BUILD_TAG>/${build_tag}/' k8s-prod-harbor.yaml"

sh "sed -i 's/<BRANCH_NAME>/${env.BRANCH_NAME}/' k8s-prod-harbor.yaml"

// sh "bash running-production.sh"

sh "cat k8s-prod-harbor.yaml"

sh "kubectl apply -f k8s-prod-harbor.yaml --record --validate=false"

}

应用------>保存------>立即构建即可,打开blue ocean会看到如下流程，可以手动点击确认

9、Jenkins接入Sonarqube

1.在192.168.40.180上安装sonarqube：

docker run -d --name postgres10 -p 5432:5432 -e POSTGRES_USER=sonar -e POSTGRES_PASSWORD=123456 postgres

docker run -d --name sonarqube7.9 -p 9000:9000 --link postgres10 -e SONARQUBE_JDBC_URL=jdbc:postgresql://postgres10:5432/sonar -e SONARQUBE_JDBC_USERNAME=sonar -e SONARQUBE_JDBC_PASSWORD=123456 -v sonarqube_conf:/opt/sonarqube/conf -v sonarqube_extensions:/opt/sonarqube/extensions -v sonarqube_logs:/opt/sonarqube/logs -v sonarqube_data:/opt/sonarqube/data sonarqube

在jenkins中安装sonarqube插件：

系统管理->插件管理->可选插件：搜索sonar，找到Sonarqube Scanner

选择Sonarqube Scanner直接安装，安装之后重启jenkins即可

在sonarqube的web界面创建一个token：

选择Generate出现如下：

把copy后面的一串token记录下来：

2b91be9d40a28385d8b2f61b0fc0a52efd5abf97

回到k8s的master1节点：

cd /root/microservic-test

mvn sonar:sonar -Dsonar.host.url=http://192.168.40.181:9000 -Dsonar.login=2b91be9d40a28385d8b2f61b0fc0a52efd5abf97

这样就可以把代码上传到sonarqube了

10、Jenkins+k8s+nexus+gitlab+harbor+sonarqube+springloud构建DevOps

11.1 安装sonarqube

在192.168.40.131上操作：

docker run -d --name postgres10 -p 5432:5432 -e POSTGRES_USER=sonar -e POSTGRES_PASSWORD=123456 postgres

在jenkins中安装sonarqube插件：

系统管理->插件管理->可选插件：搜索sonar，找到Sonarqube Scanner->选择Sonarqube Scanner直接安装

安装之后重启jenkins即可

在sonarqube的web界面创建一个token：

选择Generate出现如下：

把copy后面的一串token记录下来：

2b91be9d40a28385d8b2f61b0fc0a52efd5abf97

回到k8s的控制节点：

cd /root/microservic-test

mvn sonar:sonar -Dsonar.host.url=http://192.168.40.131:9000 -Dsonar.login=2b91be9d40a28385d8b2f61b0fc0a52efd5abf97

这样就可以把代码上传到sonarqube了

注意：开发写的代码目前不支持这个版本的sonarqube，所以这个上传到sonarqube是有问题的，会报错版本不支持，结果大家可以不用看，会用就可以

11.2 Jenkins界面添加harbor凭据

需要自己找机器安装好harbor，harbor机器ip：192.168.40.132

1.添加凭据

首页------>系统管理à管理凭据------>点击Stores scoped to Jenkins下的第一行jenkins，显示如下

点击这个全局凭据,出现如下------>

点击左侧的添加凭据，出现如下------>

username：admin

password：Harbor12345

ID：dockerharbor

描述：随意

上面改好之后选择确定即可

11.3 安装nexus

概念：

Nexus服务器是一个代码包管理的服务器，可以理解 Nexus 服务器是一个巨大的 Library 仓库。Nexus 可以支持管理的工具包括 Maven ， npm 等，对于 JAVA 开发来说，只要用到 Maven 管理就可以了。

Nexus服务器作用：因为传统的中央仓库在国外，其地理位置比较远，下载速度比较缓慢。因此，当公司开发人员数量越来越多时，如果不架设一台自己的Nexus服务器，会产生大量的流量阻塞带宽，并且在出现一些不可抗原因（光缆被挖断）导致无法连接到中央仓库时，开发就会因为无法下载相关依赖包而进度停滞。因此在本地环境部署一台私有的Nexus服务器来缓存所有依赖包，并且将公司内部开发的私有包也部署上去，方便其他开发人员下载，是非常有必要的。因为 Nexus 有权限控制，因此外部人员是无法得到公司内部开发的项目包的。

下面将介绍如何将自己的maven构件发布到nexus私服上呢？

在192.168.40.133上安装：

docker run -d -p 8081:8081 -p 8082:8082 -p 8083:8083 -v /etc/localtime:/etc/localtime --name nexus3 sonatype/nexus3

在日志中，会看到一条消息： Started Sonatype Nexus OSS 3.20.1-01 这意味着Nexus Repository Manager可以使用了。现在转到浏览器并打开

http://your-ip-addr:8081

第一步：

1、在 pom.xml 文件中声明发布的宿主仓库和 release 版本发布的仓库。

<distributionManagement>

<repository>

<id>releases</id>

<name>nexus-releases</name>

<url>http://192.168.40.133:8081/repository/maven-releases/</url>

</repository>

<snapshotRepository>

<id>snapshots</id>

<name>nexus-snapshots</name>

<url>http://192.168.40.133:8081/repository/maven-snapshots/</url>

</snapshotRepository>

</distributionManagement>

第二步：在 settings.xml 文件中配置
由于用 Maven 分发构件到远程仓库需要认证，须要在~/.m2/settings.xml或者中加入验证信息：

<servers>

<server>

<id>public</id>

<username>admin</username>

<password>123456</password>

</server>

<server>

<id>releases</id>

<username>admin</username>

<password>123456</password>

</server>

<server>

<id>snapshots</id>

<username>admin</username>

<password>123456</password>

</server>

</servers>

注意： settings.xml 中 server 元素下 id 的值必须与 POM 中 repository 或 snapshotRepository 下 id 的值完全一致。　

11.4 安装gitlab

在192.168.40.135上安装

docker run -d -p 443:443 -p 80:80 -p 222:22 --name gitlab --restart always -v /home/gitlab/config:/etc/gitlab -v /home/gitlab/logs:/var/log/gitlab -v /home/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce gitlab/gitlab-ce

改配置：

cat /home/gitlab/config/gitlab.rb

增加如下三行：

external_url 'http://192.168.40.135'

gitlab_rails['gitlab_ssh_host'] = '192.168.40.135'

gitlab_rails['gitlab_shell_ssh_port'] = 222

重启docker：

docker restart gitlab

登录192.168.40.135即可登录：

第一次登录注册账号密码之后，报错如下：

Your account is pending approval from your GitLab administrator and hence bl

可通过如下方法实现：

[root@xianchaomaster1 ~]# docker exec -it gitlab sh

irb(main):004:0> u=User.where(id:1).first

=> #<User id:1 @root>

irb(main):005:0> u.password='12345678'

=> "12345678"

irb(main):006:0> u.password_confirmation='12345678'

=> "12345678"

irb(main):007:0> u.save!

=> true

再次登录192.168.40.135

用户名是root

密码是12345678

# -d：后台运行

# -p：将容器内部端口向外映射

# --name：命名容器名称

# -v：将容器内数据文件夹或者日志、配置等文件夹挂载到宿主机指定目录

在Jenkins安装git插件

系统管理-插件管理-可选插件-搜索git安装即可

在Jenkins上添加gitlab凭据

Jenkins-凭据-全局凭据

在gitlab上新建项目：

创建密钥对：

[root@localhost ~]# ssh-keygen -t rsa

#一路回车

上传密钥：

[root@localhost ~]# cat ~/.ssh/id_rsa.pub #查看公钥

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8KZUe+PJykjZzJherolD+vXsw8/aL3OMyX/x1HF6Rz73dNZFCERQxA6t/9ahRrya8iY7IIloLjzi5iX666mzYI3fAEq1Ga3Dz2MWqEeWZGdbNKvL9lf0qTy0aLBIRe2fnQwrkrP2YakiqzDRpyjQgr05VkrnF5bVLX2HCHuC2GXwnHUAuJEkjb1f9vmII7YP0BmYDMOMpricQ1LeFnQ9cc2ZvPw6212yiXOrbhrbiMtjCYTPoRA8EIfmRAPcNcVl4GT3fZxAVocDk70rA/tEWCgu+zzFFH+aWhaIXMdkC70FEWLD28AxLWwwKj22KA9ezqp0eoxofzU3tSCIymVU9 root@localhost.localdomain

提交本地代码到gitlab:

[root@localhost ~]# yum install git -y

[root@localhost ~]# unzip microservic-test.zip

[root@localhost ~]# cd microservic-test

[root@localhost microservic-test]# git init #建仓

[root@localhost microservic-test]# git add * #把当前文件夹所有代码提交

[root@localhost microservic-test]# git commit -m "add microservic-test" #代码提交到缓冲区

[root@localhost microservic-test]# git remote add origin http://192.168.40.135/root/microservic-test.git

#代码提交到远程仓库

[root@localhost microservic-test]# git push -u origin master

#最后一步push推送过去,push的时候，会让你输入账号和密码，这里的用户名和密码就是gitlab上注册的用户了

回到gitlab首页，可以看到，已经有项目了：

11.5 Jenkins+k8s+nexus+sonarqube+harbor+gitlab构建DevOps

jenkins-jnlp-v2.tar.gz这个压缩包封装的镜像带有mvn命令

[root@xianchaonode1 ~]# docker load -i jenkins-jnlp-v2.tar.gz

在http://192.168.40.180:30002/configureClouds/，把Container Template镜像改成jenkins-jnlp-v2.tar.gz压缩包解压之后的镜像xianchao/jenkins-jnlp:v2

修改gitlab上portal.yaml文件：

把image镜像变成：192.168.40.132/microservice/jenkins-demo:v1

注意：microservice需要在harbor里提前创建这个仓库

打开Jenkins，新建流水线，流水线名字是mvn-gitlab-harbor-springcloud

在Pipeline Script处输入如下内容：

node('testhan') {

stage('Clone') {

echo "1.Clone Stage"

git credentialsId: 'gitlab', url: 'http://192.168.40.135/root/microservic-test.git '

script {

build_tag = sh(returnStdout: true, script: 'git rev-parse --shortHEAD').trim()

}

stage('Test') {

echo "2.Test Stage"

}

stage('mvn') {

sh "mvn clean package -D maven.test.skip=true"

}

stage('Build') {

echo "3.Build Docker Image Stage"

sh "cd /home/jenkins/agent/workspace/mvn-gitlab-harbor-springcloud/portal-service"

sh "docker build --tag 192.168.40.132/microservice/jenkins-demo:v1 /home/jenkins/agent/workspace/mvn-gitlab-harbor-springcloud/portal-service/"

}

stage('Push') {

echo "4.Push Docker Image Stage"

withCredentials([usernamePassword(credentialsId: 'dockerharbor',passwordVariable: 'dockerHubPassword', usernameVariable: 'dockerHubUser')]) {

sh "docker login 192.168.40.132 -u ${dockerHubUser} -p ${dockerHubPassword}"

sh "docker push 192.168.40.132/microservice/jenkins-demo:v1"

}

stage('Promoteto pro') {

sh "kubectl apply -f /home/jenkins/agent/workspace/mvn-gitlab-harbor-springcloud/k8s/portal.yaml"

}

立即构建即可

注意事项：

url: http://192.168.40.135/root/microservic-test.git

开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

修改固态硬盘的物理序列号_有了三星固态盘魔术师软件，再也不怕买到假货次品的三星固态盘了...

前几天遇到一个网友反映在网上买到的三星二手固态盘不好用，有问题。我自己这里最近刚好帮客户购买三星固态盘860PRO 512GB用于替换原来使用的850EVO 250GB.期间使用一款三星自己出品的固态盘管理软件Samsung Magician的软件(中文名：三星魔术师)进行硬盘的真伪检查和测试，很好用。在这里分享给大家。这款软件主要是以下几个作用1. 查询硬盘的真伪。(只支持三星)2. 固态盘基本

开放原子开发者工作坊

PPPOE协议工作流程

PPPoE （ Point to Point Protocol over Ethernet ，基于以太网的点对点协议）的工作流程包含发现（ Discovery ）和会话（ Session ）两个阶段，发现阶段是无状态的，目的是获得PPPoE 终端（在局端的ADSL 设备上）的以太网MAC 地址，并建立一个惟一的PPPoE SESSION-ID 。发现阶段结束后，就进入标准的PPP 会话阶段...

开放原子开发者工作坊

stm32f4 串口空闲中断+DMA遇到的奇怪错位问题

基于stm32f407文章目录一、利用DMA接受串口任意长数据1、简介2、循环模式和普通模式二、DMA接受数据错位问题1、程序设置2、数据缓冲错位问题（1）问题描述：（2）调试过程（3）解决方案（4）后记一、利用DMA接受串口任意长数据1、简介有时候，我们希望利用串口在设备间进行高速而稳定的数据通信，于是定义了一些通讯协议，包括帧头、功能码、数据码、校验码等等，DMA非常适合此类需求。...