Loading [MathJax]/jax/output/CommonHTML/config.js
前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >Jenkins Pipeline脚本优化：为Kubernetes应用部署增加状态检测

Jenkins Pipeline脚本优化：为Kubernetes应用部署增加状态检测

原创
作者头像
对你无可奈何
发布于 2023-12-21 08:25:01
发布于 2023-12-21 08:25:01
6790
举报
文章被收录于专栏：运维专栏运维专栏
关联问题
换一批

引言

在软件部署的世界中，Jenkins已经成为自动化流程的代名词。不断变化的技术环境要求我们持续改进部署流程以满足现代应用部署的需要。在本篇博客中，作为一位资深运维工程师，我将分享如何将Jenkins Pipeline进化至不仅能支持部署应用直至Running状态检测，同时也能兼顾Deployment和StatefulSet资源的轮询更新，并详细介绍滚动更新策略的配置方法。

初始Jenkins Pipeline分析

参照前文：Jenkins Pipeline 脚本优化实践：从繁琐到简洁，初始化pipeline如下：

代码语言：bash
AI代码解释
复制
pipeline {
    agent none // Use none at the top level, each stage will define its own agent.

    environment {
        REGISTRY = "swr.cn-north-4.myhuaweicloud.com/master-metaspace"
        KUBE_CONFIG = "--namespace=master-metaspace --context=master"
        KUBE_YAML_PATH = "/home/jenkins/workspace/yaml/master-metaspace"
        // Assume that 'data' is defined elsewhere or injected as a parameter.
        BASE_WORKSPACE = "xxxxxxx" // 定义一个基础工作空间路径
    }

    stages {
        stage("GetCode") {
            agent { label "build01" }
            steps {
                script {
                    checkout scm: [
                        $class: 'GitSCM',
                        branches: [[name: env.branchName]],
                        extensions: [[$class: 'CloneOption', depth: 1, noTags: false, shallow: true]],
                        userRemoteConfigs: [[credentialsId: 'xxxx', url: env.gitHttpURL]]
                    ]
                }
            }
        }
        
        stage("Docker Builds") {
            parallel {
                stage('Build dataloader-game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'dataloader', value: 'true' }
                    steps {
                        buildAndPushDockerImage("dataloader-game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
                stage('Build datawriter-game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'datawriter', value: 'true' }
                    steps {
                        buildAndPushDockerImage("datawriter-game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
                stage('Build game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'game-ucenter', value: 'true' }
                    steps {
                        buildAndPushDockerImage("game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
            }
        }
        
        stage('Development Deployment') {
            parallel {
                stage("Deploy datawriter-game-ucenter") {
                    when { environment name: 'datawriter-game-ucenter', value: 'true' }
                    agent { label  "huaweiyun-xx" }
                    steps {
                        deployToKubernetes("datawriter-game-ucenter")
                    }
                }
                stage("Deploy dataloader-game-ucenter") {
                    when { environment name: 'dataloader', value: 'true' }
                    agent { label  "huaweiyun-xx" }
                    steps {
                        deployToKubernetes("dataloader-game-ucenter")
                    }
                }
                stage("Deploy game-ucenter") {
                    when { environment name: 'game-ucenter', value: 'true' }
                    agent { label  "huaweiyun-xx" }
                    steps {
                        deployToKubernetes("game-ucenter")
                    }
                }
            }
        }
    }
}

// Define methods outside pipeline to avoid repetition

def buildAndPushDockerImage(String imageName, String tag, String workspacePath) {
    sh "cd ${workspacePath} && echo 'Current directory: \$(pwd)'" // 使用基础工作空间变量
    sh "cd ${workspacePath}/${imageName}&& docker build --build-arg NODE_ENV=$imageName -t $REGISTRY/$imageName:$tag ."
    withCredentials([usernamePassword(credentialsId: 'hw-registry', passwordVariable: 'dockerPassword', usernameVariable: 'dockerUser')]) {
        sh "docker login -u $dockerUser -p $dockerPassword $REGISTRY"
        sh "docker push $REGISTRY/$imageName:$tag"
    }
}

def deployToKubernetes(String kubernetesComponent) {
    String templateFile = "${KUBE_YAML_PATH}/${kubernetesComponent}.tpl"
    String outputFile = "${KUBE_YAML_PATH}/${kubernetesComponent}.yaml"
    sh "sed -e 's/{data}/$data/g' $templateFile > $outputFile"
    sh "sudo kubectl apply -f $outputFile $KUBE_CONFIG"
}

初始的Jenkins Pipeline定义了一个基本的CI/CD流程，涵盖了代码拉取、Docker镜像构建、推送及在Kubernetes环境中的部署。然而，流程中缺少了对部署状态的检查，这是在确保部署稳定性方面至关重要的一个环节。

进化 I：探针引入Deployment部署

现代应用部署不仅仅需要一个“部署到Kubernetes”的指令，更需要在部署后进行健康检查。对于Deployment类型的应用来说，我们需要在所有Pods运行并处于READY状态后才认为部署成功。

状态检测方法介绍

为此，我们引入了checkKubernetesResourceStatus方法来检查资源的状态。该方法通过kubectl的get命令和jsonpath查询输出来轮询检查ready副本数。如果指定时间内资源不达状态，则流程失败。

Jenkinsfile变更详解：

引入checkKubernetesResourceStatus方法来检测deployment各个阶段部署的状态。

代码语言：bash
AI代码解释
复制
def checkKubernetesResourceStatus(String deploymentName, String namespace) {
    int attempts = 30 // Set the number of retry attempts
    int sleepTime = 10 // Set the sleep time between attempts in seconds
    String readyReplicasJsonPath = ".status.readyReplicas"
    for (int i = 1; i <= attempts; i++) {
        // Check the deployment status
        String statusCheck = sh (
            script: "kubectl get deployment ${deploymentName} --namespace=${namespace} -o jsonpath=\"{${readyReplicasJsonPath}}\"",
            returnStdout: true
        ).trim()

        // If the number of ready replicas is not empty and greater than 0
        if (statusCheck && statusCheck.isInteger() && statusCheck.toInteger() > 0) {
            echo "Deployment ${deploymentName} is ready."
            return
        } else {
            echo "Waiting for Deployment ${deploymentName} to be ready. Attempt ${i}/${attempts}"
            sleep sleepTime
        }
    }
    error "Deployment ${deploymentName} did not become ready after ${attempts} attempts"
}

以Deploy game-ucenter stage为例：

代码语言：bash
AI代码解释
复制
                stage("Deploy game-ucenter") {
                    when { environment name: 'game-ucenter', value: 'true' }
                    agent { label  "xxxx" }
                    steps {
                        deployToKubernetes("game-ucenter")
                        checkKubernetesResourceStatus("game-ucenter", "master-metaspace")
                    }
                }

game-ucenter模板文件如下：

代码语言：bash
AI代码解释
复制
apiVersion: apps/v1
kind: Deployment
metadata:
  name: game-ucenter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: game-ucenter
  template:
    metadata:
      labels:
        app: game-ucenter
    spec:
      containers:
        - name: game-ucenter
          image: xxxxxx/xxxx/game-ucenter:{data}
          envFrom:
          - configMapRef:
              name: deploy
          ports:
            - containerPort: 80
          resources:
            requests:
              memory: "4096M"
              cpu: "2000m"
            limits:
              memory: "4096M"
              cpu: "2000m" 
          livenessProbe:
            httpGet:
              scheme: HTTP
              path: /test.html
              port: 80
            initialDelaySeconds: 20
            periodSeconds: 120
            successThreshold: 1
            failureThreshold: 3
          readinessProbe:
            httpGet:
              scheme: HTTP
              path: /test.html
              port: 80
            initialDelaySeconds: 20
            periodSeconds: 120
      imagePullSecrets:                                              
        - name: xxxx
---

apiVersion: v1
kind: Service
metadata:
  name: game-ucenter
  labels:
    app: game-ucenter
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: game-ucenter

尝试修改以下replicas: 3 重新运行以下pipeline：

也没有问题，pipeline 脚本有效！

进化 II：兼容StatefulSet的健康检查

考虑到某些应用可能采用StatefulSet作为工作负载类型，我们必须确保Jenkins Pipeline能够针对不同的工作负载类型执行健康检查。

状态检测兼容性改进

为了适配StatefulSet，我们对checkKubernetesResourceStatus方法做了略微修改，使其可以接受一个resourceType参数来区分资源类型，进而查询对应的状态字段，代码片段如下：

代码语言：bash
AI代码解释
复制
def checkKubernetesResourceStatus(String resourceName, String namespace, String resourceType) {
    int attempts = 30 // Set the number of retry attempts
    int sleepTime = 10 // Set the sleep time between attempts in seconds
    String readyReplicasJsonPath = resourceType == "deployment" ? ".status.readyReplicas" : ".status.readyReplicas"
    for (int i = 1; i <= attempts; i++) {
        // Check the resource status
        String statusCheck = sh (
            script: "kubectl get ${resourceType} ${resourceName} --namespace=${namespace} -o jsonpath=\"{${readyReplicasJsonPath}}\"",
            returnStdout: true
        ).trim()

        // If the number of ready replicas is not empty and equal to the desired number
        if (statusCheck && statusCheck.isInteger() && statusCheck.toInteger() > 0) {
            echo "${resourceType} ${resourceName} is ready."
            return
        } else {
            echo "Waiting for ${resourceType} ${resourceName} to be ready. Attempt ${i}/${attempts}"
            sleep(sleepTime)
        }
    }
    error "${resourceType} ${resourceName} did not become ready after ${attempts} attempts"
}

修改game-ucenter stage:

代码语言：bash
AI代码解释
复制
                stage("Deploy game-ucenter") {
                    when { environment name: 'game-ucenter', value: 'true' }
                    agent { label  "k8s-node-06" }
                    steps {
                        deployToKubernetes("game-ucenter")
                        checkKubernetesResourceStatus("game-ucenter", "master-metaspace", "deployment")
                    }
                }

创建一个statefulset datawriter-game-ucenter stage:

代码语言：bash
AI代码解释
复制
                stage("Deploy datawriter-game-ucenter") {
                    when { environment name: 'datawriter-game-ucenter', value: 'true' }
                    agent { label  "xxxxx" }
                    steps {
                        deployToKubernetes("datawriter-game-ucenter")
                        checkKubernetesResourceStatus("datawriter-game-ucenter", "master-metaspace", "statefulset")
                    }
                }

注意:我这里截图还是用了game-ucenter做的测试，其实我想用我的datawriter-game-ucenter，but这个服务是一个node应用没有没有livenessProbe readinessProbe，所以截图我还是使用了game-ucenter!

进化 III：引入滚动更新策略配置和检测

当我们更新Deployment资源时，通常会采用滚动更新策略，以逐步替换旧Pods，最小化部署时的中断。

更新策略检测逻辑

代码语言：bash
AI代码解释
复制
def checkDeploymentUpdateStatus(String deploymentName, String namespace) {
    int attempts = 30 // Set the number of retry attempts
    int sleepTime = 10 // Set the sleep time between attempts in seconds
    echo "Checking the update status of Deployment: ${deploymentName}"

    for (int i = 1; i <= attempts; i++) {
        String updateStatus = sh (
            script: "kubectl rollout status deployment/${deploymentName} --namespace=${namespace}",
            returnStdout: true
        ).trim()

        if (updateStatus.contains("successfully rolled out")) {
            echo "Update status: ${updateStatus}"
            return
        } else {
            echo "Waiting for Deployment ${deploymentName} to successfully roll out. Attempt ${i}/${attempts}"
            sleep(sleepTime)
        }
    }

    error "Deployment ${deploymentName} did not successfully roll out after ${attempts} attempts"
}
  1. 我们增加了checkDeploymentUpdateStatus方法，该方法通过kubectl命令rollout status监控Deployment的更新状态。
  2. 当检测到successfully rolled out时，表示滚动更新成功。
  3. 如果在给定时间内更新没有成功，则流程将失败。

继续考虑一下如果statefulset多实例呢？不想写两个了整合成一个方法如下：

代码语言：bash
AI代码解释
复制
def checkRolloutStatus(String resourceName, String namespace, String resourceType) {
    int attempts = 30 // Set the number of retry attempts
    int sleepTime = 10 // Set the sleep time between attempts in seconds

    if (!(resourceType in ["deployment", "statefulset"])) {
        error "Unknown resource type: ${resourceType}. Only 'deployment' and 'statefulset' are supported."
    }

    echo "Checking the update status of ${resourceType} '${resourceName}' in namespace '${namespace}'"

    for (int i = 1; i <= attempts; i++) {
        String rolloutCommand = "kubectl rollout status ${resourceType}/${resourceName} --namespace=${namespace}"
        String updateStatus = sh (
            script: rolloutCommand,
            returnStdout: true
        ).trim()

        if (updateStatus.contains("successfully rolled out") || updateStatus.contains("partitioned roll out complete"))  {
            echo "Update status: ${updateStatus}"
            return
        } else {
            echo "Waiting for ${resourceType} '${resourceName}' to successfully roll out. Attempt ${i}/${attempts}."
            sleep(sleepTime)
        }
    }

    error "${resourceType} '${resourceName}' did not successfully roll out after ${attempts} attempts in namespace '${namespace}'"
}

Jenkinsfile更新实现

经过上述进化，Jenkinsfile中现在包含了完整的部署状态检查逻辑，以应对不同类型资源的部署监控需求。

代码语言：groovy
AI代码解释
复制
pipeline {
    agent none // Use none at the top level, each stage will define its own agent.

    environment {
        REGISTRY = "ccr.ccs.tencentyun.com/xxxxx"
        KUBE_CONFIG = "--namespace=master-metaspace"
        KUBE_YAML_PATH = "/home/jenkins/workspace/yaml/master-metaspace"
        // Assume that 'data' is defined elsewhere or injected as a parameter.
        BASE_WORKSPACE = "xxxxxx" // 定义一个基础工作空间路径
    }

    stages {
        stage("GetCode") {
            agent { label "build01" }
            steps {
                script {
                    checkout scm: [
                        $class: 'GitSCM',
                        branches: [[name: env.branchName]],
                        extensions: [[$class: 'CloneOption', depth: 1, noTags: false, shallow: true]],
                        userRemoteConfigs: [[credentialsId: 'xxxxx', url: env.gitHttpURL]]
                    ]
                }
            }
        }
        
        stage("Docker Builds") {
            parallel {
                stage('Build dataloader-game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'dataloader-game-ucenter', value: 'true' }
                    steps {
                        buildAndPushDockerImage("dataloader-game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
                stage('Build datawriter-game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'datawriter-game-ucenter', value: 'true' }
                    steps {
                        buildAndPushDockerImage("datawriter-game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
                stage('Build game-ucenter') {
                    agent { label "build01" }
                    when { environment name: 'game-ucenter', value: 'true' }
                    steps {
                        buildAndPushDockerImage("game-ucenter", env.data, env.BASE_WORKSPACE)
                    }
                }
            }
        }
        
        stage('Development Deployment') {
            parallel {
                stage("Deploy datawriter-game-ucenter") {
                    when { environment name: 'datawriter-game-ucenter', value: 'true' }
                    agent { label  "xxxx" }
                    steps {
                        deployToKubernetes("datawriter-game-ucenter")
                        checkKubernetesResourceStatus("datawriter-game-ucenter", "master-metaspace", "statefulset")
                        checkRolloutStatus("datawriter-game-ucenter", "master-metaspace", "statefulset")
                    }
                }
                stage("Deploy dataloader-game-ucenter") {
                    when { environment name: 'dataloader-game-ucenter', value: 'true' }
                    agent { label  "xxxx" }
                    steps {
                        deployToKubernetes("dataloader-game-ucenter")
                        checkKubernetesResourceStatus("dataloader-game-ucenter", "master-metaspace", "statefulset")
                    }
                }
                stage("Deploy game-ucenter") {
                    when { environment name: 'game-ucenter', value: 'true' }
                    agent { label  "xxxx" }
                    steps {
                        deployToKubernetes("game-ucenter")
                        checkRolloutStatus("game-ucenter", "master-metaspace", "deployment")
                        checkKubernetesResourceStatus("game-ucenter", "master-metaspace", "deployment")
                    }
                }
            }
        }
    }
}

// Define methods outside pipeline to avoid repetition

def buildAndPushDockerImage(String imageName, String tag, String workspacePath) {
    sh "cd ${workspacePath} && echo 'Current directory: \$(pwd)'" // 使用基础工作空间变量
    sh "cd ${workspacePath}/${imageName}&& docker build --build-arg NODE_ENV=game-ucenter -t $REGISTRY/$imageName:$tag ."
    withCredentials([usernamePassword(credentialsId: 'xxxxx', passwordVariable: 'dockerPassword', usernameVariable: 'dockerUser')]) {
        sh "docker login -u $dockerUser -p $dockerPassword $REGISTRY"
        sh "docker push $REGISTRY/$imageName:$tag"
    }
}

def deployToKubernetes(String kubernetesComponent) {
    String templateFile = "${KUBE_YAML_PATH}/${kubernetesComponent}.tpl"
    String outputFile = "${KUBE_YAML_PATH}/${kubernetesComponent}.yaml"
    sh "sed -e 's/{data}/$data/g' $templateFile > $outputFile"
    sh "sudo kubectl apply -f $outputFile $KUBE_CONFIG"
}

def checkRolloutStatus(String resourceName, String namespace, String resourceType) {
    int attempts = 30 // 设置重试次数
    int sleepTime = 10 // 设置重试间隔时间（秒）

    if (!(resourceType in ["deployment", "statefulset"])) {
        error "未知资源类型：${resourceType}。只支持 'deployment' 和 'statefulset' 。"
    }

    echo "正在检查${resourceType} '${resourceName}' 在命名空间 '${namespace}' 的更新状态"

    for (int i = 1; i <= attempts; i++) {
        String rolloutCommand = "kubectl rollout status ${resourceType}/${resourceName} --namespace=${namespace}"
        try {
            String updateStatus = sh (
                script: rolloutCommand,
                returnStdout: true
            ).trim()

            // 添加对 "partitioned roll out complete" 状态的检查
            if (updateStatus.contains("successfully rolled out") || updateStatus.contains("partitioned roll out complete")) {
                echo "更新状态：${updateStatus}"
                return
            } else {
                echo "等待 ${resourceType} '${resourceName}' 成功发布。尝试次数：${i}/${attempts}。"
                sleep(sleepTime)
            }
        } catch (Exception e) {
            echo "获取更新状态时发生错误：${e.getMessage()}。尝试次数：${i}/${attempts}。"
            sleep(sleepTime)
        }
    }

    error "${resourceType} '${resourceName}' 在命名空间 '${namespace}' 内未能在 ${attempts} 次尝试之后成功发布"
}
def checkKubernetesResourceStatus(String resourceName, String namespace, String resourceType) {
    int attempts = 30 // Set the number of retry attempts
    int sleepTime = 10 // Set the sleep time between attempts in seconds
    String readyReplicasJsonPath = resourceType == "deployment" ? ".status.readyReplicas" : ".status.readyReplicas"
    for (int i = 1; i <= attempts; i++) {
        // Check the resource status
        String statusCheck = sh (
            script: "kubectl get ${resourceType} ${resourceName} --namespace=${namespace} -o jsonpath=\"{${readyReplicasJsonPath}}\"",
            returnStdout: true
        ).trim()

        // If the number of ready replicas is not empty and equal to the desired number
        if (statusCheck && statusCheck.isInteger() && statusCheck.toInteger() > 0) {
            echo "${resourceType} ${resourceName} is ready."
            return
        } else {
            echo "Waiting for ${resourceType} ${resourceName} to be ready. Attempt ${i}/${attempts}"
            sleep(sleepTime)
        }
    }
    error "${resourceType} ${resourceName} did not become ready after ${attempts} attempts"
}// 更新后的Jenkins Pipeline代码详细定义参照本文开头给出的代码

总结

本篇博客通过对Jenkins Pipeline的进化过程展开讲解，展现了如何从简单的部署任务转变为一个健壮且兼顾各类工作负载状态监测的CI/CD流程。我们强化了状态检测的逻辑，引入了更新策略的检测，并保持了对不同Kubernetes资源类型的兼容性。这些改进确保了自动化流程能够与现代部署实践保持同步，给运维团队带来极大便利，并最大化地保障了部署的可靠性。

后记

由于篇幅限制，本篇文章未作其他更详细演示。然而，在实际应用中，运维团队可以根据自己的具体需求和环境进一步丰富和细化每个步骤的实现，确保Pipeline的健壮性和高可用性，以适应不断变化的技术挑战。以上实验中使用了腾讯云的镜像仓库服务，kubernetes集群环境使用了Tke服务！

我正在参与2023腾讯技术创作特训营第四期有奖征文，快来和我瓜分大奖！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

devops
jenkins
2023腾讯·技术创作特训营 第四期
容器服务
kubernetes

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

devops
jenkins
2023腾讯·技术创作特训营 第四期
容器服务
kubernetes
#tke
#kubernetes
#devops
#jenkins
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
编辑精选文章
换一批
万字详解高可用架构设计
2708
Go 开发者必备：Protocol Buffers 入门指南
1580
10分钟带你彻底搞懂分布式链路跟踪
1055
多租户的 4 种常用方案
2256
亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？
1513
60页PPT全解：DeepSeek系列论文技术要点整理
2628
Jenkins Pipeline 脚本优化实践：从繁琐到简洁
jenkinschatgptjenkins-groovyjenkins-pipeline2023腾讯·技术创作特训营 第四期
在持续集成的过程中，Jenkins Pipeline 是非常关键的一环。它定义了如何自动编译、测试和部署代码。随着项目的不断发展，Pipeline 的复杂性也在不断上升，这就需要我们持续优化 Pipeline 脚本，以提高代码的可读性和维护性。本文将介绍一次从繁琐Pipeline脚本到精简Pipeline脚本的转化过程，以及这种转化所带来的好处。
对你无可奈何
2023/12/12
9483
使用Jenkins和单个模板部署多个Kubernetes组件
kubernetesjenkins2023腾讯·技术创作特训营 第四期
在持续集成和部署中，我们通常需要部署多个实例或组件到Kubernetes集群中。通过Jenkins的管道脚本，我们可以自动化这个过程。在本文中，我将演示如何使用Jenkins Pipeline及单个YAML模板文件（.tpl）来部署多个类似的Kubernetes组件，而不需要为每个组件提供单独的模板文件。
对你无可奈何
2023/12/29
4550
打造企业级自动化运维平台系列（六）：Jenkins Pipeline 入门及使用详解
pipeline脚本入门自动化运维jenkins
作为一种流行的持续集成和交付工具，Jenkins有多种方式来实现交付流水线。其中，Jenkins Pipeline是一种比较流行的方式，它提供了一个DSL（Domain Specific Language 的缩写，中文翻译为：领域特定语言）来描述交付流水线。
民工哥
2024/01/18
2.6K0
打造企业级自动化运维平台系列（六）：Jenkins Pipeline 入门及使用详解
Jenkins Pipeline用户权限管理新技巧：打造安全高效的流水线！
pipeline管理技巧权限安全
基于角色的访问控制（Role-based access control，简称 RBAC），指的是通过用户的角色（Role）授权其相关权限，这实现了更灵活的访问控制，相比直接授予用户权限，要更加简单、高效、可扩展。
用户1107783
2024/05/25
2480
Jenkins Pipeline用户权限管理新技巧：打造安全高效的流水线！
史诗级整理 Jenkins 流水线详解
jenkinsagentinputpipelinepost
jenkins 有 2 种流水线分为声明式流水线与脚本化流水线，脚本化流水线是 jenkins 旧版本使用的流水线脚本，新版本 Jenkins 推荐使用声明式流水线。文档只介绍声明流水线。
我的小碗汤
2023/03/19
8.1K0
史诗级整理 Jenkins 流水线详解
Jenkins Pipeline演进
jenkins
生产环境都部署在kubernetes集群上，使用jenkins打包镜像并部署在kubernetes集群中。关于jenkins的安装参照：https://duiniwukenaihe.github.io/2019/11/19/k8s-install-jenkins/。当然了也有helm的安装方式https://duiniwukenaihe.github.io/2021/03/31/Kubernetes-1.20.5-helm-%E5%AE%89%E8%A3%85jenkins/。
对你无可奈何
2021/05/11
1K0
kubernetes 基于jenkins spinnaker的ci/cd实践一增加制品镜像扫描
jenkins安全漏洞漏洞扫描服务
早期jenkins承担了kubernetes中的ci/cd全部功能Jenkins Pipeline演进,这里准备将cd持续集成拆分出来到spinnaker!
对你无可奈何
2021/11/20
1.1K0
Jenkins file一行代码部署.NET程序到K8S
jenkinskubernetes.netasp.net
随着微服务的增多，每个项目的都需要pipline文件，这样的话Pipeline代码冗余度高，并且pipeline的功能越来越复杂。
Chester Chen
2022/08/18
6540
Jenkins file一行代码部署.NET程序到K8S
2.Jenkins进阶之流水线pipeline语法入门学习
jenkinsgroovyapache编程算法
Q: 什么是 Groovy 语言 答: Groovy 是 Apache 旗下的一门基于 JVM 平台的动态/敏捷编程语言，在语言的设计上它吸纳了 Python、Ruby 和 Smalltalk 语言的优秀特性，语法非常简练和优美，开发效率也非常高（编程语言的开发效率和性能是相互矛盾的，越高级的编程语言性能越差，因为意味着更多底层的封装，不过开发效率会更高，需结合使用场景做取舍）
全栈工程师修炼指南
2022/09/29
18.1K0
2.Jenkins进阶之流水线pipeline语法入门学习
最全教程 | Kubernetes + Jenkins + Helm + Springboot 实践
jenkins容器镜像服务gitgithub开源
为了方便集成 Maven、Kubernetes、配置文件等等，这里需要安装几个别的插件,这里插件可以在 系统管理—>插件管理—>可选插件 里面安装下面列出的插件。
我的小碗汤
2019/12/27
8.9K0
最全教程 | Kubernetes + Jenkins + Helm + Springboot 实践
『Jenkins』使用Jenkins Pipeline脚本详解与实例
腾讯技术创作特训营S11#重启人生
Jenkins作为一种广泛使用的CI/CD工具，为开发团队提供了强大的自动化功能，其中Jenkins Pipeline是一项至关重要的特性。通过Pipeline脚本，开发者可以定义复杂的构建、测试、部署流程，并实现自动化管理。
数字扫地僧
2025/01/20
5030
使用 Jenkins Pipeline 流水线部署 Kubernetes 应用
容器镜像服务容器kubernetesjenkins
要实现在 Jenkins 中的构建工作，可以有多种方式，我们这里采用比较常用的 Pipeline 这种方式。Pipeline，简单来说，就是一套运行在 Jenkins 上的工作流框架，将原来独立运行于单个或者多个节点的任务连接起来，实现单个任务难以完成的复杂流程编排和可视化的工作。
我是阳明
2021/06/25
5.3K0
使用 Jenkins Pipeline 流水线部署 Kubernetes 应用
Kubesphere DevOps组件 创建CI/CD流水线
kubernetes
DevOps 提供一系列持续集成 (CI) 和持续交付 (CD) 工具，可以使 IT 和软件开发团队之间的流程实现自动化。在 CI/CD 工作流中，每次集成都通过自动化构建来验证，包括编码、发布和测试，从而帮助开发者提前发现集成错误，团队也可以快速、安全、可靠地将内部软件交付到生产环境。
全栈研发知识库
2025/01/21
3180
【Jenkins系列】-Pipeline语法全集
脚本配置语法jenkinspipeline
parameters指令提供用户在触发Pipeline时的参数列表。这些参数值通过该params对象可用于Pipeline步骤
DevOps在路上
2023/05/16
2.1K0
【Jenkins系列】-Pipeline语法全集
Jenkins + Pipeline 构建流水线发布
jenkins
Jenkins + Pipeline 构建流水线发布 利用Jenkins的Pipeline配置发布流水线 参考： https://jenkins.io/doc/pipeline/tour/deplo
shaonbean
2018/01/02
1.3K0
Jenkins + Pipeline 构建流水线发布
Kubernetes中spinnaker的使用一
kubernetescci 持续集成
spinnaker 1.26.6 on kubernetes，现在想到的做的跟jenkins流水线联动（添加多个jenkins环境配置）and 多kubernetes集群配置。
对你无可奈何
2021/11/12
5410
Gitlab+Jenkins+k8s+Helm 的自动化部署实践
jenkins容器镜像服务腾讯云测试服务
本文从实践角度介绍如何结合我们常用的 Gitlab 与 Jenkins，通过 K8s 来实现项目的自动化部署，示例将包括基于 SpringBoot 的服务端项目与基于 Vue.js 的 Web 项目。
kubernetes中文社区
2021/11/12
3.8K0
Jenkins中使用pipeline
httpnode.jsjenkins编程算法
如同工厂的生产线，每个节点只关注自己的任务，然后流向下一个节点。 我们在编排jenkins时，也可以使用这种思想。
赵云龙龙
2019/09/17
2.8K0
Jenkins中使用pipeline
Kubernetes中spinnaker使用二
kubernetescci 持续集成jenkins
紧跟Kubernetes中spinnaker的使用一。完成了简单的各种Triggers触发器，还有deploy Mainfest部署一个kubernetes的简单流水线。这里根据实际的环境想更深入一下流水线步骤:参数化的构建，webhook的触发，邮件的发送,jenkins流水线的集成等等
对你无可奈何
2021/11/17
9690
基于Jenkins Pipeline构建企业级CI/CD
pipeline镜像配置jenkinsci
本设计通过Jenkins Generic Webhook Trigger 插件实现了基于Webhook自动触发流水线构建。
用户1107783
2024/05/21
2320
基于Jenkins Pipeline构建企业级CI/CD
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
相关讨论
生产环境中kubernetes中如何部署jenkins主从节点？gitlab pipeline 状态问题？使用加固以后，APP启动时间增加了3倍，怎么优化？
相关课程
轻量应用构建训练营数字化IT从业者知识体系云原生降本增效实战营
Jenkins Pipeline 脚本优化实践：从繁琐到简洁
9483
使用Jenkins和单个模板部署多个Kubernetes组件
4550
打造企业级自动化运维平台系列（六）：Jenkins Pipeline 入门及使用详解
2.6K0
Jenkins Pipeline用户权限管理新技巧：打造安全高效的流水线！
2480
史诗级整理 Jenkins 流水线详解
8.1K0
Jenkins Pipeline演进
1K0
kubernetes 基于jenkins spinnaker的ci/cd实践一增加制品镜像扫描
1.1K0
Jenkins file一行代码部署.NET程序到K8S
6540
2.Jenkins进阶之流水线pipeline语法入门学习
18.1K0
最全教程 | Kubernetes + Jenkins + Helm + Springboot 实践
8.9K0
『Jenkins』使用Jenkins Pipeline脚本详解与实例
5030
使用 Jenkins Pipeline 流水线部署 Kubernetes 应用
5.3K0
Kubesphere DevOps组件 创建CI/CD流水线
3180
【Jenkins系列】-Pipeline语法全集
2.1K0
Jenkins + Pipeline 构建流水线发布
1.3K0
Kubernetes中spinnaker的使用一
5410
Gitlab+Jenkins+k8s+Helm 的自动化部署实践
3.8K0
Jenkins中使用pipeline
2.8K0
Kubernetes中spinnaker使用二
9690
基于Jenkins Pipeline构建企业级CI/CD
2320
相关推荐
Jenkins Pipeline 脚本优化实践：从繁琐到简洁
更多 >
对你无可奈何0
LV.5
无业游民运维工程师
文章
201
获赞
897
排名
146
专栏
2
作者相关精选
换一批
加入讨论
的问答专区 >
Lethehong0
相关课程
一站式学习中心 >
轻量应用构建训练营
2991人在学
云服务器
轻量应用服务器
云计算
数字化IT从业者知识体系
396人在学
CODING DevOps
软件开发
云原生降本增效实战营
270人在学
容器
容器服务
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
3
2
目录