note15：jenkins部署

已于 2023-03-06 15:20:23 修改
阅读量166 收藏
点赞数
分类专栏： 投产部署 文章标签： jenkins 运维 Powered by 金山文档
于 2023-03-06 15:18:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44960008/article/details/129050129
版权

jenkinsfile：用代码部署流水线

groovy语法 pipeline

// We use current date for image/helm versioning.
import java.text.SimpleDateFormat
// Pipeline root
pipeline {    
    agent any    
    // Define some project-dependent variables 项目依赖变量    
    environment {        
        // OCP endpoint        
        OCP_API_SERVER_URL =       
        // OCP login credential        
        CREDENTIALS_ID_OCP = 'ocp-rikchong'        
        CREDENTIALS_OCP = credentials("${CREDENTIALS_ID_OCP}")        
        // Namespace of your app        
        APP_NAMESPACE = 'boc-app'        
        // App target environment: test/prod        
        APP_ENV = 'prod'        
        // SCM url for your app        
        GIT_URL = 
        GIT_BRANCH = 'master'        
        // SCM credential        
        CREDENTIALS_ID_GIT =         
        // Helm package root        
        HELM_PATH = 'cicd/k8s/helm'        
        // Helm chart release name        
        HELM_RELEASE_NAME  = 'boc-app'        
        // Timeout settings        
        APP_STARTUP_WAIT_TIMEOUT = 20        
        OCP_BUILD_CONFIG_NAME = 'boc-app'    
        }    
    stages {        
    // OCP login        
    stage('OCP login') {            
        steps {                
            script {                    
                timeout("$APP_STARTUP_WAIT_TIMEOUT") {                        
                    waitUntil {                            
                        def test = sh (
                            script: "oc login ${OCP_API_SERVER_URL} -u ${CREDENTIALS_OCP_USR} -p ${CREDENTIALS_OCP_PSW} -n ${APP_NAMESPACE} --insecure-skip-tls-verify",                                                
                            returnStatus: true)                            
        return test == 0                        
        }}                    
        sh "oc project ${APP_NAMESPACE}"                
        }}}        
        // Apply build config && trigger build        
        stage('SCM Checkout') {            
            steps {                
                script {     
                    def scmVars = checkout([      
                        $class: 'GitSCM',      
                        branches: [[name: "$GIT_BRANCH"]],      
                        doGenerateSubmoduleConfigurations: false,      
                        extensions: [],      
                        submoduleCfg: [],      
                        userRemoteConfigs: [[       
                            credentialsId: "$CREDENTIALS_ID_GIT",       
                            url: "$GIT_URL"      ]]     ])                }            }        }        
       // Apply build config && trigger build        
       stage('OCP Build') {            
            steps {                
                script {                    
                // Check for running builds                    
                def running = sh(                        
                    script: "oc get build -l openshift.io/build-config.name=$OCP_BUILD_CONFIG_NAME | awk '{ print \$4 }' | grep -E 'Pending|Running|New' | wc -l",                        
                returnStdout: true                    
                ).trim()                    
                println "current building task num:" + running                                   //IMAGE_TAG                    
                def sdf = new SimpleDateFormat("yyMMddHHmmss")                                  sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"))                          env.IMAGE_TAG = "r" + sdf.format(new Date())                                     //build in OCP                    
                def lastBuild = ""                    
                if (running == "0") {                        
                    println "====ocp start build ..."                        
                    sh "cat cicd/buildconfig/$APP_ENV/buildconfig.yaml"                                sh "sed 's/app_image_tag/'$IMAGE_TAG'/' cicd/buildconfig/$APP_ENV/buildconfig.yaml"                        
                       sh "sed 's/app_image_tag/'$IMAGE_TAG'/' cicd/buildconfig/$APP_ENV/buildconfig.yaml | oc apply -f -"                        
                       sh "oc start-build $OCP_BUILD_CONFIG_NAME"                    }                    
lastBuild = sh(                        
script: "oc get bc ${OCP_BUILD_CONFIG_NAME} -o jsonpath={.status.lastVersion}",                        returnStdout: true                    
)                    
lastBuild = "${OCP_BUILD_CONFIG_NAME}-" + lastBuild                    
println "====> build name: " + lastBuild                    
//check build result                    
def buildResult = ""                    
timeout(20) {                        
waitUntil(quiet: true) {                            
buildResult = sh(                                
script: "oc get build " + lastBuild + " -o jsonpath={.status.phase}",                                returnStdout: true                            
).trim()                            
return buildResult == 'Complete' || buildResult == 'Failed'                        }                    }                    
if (buildResult != 'Complete') {                        
currentBuild.result = 'ABORTED'                        
def buildLog = sh(                            
script: "oc logs " + lastBuild + "-build",                            
returnStdout: true                        
)                        
error("====> build fail OCP buildconfig buildLog:\n" + buildLog)                    }                    
//get src version                    
def gitCommit = sh(                        
script: "oc get build " + lastBuild + " -o jsonpath={.spec.revision.git.commit} | cut -b 1-8",                        
returnStdout: true                    
).trim()                    
println "====> build completed git commit:" + gitCommit                    
env.REVISION_AND_DATE = env.IMAGE_TAG + "-" + gitCommit                    
env.RELEASE_LABEL = "released=" + env.REVISION_AND_DATE                    
env.RELEASE_LABEL_YAML = "released: " + env.REVISION_AND_DATE                   env.CHART_VERSION = "1.0.0-" + gitCommit + "." + sdf.format(new Date())                }            }        }        
// Deploy application        
stage('App deploy') {            
steps {                
script {                    
// Create a 'Chart.yaml' from Chart.template.yaml, by replacing version number.                    sh "sed 's/version: .*/version: ${CHART_VERSION}/' ${HELM_PATH}/Chart.template.yaml > ${HELM_PATH}/Chart.yaml"                    
// Create a 'values.yaml' from values-<APP_ENV>.yaml, by replacing image.tag (witch we just built)                    
// For example, we just pushed image myclusterd.icp:8500/tgxt/tgxt:r190709, now we need to tell helm chart with tag r190709.                    
sh "sed 's/tag: app-default-tag/tag: ${IMAGE_TAG}/' ${HELM_PATH}/values-${APP_ENV}.yaml > ${HELM_PATH}/values.yaml"                    
// Test our chart package                    
sh "helm lint --strict $HELM_PATH"                    
sh "helm upgrade ${HELM_RELEASE_NAME} ${HELM_PATH} --install"                }            }        }        
// Application initialization        
stage('Check application') {            
steps {                
script {                    
// Find first available pod                    
def timeoutValue = "$APP_STARTUP_WAIT_TIMEOUT"                    
def pod                    
timeout(timeoutValue) {                        
waitUntil {                            
sh 'oc get po -l app.kubernetes.io/instance=${HELM_RELEASE_NAME},helm.sh/version=${CHART_VERSION}'                            
// Find pod id                            
pod = sh (                                
script: 'oc get po -l app.kubernetes.io/instance=${HELM_RELEASE_NAME},helm.sh/version=${CHART_VERSION} 2>/dev/null | grep "Running" | awk \'{ print $1 }\'',                                returnStdout: true                            
).trim()                            
return pod != ""                        }                    }                    println 'Found running pod: ' + pod + ', pipeline done!'                }            }        }    }}

（复制过来的，缩进有点乱）

values.prod 一些赋值

# Default values for helm.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

env: prod
replicaCount: 1

image:
  repository: 
  tag: app-default-tag
  pullPolicy: Always
  pullSecrets: ""

nameOverride: ""
fullnameOverride: ""

memcached:
  enabled: false
  containerName: memcached
  port: 11211
  image:
    repository: 
    tag: latest
    pullPolicy: IfNotPresent

service:
  type: NodePort
  ports:
    - targetPort: 8080
      port: 8080
      nodePort: ""
      protocol: TCP
      name: 

route:
  enabled: true
  host: 
  targetPort: 8080
  annotations:
    openshift.io/host.generated: true

ingress:
  enabled: true
  annotations:
    ingress.kubernetes.io/proxy-body-size: 200m
  paths:
    - path: /
      servicePort: 8080
  hosts:
    - 
  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.local

persistence:
  enabled: true
  ## A manually managed Persistent Volume and Claim
  ## Requires persistence.enabled: true
  ## If defined, PVC must be created manually before volume will be bound
  existingClaim: dg-prac-pvc
  ## jenkins data Persistent Volume Storage Class
  ## If defined, storageClassName: <storageClass>
  ## If set to "-", storageClassName: "", which disables dynamic provisioning
  ## If undefined (the default) or set to null, no storageClassName spec is
  ##   set, choosing the default provisioner.  (gp2 on AWS, standard on
  ##   GKE, AWS & OpenStack)
  ##
  storageClass: gpfs-storage-csi
  annotations: {}
  accessMode: "ReadWriteMany"
  size: "10Gi"
  mounts:
    - mountPath: /opt/logs
      name: 
      claimName: 

resources: {}
  # We usually recommend not to specify default resources and to leave this as a conscious
  # choice for the user. This also increases chances charts run on environments with little
  # resources, such as Minikube. If you do want to specify resources, uncomment the following
  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
  # limits:
  #  cpu: 100m
  #  memory: 128Mi
  # requests:
#  cpu: 100m
#  memory: 128Mi

nodeSelector: {}

tolerations: []

affinity: {}

hostAliases: {}

buildconfig.yaml:

kind: BuildConfig
apiVersion: build.openshift.io/v1
metadata:
  name: 
spec:
  nodeSelector: null
  output:
    to:
      kind: DockerImage
      name: 
    pushSecret:
      name: registry

  resources:
    limits:
      cpu: '1'
      memory: 2Gi
  successfulBuildsHistoryLimit: 5
  failedBuildsHistoryLimit: 5
  strategy:
    type: Source
    sourceStrategy:
      from:
        kind: DockerImage
        name: 
      pullSecret:
        name: registry
      env:
        - name: ANT_ARGS
          value: 
        - name: APP_ENV
          value: prod
        - name: APP_DIR
          value: cicd/k8s/docker/app
  postCommit: {}
  source:
    type: Git
    git:
      uri:       
      ref: master
    sourceSecret:
      name: 
  #此配置不要 会生成两个节点
#  triggers:
#    - type: ConfigChange
  runPolicy: Serial

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "helm.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "helm.name" . }}
    helm.sh/chart: {{ include "helm.chart" . }}
    helm.sh/version: "{{ .Chart.Version }}"
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app.kubernetes.io/name: {{ include "helm.name" . }}
      app.kubernetes.io/instance: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: {{ include "helm.name" . }}
        app.kubernetes.io/instance: {{ .Release.Name }}
        helm.sh/version: "{{ .Chart.Version }}"
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
          {{- range .Values.service.ports }}
            - containerPort: {{ .targetPort }}
              protocol: {{ .protocol }}
          {{- end }}
          {{- if .Values.persistence.enabled }}
          volumeMounts:
            {{- range .Values.persistence.mounts }}
            - name: {{ .name }}
              mountPath: {{ .mountPath }}
            {{- end }}
          {{- end }}
          env:
            - name: STARTUP_CMD
              value: /opt/ibm/wlp/bin/server run app
          resources:
            {{- toYaml .Values.resources | nindent 12 }}
        {{- if .Values.memcached.enabled }}
        - name: {{ .Values.memcached.containerName }}
          imagePullPolicy: {{ .Values.memcached.image.pullPolicy }}
          image: "{{ .Values.memcached.image.repository }}:{{ .Values.memcached.image.tag }}"
          ports:
            - containerPort: {{ .Values.memcached.port }}
              protocol: TCP
        {{- end }}
      {{- if .Values.image.pullSecrets }}
      imagePullSecrets:
        - name: {{ .Values.image.pullSecrets }}
      {{- end }}
      {{- if .Values.persistence.enabled }}
      volumes:
        {{- range .Values.persistence.mounts }}
        - name: {{ .name }}
          persistentVolumeClaim:
            claimName: {{ .claimName }}
        {{- end }}
      {{- end }}
      {{- with .Values.nodeSelector }}
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
    {{- with .Values.affinity }}
      affinity:
        {{- toYaml . | nindent 8 }}
    {{- end }}
    {{- with .Values.tolerations }}
      tolerations:
        {{- toYaml . | nindent 8 }}
    {{- end }}
    {{- with .Values.hostAliases }}
      hostAliases:
        {{- toYaml . | nindent 8 }}
    {{- end }}

service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: {{ include "helm.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "helm.name" . }}
    helm.sh/chart: {{ include "helm.chart" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  type: {{ .Values.service.type }}
  ports:
  {{- range .Values.service.ports }}
    - port: {{ .port }}
      targetPort: {{ .targetPort }}
      protocol: {{ .protocol}}
      name: {{ .name}}
      {{- if .nodePort }}
      nodePort: {{ .nodePort }}
      {{- end }}
  {{- end }}
  selector:
    app.kubernetes.io/name: {{ include "helm.name" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}

ingress.yaml:

{{- if .Values.ingress.enabled -}}
{{- $fullName := include "helm.fullname" . -}}
{{- $ingressPaths := .Values.ingress.paths -}}
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: {{ $fullName }}
  labels:
    app.kubernetes.io/name: {{ include "helm.name" . }}
    helm.sh/chart: {{ include "helm.chart" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
  {{- with .Values.ingress.annotations }}
  annotations:
    {{- toYaml . | nindent 4 }}
  {{- end }}
spec:
{{- if .Values.ingress.tls }}
  tls:
  {{- range .Values.ingress.tls }}
    - hosts:
      {{- range .hosts }}
        - {{ . | quote }}
    {{- end }}
    secretName: {{ .secretName }}
  {{- end }}
{{- end }}
  rules:
  {{- range .Values.ingress.hosts }}
    - host: {{ . | quote }}
      http:
        paths:
        {{- range $ingressPaths }}
          - path: {{ .path }}
            backend:
              serviceName: {{ $fullName }}
              servicePort: {{ .servicePort }}
        {{- end }}
  {{- end }}
{{- end }}

pvc.yaml:

{{- if and .Values.persistence.enabled (not .Values.persistence.existingClaim) -}}
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
{{- if .Values.persistence.annotations }}
  annotations:
{{ toYaml .Values.persistence.annotations | indent 4 }}
{{- end }}
  name: {{ template "helm.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "helm.name" . }}
    helm.sh/version: "{{ .Chart.Version }}"
    helm.sh/chart: {{ include "helm.chart" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  accessModes:
    - {{ .Values.persistence.accessMode | quote }}
  resources:
    requests:
      storage: {{ .Values.persistence.size | quote }}
{{- if .Values.persistence.storageClass }}
{{- if (eq "-" .Values.persistence.storageClass) }}
  storageClassName: ""
{{- else }}
  storageClassName: "{{ .Values.persistence.storageClass }}"
{{- end }}
{{- end }}
{{- end }}

注：仍需要在ocp上手动新建sourcesecret，

猜测原因：新建sourcesecret不是每次部署都需要进行的操作？sourcesecret里包含了账号密码，不能明文写在代码里？

香菜代言人Coco
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
releaseNotes-plugin:Jenkins插件将更改日志写入文件
05-24
这个插件对于持续集成和持续部署(CI/CD)环境尤其有用，因为它可以帮助团队追踪代码修改的历史，方便审计、问题排查和版本控制。 **插件功能详解** 1. **变更日志输出**：Jenkins在每次构建时会记录所有相关的变更...
MyNote:简单笔记应用
05-16
开发者可能还使用了持续集成(CI)和持续部署(CD)工具，如Jenkins或Travis CI，以自动化构建、测试和发布流程，确保每次提交的代码都能正常工作，并且可以快速地将更新推送到用户手中。 综上所述，MyNote应用展示了...
4.Jenkins 2 权威指南 --- 通知与报告
enlyhua的专栏
05-19 734
在流水线中发送电子邮件: node('worker_node1') { try { ... currentBuild.result = 'SUCCESS' } catch (err) { currentBuild.result = 'FAILURE' } finally { mail to : 'test@qq.com', subject: "Status of p...
Jenkins pipeline基本用法
热门推荐
阿尔泰野狼的博客
02-05 1万+
原新浪博客（http://blog.sina.com.cn/billsona）搬迁至此。 文章目录前言一、一个简单的pipeline二、when关键字三、currentBuild.result四、credentials应用 前言 近期项目中用到了pipeline，支用过程中有一些感触，借此做一下总结。 随着DevOps的日趋火热，pipeline的关注度也逐渐水涨船高。 先说一下自己的感触，之前用jenkins的时候，一直使用的是普通自由风格的project，这种用法简单方便，并且相关的资料也更多，更成
Jenkins 用户手册 - 开始使用 Pipeline
kikajack的博客
03-04 7081
原文地址 如前所述，Jenkins Pipeline 是一套插件，支持将持续交付流水线实施并集成到 Jenkins 中。Pipeline 提供了一组可扩展的工具，用于通过 Pipeline DSL 将简单到复杂的交付管道“作为代码”进行建模。 本章讲述如何入门并在 Jenkins 中创建你自己的 Pipeline 项目，并介绍创建和保存 Jenkinsfile 的多种方式。 1. 先决条...
jenkins报SSH: Current build result is [NOT_BUILT], not going to run.错误
weixin_49978753的博客
08-03 2486
jenkins报SSH: Current build result is [NOT_BUILT], not going to run.
在pipeline中修改Jenkins Job的执行状态
最新发布
乱码奇糟
08-22 481
在pipeline中设置Job的执行状态
update Jenkins build status（更新jenkins的build状态）
CoberOJ_的博客
10-14 5272
近日在研究怎么更新jenkins job的状态，常用状态有几种：SUCCESS,UNSTABLE,FAILURE,ABORTED 发现可以在pipeline脚本中自主修改job的状态，例如currentBuild.result = 'FAILURE'，即可将job状态改为FAILURE，但是发现Jenkins一个机制，只能由好的状态改为更坏的状态，SUCCESS<UNSTABLE<F...
note:git note存储库
03-10
10. **持续集成/持续部署（CI/CD）**：虽然这不是笔记管理的常规需求，但对于需要自动化处理笔记的项目，如生成静态网站或构建知识图谱，可以利用Git的CI/CD工具，如Jenkins或GitHub Actions。 综上所述，Git Note...
Note:笔记
03-17
【标题】: "Note: 笔记" 【描述】: "这个笔记集合涵盖了广泛的IT知识领域，包括但不限于编程语言、操作系统、数据库管理、网络技术、软件工程和数据分析等。通过这些笔记，学习者可以深入理解各种概念和技术，提升...
cloud_note:云笔记毕设
05-16
项目可能利用Jenkins或GitLab CI/CD等工具，实现代码提交后自动构建、测试和部署，确保代码质量并缩短发布周期。 五、安全性考虑 1. 数据加密：敏感信息如用户密码可能经过加密处理，确保数据安全。 2. SQL注入防护...
jenkins报错SSH: Current build result is [NOT_BUILT], not going to run.
ZhanBiaoChina的博客
04-29 5081
jenkins在构建maven项目后，进行SSH远程推送的时候报错： SSH: Current build result is [NOT_BUILT], not going to run. 解决方法： 1.确认是否安装了Fail The Build Plugin插件,没有则需要先安装下插件. 该插件用于设置或更改构建状态,测试jenkins配置的行为. 2.在jenkins工程配置“Pre Steps”选项添加"set then build result". 这一步是将构建好的maven项目状态结果从N
Jenkins- Jenkins的代理
qq_22648091的博客
05-26 5060
一、Jenkins 代理介绍 代理就是 Jenkins 干活的地方，就是你准备让Jenkins 在那个地方完成你给它设定的任务。 代理可以安装 Jenkins 的服务器(自己)，通常成为 master， 也可以是一个 slave， 也可以是一个Docker 的容器，还可以是一个 kubernetes 的 Pod. 1 在 Pipeline 中设置代理 在 Pipeline 中设置代理的方式式通过 agent 声明 全局代理和阶段代理 全局代理 agent 出现在 pipeline 块内的顶层，就是全局代理
jenkinsfile+helmfile流水线架构模版pipline
weixin_45290734的博客
08-22 1597
目前趋势都是微服务架构，k8s服务基本普及，helm作为管理k8s包用起来也非常方便， 接下来我将我线上用的一套基于jenkins+helmfile的架构上传以便后期翻阅和学习。 首先为什么用helmfile？Helm 作为 Kubernetes 的包管理工具在业界被广泛使用。但在实际使用场景中的一些需求 helm 并不能很好的满足。 1.Helm 不提供 apply 命令 2.Values 必须是纯文本；不支持模板渲染、不方便区分环境。 helmfile就基本能满足我们的需求 1。首先对于代码，我们每个微
持续集成：Jenkins pipeline全局变量
测试开发小记
03-19 1万+
在编写Jenkins Pipeline脚本时，需要使用到一些全局变量，比如环境变量jenkins URL、项目地址，保存在env变量中（字符串类型），可以在Jenkins Pipeline或者其它Jenkinsfile中使用这些变量。本文介绍jenkins 中env、params、currentBuild和manager这几种全局变量。
【Jenkins】流水线捕获异常（try-catch-finally/catchError）
qq_35472206的博客
12-08 4256
一般情况下，在流水线中只要一个步骤执行失败，则后续流程都会skip，为了能够区分流水线出现问题的具体原因、或者在执行失败时可以进行某些特定操作、或者希望异常代码块后面的构建可以继续执行，我们可以对流水线进行异常捕获。本文主要提供两种捕捉异常的方式：try-catch-finally和catchError，相比之下catchError的使用方法更简单，try-catch-finally可以自定义捕捉到异常之后进行的操作，可以根据个人情况进行选择。
「Jenkins Pipeline」- 放弃当前构建 @20210303
k4nz
03-03 778
问题描述 在 Jenkins Pipeline 中，（1）我们希望放弃某次构建，（2）但是又不希望显示失败，而是返回 ABORTED 状态。 解决办法 if (!continueBuild) { currentBuild.result = 'ABORTED' error('Stopping early…') } 所有状态值，参考 jenkins/Result.java at master · jenkinsci/jenkins 文件。 参考文献 Abort curren.
Jenkins 内置全局变量
sankgao 的博客
09-09 5437
Jenkins 内置全局变量
SSH: Current build result is [NOT_BUILT], not going to run.
weixin_41653901的博客
01-24 4115
解决方法： 安装Fail The Build Plugin插件 安装成功后重启，在任务配置中设置这个为成功 报错的原因不明，但能明确maven构建成功了，war包也生成了，网上搜了一圈没有找到原因，甚至像一个bug，通过Fail The Build Plugin插件手动设置构建结果为成功使后面ssh脚本继续执行 ...
实战教程：Jenkins快速部署与使用详解
"Jenkins 实操部署指南" Jenkins是一个广泛使用的持续集成(CI)工具，由Java编写，其核心功能是自动化各种软件开发任务，包括构建、测试和部署。它支持多种版本控制系统（如Git）、构建工具（如Maven、Gradle）以及...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值