Jenkins CICD 单项目多服务可选服务部署

最新推荐文章于 2023-02-14 17:30:58 发布
最新推荐文章于 2023-02-14 17:30:58 发布
阅读量512 收藏
点赞数
分类专栏： Jenkins CICD K8S
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38983728/article/details/113613598
版权
K8S 同时被 3 个专栏收录
30 篇文章 2 订阅
订阅专栏
Jenkins
5 篇文章 1 订阅
订阅专栏
CICD
2 篇文章 0 订阅
订阅专栏

文章目录

1. Jenkins多选参数

有时候想要指定部署哪个服务，可以多选，安装插件Extended Choice Parameter
在这里插入图片描述
sc-auth,sc-gateway,sc-admin,sc-register,sc-info-device,sc-info-space,sc-info-car,sc-info-people,sc-info-community,sc-config
在这里插入图片描述
认证中心,网关,权限管理,注册中心,信息设备管理,信息空间管理,信息车辆管理,信息人员管理,信息社区管理,联动配置
在这里插入图片描述

2. jenkinsfile

def label = "slave-${UUID.randomUUID().toString()}"

def helmLint(String chartDir) {
    println "校验 chart 模板"
    sh "helm lint ${chartDir}"
}

def helmRepo(Map args) {
  println "添加 sc repo"
  sh "helm repo add sc http://${args.dockerRegistryUrl}/chartrepo/smartcommunity --username ${args.username} --password ${args.password}"

  println "更新 repo"
  sh "helm repo update"

  println "获取 Chart 包"
  sh """
    helm fetch sc/sc
    tar -xzvf sc-0.1.0.tgz
    """
}

def helmDeploy(Map args) {
    helmRepo(args)

    if (args.dry_run) {
        println "Debug 应用 ${args.profile} 环境"
        sh "helm upgrade --dry-run --debug --install ${args.name} ${args.chartDir} \
        --set register.image.repository=${args.registerImage} --set register.image.tag=${args.registerTag} \
        --set gateway.image.repository=${args.gatewayImage} --set gateway.image.tag=${args.gatewayTag} \
        --set admin.image.repository=${args.adminImage} --set admin.image.tag=${args.adminTag} \
        --set txManager.image.repository=${args.txManagerImage} --set txManager.image.tag=${args.txManagerTag} \
        --set auth.image.repository=${args.authImage} --set auth.image.tag=${args.authTag} \
        --set infoDevice.image.repository=${args.infoDeviceImage} --set infoDevice.image.tag=${args.infoDeviceTag} \
        --set infoSpace.image.repository=${args.infoSpaceImage} --set infoSpace.image.tag=${args.infoSpaceTag} \
        --set infoCar.image.repository=${args.infoCarImage} --set infoCar.image.tag=${args.infoCarTag} \
        --set infoPeople.image.repository=${args.infoPeopleImage} --set infoPeople.image.tag=${args.infoPeopleTag} \
        --set infoCommunity.image.repository=${args.infoCommunityImage} --set infoCommunity.image.tag=${args.infoCommunityTag} \
        --set statisticAnalysis.image.repository=${args.statisticAnalysisImage} --set statisticAnalysis.image.tag=${args.statisticAnalysisTag} \
        --set smartAnalysis.image.repository=${args.smartAnalysisImage} --set smartAnalysis.image.tag=${args.smartAnalysisTag} \
        --set profile=${args.profile} --set imagePullSecrets[0].name=myreg-in --namespace=${args.namespace}"
    } else {
        println "部署应用 到 ${args.profile} 环境"
        sh "helm upgrade --install ${args.name} ${args.chartDir} \
        --set register.image.repository=${args.registerImage} --set register.image.tag=${args.registerTag} \
        --set gateway.image.repository=${args.gatewayImage} --set gateway.image.tag=${args.gatewayTag} \
        --set admin.image.repository=${args.adminImage} --set admin.image.tag=${args.adminTag} \
        --set txManager.image.repository=${args.txManagerImage} --set txManager.image.tag=${args.txManagerTag} \
        --set auth.image.repository=${args.authImage} --set auth.image.tag=${args.authTag} \
        --set infoDevice.image.repository=${args.infoDeviceImage} --set infoDevice.image.tag=${args.infoDeviceTag} \
        --set infoSpace.image.repository=${args.infoSpaceImage} --set infoSpace.image.tag=${args.infoSpaceTag} \
        --set infoCar.image.repository=${args.infoCarImage} --set infoCar.image.tag=${args.infoCarTag} \
        --set infoPeople.image.repository=${args.infoPeopleImage} --set infoPeople.image.tag=${args.infoPeopleTag} \
        --set infoCommunity.image.repository=${args.infoCommunityImage} --set infoCommunity.image.tag=${args.infoCommunityTag} \
        --set statisticAnalysis.image.repository=${args.statisticAnalysisImage} --set statisticAnalysis.image.tag=${args.statisticAnalysisTag} \
        --set smartAnalysis.image.repository=${args.smartAnalysisImage} --set smartAnalysis.image.tag=${args.smartAnalysisTag} \
        --set profile=${args.profile} --set imagePullSecrets[0].name=myreg-in --namespace=${args.namespace}"
        echo "应用 ${args.name} 部署成功. 可以使用 helm status ${args.name} 查看应用状态"
    }
}

podTemplate(label: label, containers: [
  containerTemplate(name: 'maven', image: 'registry.cn-shanghai.aliyuncs.com/wanfei/maven:3.6-alpine-aliyun', command: 'cat', ttyEnabled: true),
  containerTemplate(name: 'docker', image: 'docker', command: 'cat', ttyEnabled: true),
  containerTemplate(name: 'helm', image: 'hypnoglow/kubernetes-helm:3.0.2', command: 'cat', ttyEnabled: true)
], volumes: [
  persistentVolumeClaim(claimName: 'maven-pvc', mountPath: '/root/.m2'),
  hostPathVolume(mountPath: '/root/.kube', hostPath: '/root/.kube'),
  hostPathVolume(mountPath: '/var/run/docker.sock', hostPath: '/var/run/docker.sock')
]) {
  node(label) {
    def myRepo = checkout scm
    def gitCommit = myRepo.GIT_COMMIT
    def gitBranch = myRepo.GIT_BRANCH
    def gitPre = sh(script: "git rev-parse --short HEAD", returnStdout: true).trim()
    def imageTag = "sc-${gitPre}"
    def dockerRegistryUrl = "10.8.6.49:30032"
    def projectName = "smartcommunity"

    def registerImageName = "sc-register"
    def gatewayImageName = "sc-gateway"
    def adminImageName = "sc-admin"
    def txManagerImageName = "sc-tx-manager"
    def authImageName = "sc-auth"
    def infoDeviceImageName = "sc-info-device"
    def infoSpaceImageName = "sc-info-space"
    def infoCarImageName = "sc-info-car"
    def infoPeopleImageName = "sc-info-people"
    def infoCommunityImageName = "sc-info-community"
    def statisticAnalysisImageName = "sc-statistic-analysis"
    def smartAnalysisImageName = "sc-smart-analysis"

    def registerImage = "${dockerRegistryUrl}/${projectName}/${registerImageName}"
    def gatewayImage = "${dockerRegistryUrl}/${projectName}/${gatewayImageName}"
    def adminImage = "${dockerRegistryUrl}/${projectName}/${adminImageName}"
    def txManagerImage = "${dockerRegistryUrl}/${projectName}/${txManagerImageName}"
    def authImage = "${dockerRegistryUrl}/${projectName}/${authImageName}"
    def infoDeviceImage = "${dockerRegistryUrl}/${projectName}/${infoDeviceImageName}"
    def infoSpaceImage = "${dockerRegistryUrl}/${projectName}/${infoSpaceImageName}"
    def infoCarImage = "${dockerRegistryUrl}/${projectName}/${infoCarImageName}"
    def infoPeopleImage = "${dockerRegistryUrl}/${projectName}/${infoPeopleImageName}"
    def infoCommunityImage = "${dockerRegistryUrl}/${projectName}/${infoCommunityImageName}"
    def statisticAnalysisImage = "${dockerRegistryUrl}/${projectName}/${statisticAnalysisImageName}"
    def smartAnalysisImage = "${dockerRegistryUrl}/${projectName}/${smartAnalysisImageName}"
    def list = "${SELECT_DEPLOY}".tokenize(",")

    stage('单元测试') {
      echo "1.测试阶段"
    }
    stage('代码编译打包') {
      try {
        container('maven') {
          echo "2. 代码编译打包阶段"
          sh "mvn -U clean package -Dmaven.test.skip=true"
        }
      } catch (exc) {
        println "构建失败 - ${currentBuild.fullDisplayName}"
        throw(exc)
      }
    }
    stage('构建 Docker 镜像') {
      withCredentials([[$class: 'UsernamePasswordMultiBinding',
        credentialsId: 'Harbor',
        usernameVariable: 'DOCKER_HUB_USER',
        passwordVariable: 'DOCKER_HUB_PASSWORD']]) {
          container('docker') {
            echo "3. 构建 Docker 镜像阶段, 需要部署 ${list} 微服务"
            sh """
            ls -la
            docker login ${dockerRegistryUrl} -u ${DOCKER_HUB_USER} -p ${DOCKER_HUB_PASSWORD}
            """
            if (list.contains(registerImageName)) {
                echo "构建 ${registerImageName} 镜像"
                sh """
                docker build -t ${registerImage}:${imageTag} ./sc-register/
                docker push ${registerImage}:${imageTag}
                """
            }
            if (list.contains(gatewayImageName)) {
                echo "构建 ${gatewayImageName} 镜像"
                sh """
                docker build -t ${gatewayImage}:${imageTag} ./sc-gateway/
                docker push ${gatewayImage}:${imageTag}
                """
            }
            if (list.contains(adminImageName)) {
                echo "构建 ${adminImageName} 镜像"
                sh """
                docker build -t ${adminImage}:${imageTag} ./sc-upms/sc-upms-biz/
                docker push ${adminImage}:${imageTag}
                """
            }
            if (list.contains(txManagerImageName)) {
                echo "构建 ${txManagerImageName} 镜像"
                sh """
                docker build -t ${txManagerImage}:${imageTag} ./sc-tx-manager/
                docker push ${txManagerImage}:${imageTag}
                """
            }
            if (list.contains(authImageName)) {
                echo "构建 ${authImageName} 镜像"
                sh """
                docker build -t ${authImage}:${imageTag} ./sc-auth/
                docker push ${authImage}:${imageTag}
                """
            }
            if (list.contains(infoDeviceImageName)) {
                echo "构建 ${infoDeviceImageName} 镜像"
                sh """
                docker build -t ${infoDeviceImage}:${imageTag} ./sc-info/sc-info-device/sc-info-device-biz/
                docker push ${infoDeviceImage}:${imageTag}
                """
            }
            if (list.contains(infoSpaceImageName)) {
                echo "构建 ${infoSpaceImageName} 镜像"
                sh """
                docker build -t ${infoSpaceImage}:${imageTag} ./sc-info/sc-info-space/sc-info-space-biz/
                docker push ${infoSpaceImage}:${imageTag}
                """
            }
            if (list.contains(infoCarImageName)) {
                echo "构建 ${infoCarImageName} 镜像"
                sh """
                docker build -t ${infoCarImage}:${imageTag} ./sc-info/sc-info-car/sc-info-car-biz/
                docker push ${infoCarImage}:${imageTag}
                """
            }
            if (list.contains(infoPeopleImageName)) {
                echo "构建 ${infoPeopleImageName} 镜像"
                sh """
                docker build -t ${infoPeopleImage}:${imageTag} ./sc-info/sc-info-people/sc-info-people-biz/
                docker push ${infoPeopleImage}:${imageTag}
                """
            }
            if (list.contains(infoCommunityImageName)) {
                echo "构建 ${infoCommunityImageName} 镜像"
                sh """
                docker build -t ${infoCommunityImage}:${imageTag} ./sc-info/sc-info-community/sc-info-community-biz/
                docker push ${infoCommunityImage}:${imageTag}
                """
            }
            if (list.contains(statisticAnalysisImageName)) {
                echo "构建 ${statisticAnalysisImageName} 镜像"
                sh """
                docker build -t ${statisticAnalysisImage}:${imageTag} ./sc-statistic-analysis/sc-statistic-analysis-biz/
                docker push ${statisticAnalysisImage}:${imageTag}
                """
            }
            if (list.contains(smartAnalysisImageName)) {
                echo "构建 ${smartAnalysisImageName} 镜像"
                sh """
                docker build -t ${smartAnalysisImage}:${imageTag} ./sc-smart-analysis/sc-smart-analysis-biz/
                docker push ${smartAnalysisImage}:${imageTag}
                """
            }
        }
      }
    }

    stage('运行 Helm') {
      withCredentials([[$class: 'UsernamePasswordMultiBinding',
        credentialsId: 'Harbor',
        usernameVariable: 'DOCKER_HUB_USER',
        passwordVariable: 'DOCKER_HUB_PASSWORD']]) {
          container('helm') {
            echo "4. [INFO] 开始 Helm 部署"
            def registerTag = "${imageTag}"
            def gatewayTag = "${imageTag}"
            def adminTag = "${imageTag}"
            def txManagerTag = "${imageTag}"
            def authTag = "${imageTag}"
            def infoDeviceTag = "${imageTag}"
            def infoSpaceTag = "${imageTag}"
            def infoCarTag = "${imageTag}"
            def infoPeopleTag = "${imageTag}"
            def infoCommunityTag = "${imageTag}"
            def statisticAnalysisTag = "${imageTag}"
            def smartAnalysisTag = "${imageTag}"

            def tagUrl = 'curl -u USER:PASS -X GET "HURL/api/v2.0/projects/PROJECT_NAME/repositories/IMAGE/artifacts?page=1&page_size=1&with_tag=true&with_label=false&with_scan_overview=false&with_signature=false&with_immutable_status=false" -H "accept: application/json" | sed \'s/,/\\n/g\' | grep "name" | awk -F \':\' \'{print $2}\' | sed \'s/"//g\''
                        .replaceAll("USER", "${DOCKER_HUB_USER}")
                        .replaceAll("PASS", "${DOCKER_HUB_PASSWORD}")
                        .replaceAll("HURL", "${dockerRegistryUrl}")
                        .replaceAll("PROJECT_NAME", "${projectName}")

            if (!list.contains(registerImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", registerImageName)
                registerTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${registerImageName} 使用老镜像号为 ${registerTag}"
            }
            if (!list.contains(gatewayImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", gatewayImageName)
                gatewayTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${gatewayImageName} 使用老镜像号为 ${gatewayTag}"
            }
            if (!list.contains(adminImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", adminImageName)
                adminTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${adminImageName} 使用老镜像号为 ${adminTag}"
            }
            if (!list.contains(txManagerImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", txManagerImageName)
                txManagerTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${txManagerImageName} 使用老镜像号为 ${txManagerTag}"
            }
            if (!list.contains(authImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", authImageName)
                authTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${authImageName} 使用老镜像号为 ${authTag}"
            }
            if (!list.contains(infoDeviceImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", infoDeviceImageName)
                infoDeviceTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${infoDeviceImageName} 使用老镜像号为 ${infoDeviceTag}"
            }
            if (!list.contains(infoSpaceImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", infoSpaceImageName)
                infoSpaceTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${infoSpaceImageName} 使用老镜像号为 ${infoSpaceTag}"
            }
            if (!list.contains(infoCarImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", infoCarImageName)
                infoCarTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${infoCarImageName} 使用老镜像号为 ${infoCarTag}"
            }
            if (!list.contains(infoPeopleImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", infoPeopleImageName)
                infoPeopleTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${infoPeopleImageName} 使用老镜像号为 ${infoPeopleTag}"
            }
            if (!list.contains(infoCommunityImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", infoCommunityImageName)
                infoCommunityTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${infoCommunityImageName} 使用老镜像号为 ${infoCommunityTag}"
            }
            if (!list.contains(statisticAnalysisImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", statisticAnalysisImageName)
                statisticAnalysisTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${statisticAnalysisImageName} 使用老镜像号为 ${statisticAnalysisTag}"
            }
            if (!list.contains(smartAnalysisImageName)) {
                def getTagUrl = tagUrl.replaceAll("IMAGE", smartAnalysisImageName)
                smartAnalysisTag = sh(script: "${getTagUrl}", returnStdout: true).trim()
                echo "${smartAnalysisImageName} 使用老镜像号为 ${smartAnalysisTag}"
            }

            helmDeploy(
                dry_run     : false,
                name        : "sc",
                chartDir    : "sc",
                namespace   : "sc-${SPRING_PROFILE}",
                registerImage       : "${registerImage}",
                gatewayImage       : "${gatewayImage}",
                adminImage       : "${adminImage}",
                txManagerImage       : "${txManagerImage}",
                authImage       : "${authImage}",
                infoDeviceImage       : "${infoDeviceImage}",
                infoSpaceImage       : "${infoSpaceImage}",
                infoCarImage       : "${infoCarImage}",
                infoPeopleImage       : "${infoPeopleImage}",
                infoCommunityImage       : "${infoCommunityImage}",
                statisticAnalysisImage       : "${statisticAnalysisImage}",
                smartAnalysisImage       : "${smartAnalysisImage}",
                registerTag         : "${registerTag}",
                gatewayTag         : "${gatewayTag}",
                adminTag         : "${adminTag}",
                txManagerTag         : "${txManagerTag}",
                authTag         : "${authTag}",
                infoDeviceTag         : "${infoDeviceTag}",
                infoSpaceTag         : "${infoSpaceTag}",
                infoCarTag         : "${infoCarTag}",
                infoPeopleTag         : "${infoPeopleTag}",
                infoCommunityTag         : "${infoCommunityTag}",
                statisticAnalysisTag         : "${statisticAnalysisTag}",
                smartAnalysisTag         : "${smartAnalysisTag}",
                username    : "${DOCKER_HUB_USER}",
                password    : "${DOCKER_HUB_PASSWORD}",
                dockerRegistryUrl    : "${dockerRegistryUrl}",
                profile     : "${SPRING_PROFILE}"
            )
            echo "[INFO] Helm 部署应用成功..."
          }
      }
    }
  }
}

tagUrl：获取Harbor镜像仓库某个镜像最新的tag号，新提交代码的服务可以使用

    def gitPre = sh(script: "git rev-parse --short HEAD", returnStdout: true).trim()
    def imageTag = "sc-${gitPre}"

git的CommitId作为tag号，并构建新的镜像上传到Harbor，没有更新代码的服务没必要更新镜像上传到Harbor，只要获取到上次上传的最新的tag号，就能在helm upgrade --install更新服务时，不更新这个老服务

wnfee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在CI/CD中演示前端三种部署方案，镜像部署，服务器部署，OSS部署
知无涯
09-01 3635
在CI/CD中演示前端三种部署方案，镜像部署，服务器部署，OSS部署 这是一次总结。废话不说直接上代码 .gitlab-ci.yml image: node:latest stages: - install - code-lint - build - deploy-test - deploy-uat - deploy-pro cache: paths: - node_modules install: stage: install script..
cicd持续集成全程_GitLabCI/CD自动集成和部署到远程服务器
weixin_39669982的博客
11-27 840
目的是通过一个示例应用程序对GitLab CI/CD进行友好的了解，该应用程序有助于入门，而无需阅读所有GitLab文档。持续集成的工作原理是：将小的代码块-commits-推送到Git存储库中托管的应用程序的代码库中，并且每次推送时，都要运行脚本管道来构建，测试和验证代码更改，然后再将其合并到主分支中。持续交付和部署包括进一步的CI，可在每次推送到存储库默认分支时将应用程序部署到生产环境。这些方...
Jenkins构建完成后自动部署到指定服务器（二）
09-16 889
主要分为两步： 1、发送Jenkins构建好的war包到指定服务器 2、执行部署脚本 这里是通过使用 publish over ssh 插件。 插件管理中搜索publish over ssh 安装，完成后系统设置中就可以看到相关设置项了。 Jenkins服务器上的公钥需要放到部署项目服务器上，可以使用ssh-add-id命令发送公钥到指定服务器。 Passphrase...
jenkins从开始搭建到多项目本机/远程部署。
my_interface的博客
06-21 493
【注意：在开始本教程前默认需要环境 jdk1.8 、 maven环境】 1.下载jenkins包，建议使用war包进行下载。推荐华为镜像下载，速度快 https://mirrors.huaweicloud.com/jenkins/war/latest/jenkins.war 2.下载完成之后，上传到服务器，可以直接用java -jar 启动，但是 推荐放到tomcat下面 进行启动。启动完成之后。会生成相应的秘钥，秘钥会在登录的时候，进行提示，秘钥的具体存储路径。 3.登录之后，建议先别安装插件，.
jenkins 多选参数构建配置
weixin_30821731的博客
08-21 1771
参考：https://blog.csdn.net/e295166319/article/details/54017231 场景： 有的时候，参数基本都是那几个，但是不变，但是参数名字比较长，不好记忆，写在jenkins使用说明中，由于参数比较多，感觉又会比较乱，比如下： ，这个时候就希望要是能有个多选框，直接要构建那几个选哪几个就好了。 步骤： 【基本参考开始的链接就可以实现了。...
CICD搭建准备——Jenkins实现自动部署
01-27
一.什么叫做Jenkins二.搭建Jenkins的目的三.Jenkins的特点四.产品发布的流程六.git搭建七.maven本地仓库搭建八....易于安装部署配置：可通过yum安装,或下载war包以及通过docker容器等快速实现安装部署，可方便
使用Jenkins部署React项目的方法步骤
10-17
在本文中，我们将探讨如何使用Jenkins部署React项目，这是一个自动化构建和部署的过程，可以极大地提高开发效率并减少人为错误。Jenkins作为一个流行的持续集成和持续部署(CI/CD)工具，可以帮助我们实现React项目的...
Jenkins自动化部署JavaWeb项目
01-27
Jenkins服务器请先安装JDK、Git、Maven等工具，并配置JAVA_...请确认部署项目的服务器可以外网访问或者与Jenkins服务器在同一内网，可以使用SSH访问（Windows安装OpenSSH参考我之前的文章） 官网下载地址： 可以下载
cicd-jenkins:CICD Jenkins将在K8S上部署项目
03-16
西德·詹金斯 CICD Jenkins将在K8S上部署项目
基于k8s-jenkins cicd部署文档.pdf
03-03
基于k8s-jenkins cicd部署文档
Jenkins 参数多选框配置
jf991804033的博客
05-25 4273
Jenkins 参数多选框配置 安装插件 Extended Choice Parameter plugin 1. 新建一个流水线项目 2.选择参数化构建，并选择Extended Choice Parameter选项 3.填写参数名称和描述 4.勾选Basic Parameter Types选项 填写参数 不要勾选Quote Value 勾选后输出的参数值为：echo ${names} 显示为<“zhangsan,lisi,wangwu”> 不勾选输出为：zhangsan,lisi,wa
利用Jenkins部署多分支的CI/CD管道
Docker的专栏
02-16 1013
简介Jenkins最初被称为Hudson，是由Kohsuke Kawaguchi编写的一个Java开源项目（部署和运行需要安装Java 8以上环境）。作为一个CI持续集成服务器，Jenk...
Jenkins CI/CD 持续集成、持续部署（微服务多项目部署、单项目部署）
m0_46803792的博客
02-14 537
Jenkins CI/CD 持续集成、持续部署（微服务多项目部署、单项目部署）
Jenkins插件--参数设置单选框、多选框、Git分支框
学无止境,勤则可达；志存高远,恒亦能成！
10-24 1915
Jenkins通过maven-surefire-plugin 这个Maven插件来参数化执行TestNG。但是在实际工作中，构建项目时我想填写不同的参数，但又不想每次都去修改对应参数到输入框中，而是预设好数据，构建时直接去选择即可。所以查阅到参数单选框、多选框以及Git分支参数框的方法。
『中级篇』CI/CD持续集成/持续部署（69）
IT架构圈博客
10-04 345
原创文章，欢迎转载。转载请注明：转载自IT人故事会，谢谢！ 原文链接地址：『中级篇』CI/CD持续集成/持续部署（69） 从这次课就开始学习CI/CD，结合docker或者是使用k8s来完成。 CICD的理解 CICD是一个整套流程的解决方案，光依靠docker和k8s是完全不行的，中间涉及到很多CICD的工具，CI的服务器。 本地用github做代码的管理，Travis CI用于...
Jenkins参数设置单选框、多选框、Git分支框
一个Tester的博客
05-07 9684
目录前言一、单选框二、多选框三、Git分支下拉框 前言 在前面Jenkins如何参数化执行TestNG,这个Maven插件告诉你！这篇博客中，我们说到了Jenkins通过maven-surefire-plugin 这个Maven插件来参数化执行TestNG。但是在实际工作中，构建项目时我想填写不同的参数，但又不想每次都去修改对应参数到输入框中，而是预设好数据，构建时直接去选择即可。所以查阅到参数单...
jenkins同一项目多个服务器,Jenkins流水线--部署多模块maven项目（推荐）
weixin_39695306的博客
08-09 1989
最终Jenkins流水线各步骤分解Jenkins+Springboot+gitlab+maven+jdk+docker目录编写Jenkinsfile,Dockerfile,Deploy.sh创建jenkins流水线工程多模块maven项目结构大概如下：cfw-project #父工程-canfu-eureka #子工程(1)-canfu-provider #子工程(2)-canfu-su...
jenkins参数化构建过程（添加多选框）
热门推荐
起个名字好难啊
01-04 4万+
1，首先增加Jenkisn插件 https://wiki.jenkins-ci.org/display/JENKINS/Extended+Choice+Parameter+plugin  需要安装插件“Extended Choice Parameter plugin”,它可以扩展参数化构建过程，直接在管理界面增加。  比如一个工程下面有多个服务的时候需要参数部署，比如maven下面有
自动部署 管道 ci cd_每个产品只有一条CI / CD管道来统治它们
cumo7370的博客
07-10 220
自动部署 管道 ci cd 当我加入WorkSafeBC负责云运营和工程流程精简的云运营团队时，我实现了我的梦想，希望拥有一个仪器化管道，并为每个产品进行一次持续集成并持续交付。 根据Lukas Klose的说法， 流程 （在软件工程范围内）是“系统以稳定且可预测的速度产生价值的状态。” 我认为这是最大的挑战和机遇之一，尤其是在紧急解决方案的复杂领域。 力求通过持续，高效和优质的解决方案，提...
Jenkins 部署前端项目到Windows服务器
最新发布
04-29
首先，你需要安装 Jenkins 和 Node.js 环境，并且在 Windows 服务器上安装 IIS（Internet Information Services）服务器。 接下来，你可以按照以下步骤来配置 Jenkins 部署前端项目到 Windows 服务器： 1. 在 Jenkins 中创建一个新的任务，选择 “自由风格项目” 作为任务类型。 2. 在任务配置页面中，选择 “源码管理” 选项卡，并配置你的前端项目代码库的 URL 和分支信息。 3. 在 “构建触发器” 选项卡中配置你的自动化构建触发条件，例如每次代码提交到代码库时触发构建。 4. 在 “构建环境” 选项卡中配置 Node.js 环境，并安装必要的 Node.js 模块。 5. 在 “构建” 选项卡中配置你的构建命令，例如 “npm install” 和 “npm run build”。 6. 在 “构建后操作” 选项卡中配置你的构建结果的处理方式，例如将构建生成的文件上传到 IIS 服务器。 7. 安装 Jenkins 插件 “Publish Over SSH”，并配置你的 Windows 服务器的 SSH 连接信息。 8. 在 “构建后操作” 选项卡中添加 “Send files or execute commands over SSH” 操作，配置上传文件到 IIS 服务器的路径和命令。 9. 点击 “保存” 按钮保存配置，并手动触发一次构建来测试部署过程是否成功。 以上就是在 Jenkins 中部署前端项目到 Windows 服务器的步骤，希望能对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值