【k8s】Jenkins实现springcloud应用CI、CD实践 【三】

已于 2023-06-27 09:51:11 修改
阅读量1k 收藏 4
点赞数
分类专栏： 云玩家-K8S&docker 文章标签： kubernetes jenkins spring cloud ci/cd
于 2023-05-21 23:37:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nightwish5/article/details/130798609
版权

一、运行Jenkins流水线流程思路：

场景：java微服务应用， 单体仓库，多个微服务模块，（并行构建、自动化构建、根据模块变更仅更新特定模块）    java、nodejs

CI阶段          并行方式; 根据模块变更仅更新特定模块
1、准备项日;
	目录结构 （源代码 、dockerfile 、deploy.yaml资源清单文件）
2、下载代码
3、漏洞检测;
4、项目编译;
5、镜像制作;
6、部署测试环境;

CD阶段:
1、拉取harbor中的镜像;
2、交付到生产环境;
3、添加回退阶段;

二、部署springcloud 若依项目

本文不做详细的部署细节，可参考以前的写的： https://blog.csdn.net/Nightwish5/article/details/130308650
在这里插入图片描述

1、准备项目；
			目录结构   （源代码、Dockerfile、deploy.yaml资源清单文件）
			deploy.yaml中要替换的变量：
			{namespace}
			{image}
		
			ui  {host}
			monitor    {host}    ingress
	
		前置条件：
			1、harbor.oldxu.net/springcloud/skywalking-java-agent:8.8
			2、依赖的MySQL、Redis、Skywalking、Nacos（配置）得有；
		
		ruoyi-gateway-dev.yml
		ruoyi-auth-dev.yml
		
		ruoyi-monitor-dev.yml
		ruoyi-system-dev.yml
		
		1、提交代码到gitlab
		2、下载代码

大致说明：

部署基础组件: ruoyi的springcloud部署顺序
1、mysql （若依项目的DB库）
2、redis
3、nacos 、 mysql（nacos依赖的库）
配置nacos中的对应的yml文件

4、sentinel  
5、skywalking （oap和ui）

#part 6可以在CICD过程中部署
6、service-all
  1、system-dp
  2、auth-dp
  3、gateway-dp
  4、monitor-dp-ingress
  5、ui-dp-ingress

三、将代码提交到gitlab

gitlab创建项目：RuoYiCloud

git init 

git config --global user.email "123456@qq.com"
git config --global user.name  "old133"

git  remote add origin http://gitlab.oldxu.net:30080/root/ruoyicloud.git
git add .
git commit -m "初始化"

git checkout -b k8s
git push --set-upstream origin k8s


#方式2：
代码上传到gitee ， gitlab导入项目 -> 从URL导入仓库

四、创建流水线 springcloud-ruoyi-CI

2、下载代码
		3、漏洞检测；
		
			并行；
			进入到对应的微服务文件夹中；
			不规则的，需要再cd进个子目录：
			cd ruoyi-monitor
			cd ruoyi-system

在这里插入图片描述

4.1 获取代码和代码扫描和漏洞扫描结果

pipeline{
    agent {
    kubernetes {
      cloud 'kubernetes'
      yaml '''
        apiVersion: v1
        kind: Pod
        spec:
          imagePullSecrets:
          - name: harbor-admin
          volumes:
          - name: data
            nfs:
              server: 192.168.79.33
              path: /data/maven
          - name: dockersocket
            hostPath:
              path: /run/docker.sock
          containers:
          - name: maven
            image: harbor.oldxu.net/ops/maven:3.8.6
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
            volumeMounts:
            - name: data
              mountPath: /root/.m2
          - name: nodejs
            image: harbor.oldxu.net/ops/nodejs:14.20
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
          - name: sonar
            image: harbor.oldxu.net/ops/sonar-scanner:2.3.0
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
          - name: docker
            image: harbor.oldxu.net/ops/docker:20.10
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
            volumeMounts:
            - name: dockersocket
              mountPath: /run/docker.sock
          - name: kubectl
            image: harbor.oldxu.net/ops/kubectl:1.18.0
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
      '''
    } //kubernetes ned
  }	//agent end

		environment{
			Gitlab_Id = "gitlab-root-token"
			Gitlab_Pro = "http://gitlab.oldxu.net:30080/root/ruoyi-cloud.git"
			
		} //environment end
		
		stages{
		    
			stage('获取代码'){
				steps{
					container('maven'){
					   //注意这里的分支是k8s
					   checkout([$class: 'GitSCM', branches: [[name: '*/k8s']], extensions: [], userRemoteConfigs: [[credentialsId: "${Gitlab_Id}", url: "${Gitlab_Pro}"]]])
                       sh 'pwd && ls -l'
					
					}
				}
			
			} //获取代码 end
			
			stage('代码扫描'){
				//并行处理
				parallel{
				    // 1 检测Gateway
					stage('检测Gateway'){
						environment{
							AppName="ruoyi-gateway"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ type -d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 2 Auth
					stage('检测Auth'){
						environment{
							AppName="ruoyi-Auth"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ type -d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 3 system
					stage('检测system'){
						environment{
							AppName="ruoyi-system"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ type -d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 4 monitor
					stage('检测monitor'){
						environment{
							AppName="ruoyi-monitor"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ type -d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 5 UI
					stage('检测UI'){
						environment{
							AppName="ruoyi-ui"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ type -d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
				}//parallel end					
			} //代码扫描 stage end
			
			
			stage('检查漏洞扫描结果'){
				steps{
					container('sonar'){
						script{
							timeout(5){
								def qg = waitForQualityGate()
								if (qg.status != 'OK'){
									error "Sonarqube 代码检查失败, error的原因 ${qg.status}"
								}
							}
						}
					}
				}
			
			}//检查漏洞扫描结果 stage end
			
			
		}//stages end

}//pipeline end

在这里插入图片描述

五、项目编译（maven和nodejs）

#思路：
也是要并行构建
				Java：
					找到这个微服务模块的路径 （使用刚才的find方法）
					mvn package -Dmaven.test.skip=true -pl ${模块路径} -am
				NodeJS：
				npm install --registry=https://registry.npmmirror.com
				npm run build:prod

maven编译举例：
在这里插入图片描述

5.1 对应的pipeline代码：

		stages{
		    			
			stage('代码编译'){
				parallel{
					// 1、编译Gateway
					stage('编译Gateway'){
						environment{
							AppName = "ruoyi-gateway"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}
							
						}
					}
					
					// 2、编译Auth
					stage('编译Auth'){
						environment{
							AppName = "ruoyi-auth"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 3、编译system
					stage('编译system'){
						environment{
							AppName = "ruoyi-system"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 4、编译monitor
					stage('编译monitor'){
						environment{
							AppName = "ruoyi-monitor"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 5、编译UI
					stage('编译UI'){
						environment{
							AppName = "ruoyi-ui"
						}
						
						steps{
							container('nodejs'){
								sh '''
									cd $(find ./ -type d -name "${AppName}") && \
									npm install --registry=https://registry.npmmirror.com && \
									npm run build:prod
								'''
							}							
						}
					}
					
				} // parallel end
			}//代码编译 stage end
			
		}//总stages end

运行结果：
在这里插入图片描述

六、制作Docker镜像

6.1 对应的pipeline代码

   stage('生成镜像Tag'){
      steps {
        container('maven') {
          script {
            //本次git提交的commid     (git log -n1 --pretty=format:'%h')
            env.COMMITID = sh(returnStdout: true, script: "git log -n1 --pretty=format:'%h'").trim()
            //构建的时间   (date +%Y%m%d_%H%M%S)
            env.BuildTime = sh(returnStdout: true, script: "date +%Y%m%d_%H%M%S").trim()
            
            //完整的镜像Tag   (c106654_20221115_133911)
            env.ImageTag = COMMITID + "_" +  BuildTime
          }
          
          sh 'echo "镜像的Tag: ${ImageTag}"'
        }
      }
    }

stage('制作Docker镜像'){

      parallel{
        stage('构建Gateway镜像') {
          when { expression {GATEWAY == "ok" || Deploy_All == "true" } }
          environment {
            AppName = "ruoyi-gateway"
            ImageName = "${Url}/${Pro}/${AppName}"
          }
          steps {
            container('docker'){
              withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
                  //登陆harbor
                  sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin'
                  //构建镜像
                  sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
                  //推送镜像
                  sh 'docker push ${ImageName}:${ImageTag}'
                  //删除镜像
                  sh 'docker rmi ${ImageName}:${ImageTag}' 
              }
            }
          }
        }

        stage('构建System镜像') {
          when { expression {SYSTEM == "ok" || Deploy_All == "true" } }
          environment {
            AppName = "ruoyi-system"
            ImageName = "${Url}/${Pro}/${AppName}"
          }
          steps {
            container('docker'){
              withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
                  //登陆harbor
                  sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin'
                  //构建镜像
                  sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
                  //推送镜像
                  sh 'docker push ${ImageName}:${ImageTag}'
                  //删除镜像
                  sh 'docker rmi ${ImageName}:${ImageTag}' 
              }
            }
          }
        }

        stage('构建Auth镜像') {
          when { expression {AUTH == "ok" || Deploy_All == "true" } }
          environment {
            AppName = "ruoyi-auth"
            ImageName = "${Url}/${Pro}/${AppName}"
          }
          steps {
            container('docker'){
              withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
                  //登陆harbor
                  sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin'
                  //构建镜像
                  sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
                  //推送镜像
                  sh 'docker push ${ImageName}:${ImageTag}'
                  //删除镜像
                  sh 'docker rmi ${ImageName}:${ImageTag}' 
              }
            }
          }
        }

        stage('构建Monitor镜像') {
          when { expression {MONITOR == "ok" || Deploy_All == "true" } }
          environment {
            AppName = "ruoyi-monitor"
            ImageName = "${Url}/${Pro}/${AppName}"
          }
          steps {
            container('docker'){
              withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
                  //登陆harbor
                  sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin'
                  //构建镜像
                  sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
                  //推送镜像
                  sh 'docker push ${ImageName}:${ImageTag}'
                  //删除镜像
                  sh 'docker rmi ${ImageName}:${ImageTag}' 
              }
            }
          }
        }

        stage('构建UI镜像') {
          when { expression {UI == "ok" || Deploy_All == "true" } }
          environment {
            AppName = "ruoyi-ui"
            ImageName = "${Url}/${Pro}/${AppName}"
          }
          steps {
            container('docker'){
              withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
                  //登陆harbor
                  sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin'
                  //构建镜像
                  sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
                  //推送镜像
                  sh 'docker push ${ImageName}:${ImageTag}'
                  //删除镜像
                  sh 'docker rmi ${ImageName}:${ImageTag}' 
              }
            }
          }
        }

执行结果：
在这里插入图片描述

七、部署至K8s测试环境

之前部署成功的效果：
在这里插入图片描述

//交付至K8s
			stage('交付微服务至k8s'){
				parallel{
					// 1 gateway
					stage('交付Gateway'){
						environment{
							AppName = "ruoyi-gateway"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 2 交付auth
					stage('交付auth'){
						environment{
							AppName = "ruoyi-auth"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 3 交付system
					stage('交付system'){
						environment{
							AppName = "ruoyi-system"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 4 交付monitor
					stage('交付monitor'){
						environment{
							AppName = "ruoyi-monitor"
							ImageName = "$Url/${Pro}/${AppName}"
							IngressHost = "monitor-dev.oldxu.net"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										sed -i "s#{host}#${IngressHost}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 5 交付UI
					stage('交付UI'){
						environment{
							AppName = "ruoyi-ui"
							ImageName = "$Url/${Pro}/${AppName}"
							IngressHost = "ui-dev.oldxu.net"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										sed -i "s#{host}#${IngressHost}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
				}//parallel end
			
			}//交付至K8s ,stage end

执行结果：
在这里插入图片描述

八、全自动化CI （问题一）

8.1 自动化构件操作

在这里插入图片描述
构建触发器 -> build when a change …
高级 -> 生成Secret token -> f5b73ada8be70c2259e587eb787e5a4b

gitlab界面：
地址：http://gitlab.oldxu.net:30080/root/ruoyi-cloud/-/hooks
Administrator -> Ruoyi Cloud -> Webhook设置
在这里插入图片描述
在这里插入图片描述
更新代码内容，提交。测试是否自动触发构建CI
ruoyi-auth/src/main/java/com/ruoyi/auth/service/SysLoginService.java
在这里插入图片描述
web页面效果
在这里插入图片描述

全自动化CI的问题：
		如果开发只更新了某个模块，就检测这个某块，编译这个某块、以及发布这个模块；
			
		解决方案：
			1、获取所有更新的模块名称，与我们的微服务名称进行比对，将更新的模块名称写入到文件中 [模块名=ok]
			2、过滤文件中模块的名称，提取OK，将这个OK赋值给新的变量，将新的变量提供给Jenkins的Stage进行判断；

主要逻辑判断脚本：

#!/usr/bin/bash
# 定义微服务模块名称
Init_Module=(ruoyi-gateway ruoyi-auth ruoyi-system ruoyi-monitor ruoyi-ui)

# 变动的模块
Change_Module=$(git diff --name-only $(git log -n2 --pretty=format:"%h") |cut -d / -f1,2)

# 外循环{提取变动的模块名称}
for Change in ${Change_Module}
do
	# echo "改变的微服务模块是: $Change"
	# 内循环
	for init in ${Init_Module[@]}
	do
		if [[ "${Change}" =~ "${init}" ]];then
		    # 正则匹配的逻辑 ->  ruoyi-module/ruoyi-system =~ ruoyi-system
		    echo "更新的模块是： $init"
			echo "${init}=ok" >> var.txt
		fi
	done
done

解释：
在这里插入图片描述

8.2 上述脚本的细节：

1、git diff对比更新的模块
在这里插入图片描述

2、对更新模块做ok判断的逻辑
在这里插入图片描述

8.3 本小节对pipeline的改动有：

新增：
    1、stage('检查变动的模块名称') {
    2、stage('输出更新的模块状态'){
    3、在parallel的各个stage中，加上when判断，如 when{ expression {GATEWAY == "ok"} }

运行效果：
在这里插入图片描述

九、全自动化CI （问题二）

	全自动化CI的问题2：
		自动化触发的时候，就更新那特定的模块；
		**手动点击**的时候是希望**所有的微服务组件都进行构建**；

9.1 新增参数化构建

Deploy_All 自动化构建的时候默认是false，手动构建的时候，选择true.
和
when { expression {UI == "ok" || Deploy_All == "true" } }


parameters {
  choice choices: ['false', 'true'], description: '是否部署所有微服务', name: 'Deploy_All'
}

在这里插入图片描述

完整的springcloud-ruoyi-CI代码：

pipeline{
    agent {
    kubernetes {
      cloud 'kubernetes'
      yaml '''
        apiVersion: v1
        kind: Pod
        spec:
          imagePullSecrets:
          - name: harbor-admin
          volumes:
          - name: data
            nfs:
              server: 192.168.79.33
              path: /data/maven
          - name: dockersocket
            hostPath:
              path: /run/docker.sock
          containers:
          - name: maven
            image: harbor.oldxu.net/ops/maven:3.8.6
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
            volumeMounts:
            - name: data
              mountPath: /root/.m2
          - name: nodejs
            image: harbor.oldxu.net/ops/nodejs:14.20
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
          - name: sonar
            image: harbor.oldxu.net/ops/sonar-scanner:2.3.0
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
          - name: docker
            image: harbor.oldxu.net/ops/docker:20.10
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
            volumeMounts:
            - name: dockersocket
              mountPath: /run/docker.sock
          - name: kubectl
            image: harbor.oldxu.net/ops/kubectl:1.18.0
            imagePullPolicy: IfNotPresent
            command: ["cat"]
            tty: true
      '''
    } //kubernetes ned
  }	//agent end
  
		//参数话构建 Deploy_All
		parameters{
			choice choices: ['false', 'true'], description: '是否部署所有的微服务', name: 'Deploy_All'

		}

		environment{
			Gitlab_Id = "gitlab-root-token"
			Gitlab_Pro = "http://gitlab.oldxu.net:30080/root/ruoyi-cloud.git"
			
			//Harbor相关的全局变量
			Url = "harbor.oldxu.net"
			Pro = "base"
			HARBOR_ID = "harbor-auth"
			
			//对外暴露的域名
			Ingress_Host = "spring-dev.oldxu.net"
			
		} //environment end
		
		stages{
		    
			stage('获取代码'){
				steps{
					container('maven'){
					   //注意这里的分支是k8s
					   checkout([$class: 'GitSCM', branches: [[name: '*/k8s']], extensions: [], userRemoteConfigs: [[credentialsId: "${Gitlab_Id}", url: "${Gitlab_Pro}"]]])
                       sh 'pwd && ls -l'
					
					}
				}
			
			} //获取代码 end
			
			//检查变动的模块名称
			stage('检查变动的模块名称'){
				steps{
					sh '''#!/bin/bash
						#微服务模块名称
						Init_Module=(ruoyi-gateway ruoyi-auth ruoyi-system ruoyi-monitor ruoyi-ui)
						
						#变动的模块
						Change_Module=$(git diff --name-only $(git log -n2 --pretty=format:"%h") | cut -d / -f1,2 )
						
						# 外循环{提取变动的模块名称}
						for Change in ${Change_Module}
						do
							echo "改变的微服务模块是： $Change"
							#内循环 
							for init in ${Init_Module[@]}
							do
								if [[ "${Change}" =~ "${init}" ]];then
									echo "${init}=ok" >> var.txt
								fi
							done
						done
					'''
					
					//制作自定义变量
					script{
						env.GATEWAY = sh(returnStdout: true,script: "grep 'ruoyi-gateway' var.txt | awk -F '=' '{print \$2}' ").trim()
						env.AUTH = sh(returnStdout: true, script: "grep 'ruoyi-auth' var.txt | awk -F '=' '{print \$2}'").trim()
						env.SYSTEM = sh(returnStdout: true,script: "grep 'ruoyi-system' var.txt | awk -F '=' '{print \$2}'").trim()
						env.MONITOR = sh(returnStdout: true,script: "grep 'ruoyi-monitor' var.txt | awk -F '=' '{print \$2}'").trim()
						env.UI = sh(returnStdout: true,script: "grep 'ruoyi-ui' var.txt | awk -F '=' '{print \$2}'").trim()
					}
			
				}
			
			}//检查变动的模块名称 stage end
			
			stage('输出更新的模块状态'){
				steps{
					sh 'echo "gateway: ${GATEWAY}"'
					sh 'echo "auth: ${AUTH}"'
					sh 'echo "system: ${SYSTEM}"'
					sh 'echo "monitor: ${MONITOR}"'
					sh 'echo "ui: ${UI}"'
				}
			}//输出更新的模块状态 stage end
			
			stage('代码扫描'){
				//并行处理
				parallel{
				    // 1 检测Gateway
					stage('检测Gateway'){
						when { expression {GATEWAY == "ok" || Deploy_All == "true"} }
						environment{
							AppName="ruoyi-gateway"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ -type d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 2 Auth
					stage('检测Auth'){
   						when { expression {AUTH == "ok" || Deploy_All == "true" } }
						environment{
							AppName="ruoyi-auth"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ -type d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 3 system
					stage('检测system'){
						when { expression {SYSTEM == "ok" || Deploy_All == "true"} }
						environment{
							AppName="ruoyi-system"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ -type d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 4 monitor
					stage('检测monitor'){
						when { expression {MONITOR == "ok" || Deploy_All == "true"} }
						environment{
							AppName="ruoyi-monitor"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ -type d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
					// 5 UI
					stage('检测UI'){
						when { expression {UI == "ok"|| Deploy_All == "true"} }
						environment{
							AppName="ruoyi-ui"
						}
						
						steps{
							withSonarQubeEnv('sonar-k8s'){
								container('sonar'){
									sh ' cd $(find ./ -type d -name "${AppName}") && \
										sonar-scanner \
										-Dsonar.projectKey=${AppName} \
										-Dsonar.java.binaries=src \
										-Dsonar.sources=.'
								}
							}
						}
					}
					
				}//parallel end					
			} //代码扫描 stage end
			
			
			stage('检查漏洞扫描结果'){
				steps{
					container('sonar'){
						script{
							timeout(5){
								def qg = waitForQualityGate()
								if (qg.status != 'OK'){
									error "Sonarqube 代码检查失败, error的原因 ${qg.status}"
								}
							}
						}
					}
				}
			
			}//检查漏洞扫描结果 stage end
			
			stage('代码编译'){
				parallel{
					// 1、编译Gateway
					stage('编译Gateway'){
						when { expression {GATEWAY == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-gateway"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}
							
						}
					}
					
					// 2、编译Auth
					stage('编译Auth'){
						when { expression {AUTH == "ok" || Deploy_All == "true"} }

						environment{
							AppName = "ruoyi-auth"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 3、编译system
					stage('编译system'){
						when { expression {SYSTEM == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-system"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 4、编译monitor
					stage('编译monitor'){
						when { expression {MONITOR == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-monitor"
						}
						
						steps{
							container('maven'){
								sh '''
									Build_Path=$(find ./ -type d -name "${AppName}")
									mvn package -Dmaven.test.skip=true -pl ${Build_Path} -am
								'''
							}							
						}
					}
					
					// 5、编译UI
					stage('编译UI'){
						when { expression {UI == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-ui"
						}
						
						steps{
							container('nodejs'){
								sh '''
									cd $(find ./ -type d -name "${AppName}") && \
									npm install --registry=https://registry.npmmirror.com && \
									npm run build:prod
								'''
							}							
						}
					}
					
				} // parallel end
			}//代码编译 stage end
			
			//生产镜像tag
			stage('生产镜像tag'){
				steps{
					container('maven'){
						script{
							//本次git提交的commid   (git log -n1 --pretty=format:'%h')
							env.COMMITID = sh(returnStdout: true, script: "git log -n1 --pretty=format:'%h'").trim()
							//构建时间
							env.BuildTime = sh(returnStdout: true, script: "date +%Y%m%d_%H%M%S").trim()
							//完整的镜像Tag   (c106654_20221115_133911)
							env.ImageTag = COMMITID + "_" + BuildTime
						}
						sh 'echo "镜像的Tag： ${ImageTag}"'
					}
				}
			}//生产镜像tag , stage end
			
			//制作Docker镜像
			stage('制作Docker镜像'){
				parallel{
					//1 gateway
					stage('构建Gateway镜像'){
						when { expression {GATEWAY == "ok" || Deploy_All == "true" } }
						environment{
							AppName = "ruoyi-gateway"
							ImageName = "${Url}/${Pro}/${AppName}"
						}
						steps{
							container('docker'){
								withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
									//登录harbor
									sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin '
									// 构建 、推送 、删除本地镜像
									sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
									sh 'docker push ${ImageName}:${ImageTag}'
									sh 'docker rmi ${ImageName}:${ImageTag}'
								}

							}
						}
					}
					
					//2 system
					stage('构建system镜像'){
						when { expression {SYSTEM == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-system"
							ImageName = "${Url}/${Pro}/${AppName}"
						}
						steps{
							container('docker'){
								withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
									//登录harbor
									sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin '
									// 构建 、推送 、删除本地镜像
									sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
									sh 'docker push ${ImageName}:${ImageTag}'
									sh 'docker rmi ${ImageName}:${ImageTag}'
								}

							}
						}
					}
					
					//3 auth
					stage('构建auth镜像'){
						when { expression {AUTH == "ok" || Deploy_All == "true" } }
						environment{
							AppName = "ruoyi-auth"
							ImageName = "${Url}/${Pro}/${AppName}"
						}
						steps{
							container('docker'){
								withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
									//登录harbor
									sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin '
									// 构建 、推送 、删除本地镜像
									sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
									sh 'docker push ${ImageName}:${ImageTag}'
									sh 'docker rmi ${ImageName}:${ImageTag}'
								}

							}
						}
					}
					
					//4 monitor
					stage('构建monitor镜像'){
						when { expression {MONITOR == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-monitor"
							ImageName = "${Url}/${Pro}/${AppName}"
						}
						steps{
							container('docker'){
								withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
									//登录harbor
									sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin '
									// 构建 、推送 、删除本地镜像
									sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
									sh 'docker push ${ImageName}:${ImageTag}'
									sh 'docker rmi ${ImageName}:${ImageTag}'
								}

							}
						}
					}
					
					//5 ui
					stage('构建ui镜像'){
						when { expression {UI == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-ui"
							ImageName = "${Url}/${Pro}/${AppName}"
						}
						steps{
							container('docker'){
								withCredentials([usernamePassword(credentialsId: "${HARBOR_ID}", passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USER')]) {
									//登录harbor
									sh 'echo "${HARBOR_PASSWORD}" | docker login ${Url} -u "${HARBOR_USER}" --password-stdin '
									// 构建 、推送 、删除本地镜像
									sh 'cd $(find ./ -type d -name "${AppName}") && docker build -t ${ImageName}:${ImageTag} .'
									sh 'docker push ${ImageName}:${ImageTag}'
									sh 'docker rmi ${ImageName}:${ImageTag}'
								}

							}
						}
					}
					
				} //parallel end
			
			}//制作Docker镜像 stage end
			
			
			//交付至K8s
			stage('交付微服务至k8s'){
				parallel{
					// 1 gateway
					stage('交付Gateway'){
						when { expression {GATEWAY == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-gateway"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 2 交付auth
					stage('交付auth'){
						when { expression {AUTH == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-auth"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 3 交付system
					stage('交付system'){
						when { expression {SYSTEM == "ok" || Deploy_All == "true" } }
						environment{
							AppName = "ruoyi-system"
							ImageName = "$Url/${Pro}/${AppName}"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 4 交付monitor
					stage('交付monitor'){
						when { expression {MONITOR == "ok" || Deploy_All == "true"} }
						environment{
							AppName = "ruoyi-monitor"
							ImageName = "$Url/${Pro}/${AppName}"
							IngressHost = "monitor-dev.oldxu.net"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										sed -i "s#{host}#${IngressHost}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
					// 5 交付UI
					stage('交付UI'){
						when { expression {UI == "ok" || Deploy_All == "true" } }
						environment{
							AppName = "ruoyi-ui"
							ImageName = "$Url/${Pro}/${AppName}"
							IngressHost = "ui-dev.oldxu.net"
						}
						
						steps{
							container('kubectl'){
								withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
									sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
									
									sh '''
										cd $(find ./ -type d -name "${AppName}") && \
										sed -i "s#{namespace}#dev#" deploy.yaml
										sed -i "s#{image}#${ImageName}:${ImageTag}#g" deploy.yaml
										sed -i "s#{host}#${IngressHost}#g" deploy.yaml
										
										cat deploy.yaml
										kubectl apply -f deploy.yaml
									'''
								}

							}
						}
					}
					
				}//parallel end
			
			}//交付至K8s ,stage end
			
			
			
		}//总stages end

}//pipeline end

springcloud-CI阶段 END

十、Jenkins交付微服务-CD流水线设计与实现

		1、拉取harbor中的镜像；
		2、交付到生产环境；
		3、添加回退阶段；
		
可复用上次写的springboot-CD 。 由于环境内存有限，这里就没有部署prod环境下的springcloud ruoyi环境， 仍然使用dev环境。
复用后，需要修改的地方：

在这里插入图片描述
构建界面：
在这里插入图片描述
部署与回滚：
在这里插入图片描述
在这里插入图片描述
回滚：
在这里插入图片描述

10.1 对应的springcloud-ruoyi-CD代码：

pipeline{
    agent{
        kubernetes{
            cloud 'kubernetes'
            yaml '''
              apiVersion: v1
              kind: Pod
              spec:
                imagePullSecrets:
                - name: harbor-admin
                containers:
                - name: kubectl
                  image: harbor.oldxu.net/ops/kubectl:1.18.0
                  imagePullPolicy: IfNotPresent
                  command: ["cat"]
                  tty: true
            '''
        }
    }
    
    environment{
        Full_Image = "${Harbor_Url}/${Harbor_Pro}/${Image_Name}:${Image_Tag}"
       
    }//environment end
    
    stages{
        stage('输出完整的镜像名称'){
            steps{
                sh 'echo 镜像名称-tag: ${Full_Image}'
           

            }
            
        }
        
        stage('部署应用至生产 K8S'){
            steps{
                withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
                    container('kubectl'){
                        sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
                        sh 'kubectl set image deployment/${Image_Name} ${Image_Name}=${Full_Image} -n dev'
                    }
                }
    
            
            }
        }
        
        stage('快速回滚'){
            steps{
              withCredentials([file(credentialsId: 'kubeconfig', variable: 'KUBECONFIG')]) {
                container('kubectl'){
                    script{
                        timeout(time: 1, unit: 'HOURS'){
                            def UserInput = input message: '是否回退到上个版本', parameters: [choice(choices: ['No', 'Yes'], name: 'rollback')]
                            if (UserInput == "Yes"){
                               sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
                               sh 'kubectl rollout undo deployment $Image_Name -n dev'
 
                            }
                            
                        }
                    }
                }
              }

            }
        }
        
    }//stages end
    
    
    
}//pipeline end

本文多数是贴代码，沿用了上篇Jenkins文章的基础/操作 https://blog.csdn.net/Nightwish5/article/details/130761785

END

2023年5月24日。 队友崔了，我什么时候提崔呢？88133

Nightwish5
关注
专栏目录
【SpringCloud微服务实战10】DevOps自动化部署微服务项目(Jenkins+Docker+K8s)
李维山的博客
03-28 1563
DevOps 是一种重视软件开发人员（Developer）和运维人员（Operations）之间沟通与协作的文化、运动或实践，目标在于快速交付高质量的软件产品和服务。DevOps 强调自动化流程、持续集成与交付（CI/CD）、以及通过工具链、敏捷方法论和跨职能团队协作来增强软件的可靠性和安全性。在 DevOps 中，开发、测试、部署和监控等多个环节紧密连接，形成一个高效的工作流。
基于Docker和k8s部署Jenkins+gitlab的CI/CD环境
weixin_48218106的博客
05-22 1166
整个流程大部分通过容器化的部署来实现，通过Docker分别创建Jenkins、Gitlab容器，配置Jenkins连接maven，在Gitlab容器里面，编写Jenkinsfile流水线脚本，当代码提交到 Gitlab 代码仓库之后，可以通过 Jenkins 自动识别到代码的变化，将代码同步到kubernetes集群中，以缩短新功能开发上线周期，及时满足客户的需求，实现DevOps的部分流程，来减轻部署运维的负担，实现可视化容器生命周期管理、应用发布和版本迭代更新。
使用Jenkins实现Spring Cloud自动化部署
sinat_30802291的博客
09-14 2万+
Jenkins简介        Jenkins是基于Java开发的一种持续集成工具，用于监控持续重复的工作。简单点来讲就是配置好Jenkins以后可以一键发布项目，包括从git master分支拉取最新的代码，然后打包，然后上传到远程Linux服务器发布等一系列步骤它都可以帮你一键完成。这无疑可以省去很多程序员重复性繁琐的操作。特别是对于现在的spring cloud微服务来说，一个项目...
Jenkins---部署Spring Cloud项目
qq_40823910的博客
05-18 1412
Jenkins---部署Spring Cloud项目
jenkins流水线+k8s部署springcloud微服务架构项目
最新发布
m0_52620144的博客
09-11 2154
jenkins流水线+k8s部署springcloud项目的具体操作讲解
jenkins自动构建SpringCloud
热门推荐
微笑听雨
03-01 2万+
jenkins依赖docker-compose自动部署SpringCloud和vue项目本机环境jenkins配置下载war包war包部署设置开机自启访问Jenkins插件配置全局工具配置配置GitLab创建任务vue项目springcloud项目 本机环境 CentOS: CentOS Linux release 7.9.2009 (Core) jdk: Java(TM) SE Runtime Environment (build 1.8.0_281-b09) jenkins配置 Jenkins是一个开
基于docker环境jenkins一键部署springcloud微服务
wwl121184的博客
05-11 1699
jenkins持续构建、部署spring cloud微服务，加快项目构建、部署效率
DevOps-K8s+Jenkins+Gitlab实现CI/CD-部署微服务PiggyMetrics
ABCCloud的博客
05-20 2327
DevOps意为“Development”和“Operations”，即为开发人员和运维人员之间沟通合作的开发模式，通过自动化“软件交付”和“架构更变”的流程，实现开发运维一体化，使得开发构建、测试、发布能够更加快捷、频繁和高效稳定。 DevOps是一组过程、方法与系统的统称，用于促进开发（应用程序/软件工程）、技术运营和质量保证部门之间的沟通、协作与整合。它的出现时由于软件行业日益清晰地认识到：为了按时交付软件产品和服务，开发和运营工作必须紧密合作。其最大的特点就是极速的迭代和快速的用户反馈。 测试的
基于Jenkins+Docker+Github实现SpringCloud自动化部署
Hpsyche的博客
04-05 2358
前言 本博文主要介绍了基于Jenkins+Docker+Github实现了对SpringCloud微服务项目的快速打包、部署。 正文 项目准备 首先有如下SpringCloud项目（这里以本人的毕设项目举例），目录结构如下： bishe_base中的每个module代表一个服务，其中client为后缀的代表的是客户端，其用来暴露server服务中提供的服务接口，给外部的服务使用。 为了让项目最终...
Jenkins+SpringCloud（多模块）+Vue项目详细配置
lxmtim的博客
09-21 609
随着Docker、K8S、服务网格（ServiceMesh）等新型部署管理方式的兴起，Jenkins等工具已逐渐是CI/CD的较为过时的管理方式，我这用到工具包括JDK、Git、Maven、NodeJS：可以选择自行在服务器安装，也可以通过Jenkins自动安装，位置在系统管理 》全局工具配置。部署方式可以根据实际情况灵活调整：如果Jenkins和系统部署为一台服务器，则无需远程传输，将打包好的文件移动或复制到指定的目录运行即可；#根据输入参数，选择执行对应方法，不输入则执行使用说明。
jenkins最佳实践（二）：Pipeline流水线部署springCloud微服务项目
小金的博客
08-20 1913
各位小伙伴们大家好呀，我是小金，本篇文章我们将介绍如何使用Pipeline流水线部署我们自己的微服务项目，特此记录一下，遇到的问题和解决办法
Jenkins自动部署SpringCloud项目
u012632105的博客
06-30 5251
Jenkins自动部署SpringCloud项目 wToFly关注 2019.08.15 16:01:17字数 162阅读 759 1.本地准备Tomcat环境 2.jenkins下载地址https://jenkins.io/zh/download/ 选择war包下载 image.png 下载后把war包放入Tomcat的webapps目录下，之后启动Tomcat 3.浏览器输入http://localhost:8080/jenkins/进入jenkins页面(Tomcat端口号为808
jenkins启动部署springcloud项目
迪八戈的博客
11-11 1962
1.安装并且启动Jenkins: 下载jenkins的war包， 启动命令： nohup java -jar jenkins.war --httpPort=8431 >output 2>&1 & 2.在服务器主机配置号，JDK，GIT，MAVEN三个环境，不赘述。 3.登录jenkins创建Freestyle Project，如图： 4.其他的不用管，直接拉到后面的“构建”模块，选择“执行shell”，如图： 5.然后填入shell指令： 指令编码，如下： cd /var/
Jenkins构建springcloud项目全流程
weixin_41673092的博客
11-17 532
使用jenkins完成拉代码到服务器运行的整个流程。
jenkins 部署 spring_cloud服务 二
生生的博客
03-07 214
jenkins 部署微服务 多个包
【学习Docker（七）】详细讲解Jenkins部署SpringCloud微服务项目，Docker-compose启动
你若为我繁华，我愿成你烟花
03-03 1158
座右铭：《坚持有效输出，创造价值无限》本文介绍使用Jenkins部署SpringCloud微服务项目
jenkins +spring cloud +git 实现自动化部署
zen243435的博客
06-11 603
然后点击高级，勾选【Use password authentication, or use a different key】使用密码登录，填写密码、端口、连接超时。4编辑 ./home/jenkins/jenkins_mount/hudson.model.UpdateCenter.xml。2.编写jenkins 启动脚本， 挂载jenkins maven jdk jenkins port可自行设置。7.查看jenkins 日志，复制密码登录，并选择新手推荐。9.进入全局工具配置，配置maven，jdk。
springcloud基于jenkins自动部署
super--man的博客
12-21 3148
jenkins运行流程： 1、从SVN拉取代码到 jenkins 2、运行maven命令clean install，将项目打 jar (war)包 3、执行shell 脚本，启动项目 下图是我们的项目 两部分：红色是需要运行的项目、绿色是基础项目不需要运行（只需deploy到maven仓库即可） jenkins下载：http://mirrors.jenkins.io/war-s...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值