基于Jenkins和Argocd实现CI/CD

最新推荐文章于 2024-09-03 14:47:45 发布
最新推荐文章于 2024-09-03 14:47:45 发布
阅读量2.6k 收藏 8
点赞数
分类专栏： CI/CD 文章标签： jenkins ci kubernetes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanger5354/article/details/122302549
版权

微信公众号：运维开发故事，作者：乔克

CI/CD并不是陌生的东西，大部分企业都有自己的CI/CD，不过今天我要介绍的是使用Jenkins和GitOps实现CI/CD。

整体架构如下：

图片

devops.png

涉及的软件以及版本信息如下：

软件版本
kubernetes1.17.9
docker19.03.13
jenkins2.249.3
argocd1.8.0
gitlab社区版11.8.1
sonarqube社区版8.5.1
traefik2.3.3
代码仓库阿里云仓库

涉及的技术：

  • Jenkins shareLibrary

  • Jenkins pipeline

  • Jenkinsfile

  • Argocd

  • sonarqube api操作

软件安装

软件安装我这里不贴具体的安装代码了，所有的代码我都放在了github上，地址：https://github.com/cool-ops/kubernetes-software-yaml.git

所以这里默认你已经安装好所以软件了。

在Jenkins上安装如下插件

  • kubernetes

  • AnsiColor

  • HTTP Request

  • SonarQube Scanner

  • Utility Steps

  • Email Extension Template

  • Gitlab Hook

  • Gitlab

在Jenkins上配置Kubernetes集群信息

在系统管理–>系统配置–>cloud

图片

image.png

在Jenkins上配置邮箱地址

系统设置–>系统配置–>Email

（1）设置管理员邮箱

图片

image.png

配置SMTP服务

图片

image.png

在Gitlab上准备一个测试代码

我这里有一个简单的java测试代码，地址如下：https://gitee.com/jokerbai/springboot-helloworld.git

可以将其导入到自己的gitlab仓库。

在Gitlab上创建一个共享库

首先在gitlab上创建一个共享库，我这里取名叫shareLibrary，如下：

图片

image.png

然后创建src/org/devops目录，并在该目录下创建一下文件。

图片

image.png

它们的内容分别如下：

build.groovy

package org.devops

// docker容器直接build
def DockerBuild(buildShell){
    sh """
        ${buildShell}
    """
}

sendEmail.groovy

package org.devops

//定义邮件内容
def SendEmail(status,emailUser){
    emailext body: """
            <!DOCTYPE html> 
            <html> 
            <head> 
            <meta charset="UTF-8"> 
            </head> 
            <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0"> 
                <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">   
                <tr>
                    本邮件由系统自动发出，无需回复！<br/>
                    各位同事，大家好，以下为${JOB_NAME}项目构建信息</br>
                    <td><font color="#CC0000">构建结果 - ${status}</font></td>
                </tr>

                    <tr> 
                        <td><br /> 
                            <b><font color="#0B610B">构建信息</font></b> 
                        </td> 
                    </tr> 
                    <tr> 
                        <td> 
                            <ul> 
                                <li>项目名称：${JOB_NAME}</li>         
                                <li>构建编号：${BUILD_ID}</li> 
                                <li>构建状态: ${status} </li>                         
                                <li>项目地址：<a href="${BUILD_URL}">${BUILD_URL}</a></li>    
                                <li>构建日志：<a href="${BUILD_URL}console">${BUILD_URL}console</a></li>   
                            </ul> 
                        </td> 
                    </tr> 
                    <tr>  
                </table> 
            </body> 
            </html>  """,
            subject: "Jenkins-${JOB_NAME}项目构建信息 ",
            to: emailUser
        
}

sonarAPI.groovy

package ore.devops

// 封装HTTP请求
def HttpReq(requestType,requestUrl,requestBody){
    // 定义sonar api接口
    def sonarServer = "http://sonar.devops.svc.cluster.local:9000/api"
    result = httpRequest authentication: 'sonar-admin-user',
            httpMode: requestType,
            contentType: "APPLICATION_JSON",
            consoleLogResponseBody: true,
            ignoreSslErrors: true,
            requestBody: requestBody,
            url: "${sonarServer}/${requestUrl}"
    return result
}

// 获取soanr项目的状态
def GetSonarStatus(projectName){
    def apiUrl = "project_branches/list?project=${projectName}"
    // 发请求
    response = HttpReq("GET",apiUrl,"")
    // 对返回的文本做JSON解析
    response = readJSON text: """${response.content}"""
    // 获取状态值
    result = response["branches"][0]["status"]["qualityGateStatus"]
    return result
}

// 获取sonar项目，判断项目是否存在
def SearchProject(projectName){
    def apiUrl = "projects/search?projects=${projectName}"
    // 发请求
    response = HttpReq("GET",apiUrl,"")
    println "搜索的结果：${response}"
    // 对返回的文本做JSON解析
    response = readJSON text: """${response.content}"""
    // 获取total字段，该字段如果是0则表示项目不存在,否则表示项目存在
    result = response["paging"]["total"]
    // 对result进行判断
    if (result.toString() == "0"){
        return "false"
    }else{
        return "true"
    }
}

// 创建sonar项目
def CreateProject(projectName){
    def apiUrl = "projects/create?name=${projectName}&project=${projectName}"
    // 发请求
    response = HttpReq("POST",apiUrl,"")
    println(response)
}

// 配置项目质量规则
def ConfigQualityProfiles(projectName,lang,qpname){
    def apiUrl = "qualityprofiles/add_project?language=${lang}&project=${projectName}&qualityProfile=${qpname}"
    // 发请求
    response = HttpReq("POST",apiUrl,"")
    println(response)
}

// 获取质量阈ID
def GetQualityGateId(gateName){
    def apiUrl = "qualitygates/show?name=${gateName}"
    // 发请求
    response = HttpReq("GET",apiUrl,"")
    // 对返回的文本做JSON解析
    response = readJSON text: """${response.content}"""
    // 获取total字段，该字段如果是0则表示项目不存在,否则表示项目存在
    result = response["id"]
    return result
}

// 更新质量阈规则
def ConfigQualityGate(projectKey,gateName){
    // 获取质量阈id
    gateId = GetQualityGateId(gateName)
    apiUrl = "qualitygates/select?projectKey=${projectKey}&gateId=${gateId}"
    // 发请求
    response = HttpReq("POST",apiUrl,"")
    println(response)
}

//获取Sonar质量阈状态
def GetProjectStatus(projectName){
    apiUrl = "project_branches/list?project=${projectName}"
    response = HttpReq("GET",apiUrl,'')
    
    response = readJSON text: """${response.content}"""
    result = response["branches"][0]["status"]["qualityGateStatus"]
    
    //println(response)
    
   return result
}

sonarqube.groovy

package ore.devops

def SonarScan(projectName,projectDesc,projectPath){
    // sonarScanner安装地址
    def sonarHome = "/opt/sonar-scanner"
    // sonarqube服务端地址
    def sonarServer = "http://sonar.devops.svc.cluster.local:9000/"
    // 以时间戳为版本
    def scanTime = sh returnStdout: true, script: 'date +%Y%m%d%H%m%S'
    scanTime = scanTime - "\n"
    sh """
    ${sonarHome}/bin/sonar-scanner  -Dsonar.host.url=${sonarServer}  \
    -Dsonar.projectKey=${projectName}  \
    -Dsonar.projectName=${projectName}  \
    -Dsonar.projectVersion=${scanTime} \
    -Dsonar.login=admin \
    -Dsonar.password=admin \
    -Dsonar.ws.timeout=30 \
    -Dsonar.projectDescription="${projectDesc}"  \
    -Dsonar.links.homepage=http://www.baidu.com \
    -Dsonar.sources=${projectPath} \
    -Dsonar.sourceEncoding=UTF-8 \
    -Dsonar.java.binaries=target/classes \
    -Dsonar.java.test.binaries=target/test-classes \
    -Dsonar.java.surefire.report=target/surefire-reports -X 

    echo "${projectName}  scan success!"
    """
}

tools.groovy

package org.devops

//格式化输出
def PrintMes(value,color){
    colors = ['red'   : "\033[40;31m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m",
              'blue'  : "\033[47;34m ${value} \033[0m",
              'green' : "[1;32m>>>>>>>>>>${value}>>>>>>>>>>[m",
              'green1' : "\033[40;32m >>>>>>>>>>>${value}<<<<<<<<<<< \033[0m" ]
    ansiColor('xterm') {
        println(colors[color])
    }
}


// 获取镜像版本
def createVersion() {
    // 定义一个版本号作为当次构建的版本，输出结果 20191210175842_69
    return new Date().format('yyyyMMddHHmmss') + "_${env.BUILD_ID}"
}


// 获取时间
def getTime() {
    // 定义一个版本号作为当次构建的版本，输出结果 20191210175842
    return new Date().format('yyyyMMddHHmmss')
}

在Gitlab上创建一个YAML管理仓库

我这里创建了一个叫devops-cd的共享仓库，如下：

图片

image.png

然后以应用名创建一个目录，并在目录下创建以下几个文件。

图片

image.png

它们的内容分别如下。

service.yaml

kind: Service
apiVersion: v1
metadata:
  name: the-service
  namespace: default
spec:
  selector:
    deployment: hello
  type: NodePort
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

ingress.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: the-ingress 
  namespace: default
spec:
  rules:
    - host: test.coolops.cn 
      http:
        paths:
          - backend:
              serviceName: the-service 
              servicePort: 8080 
            path: /

deploymeny.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: the-deployment
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      deployment: hello
  template:
    metadata:
      labels:
        deployment: hello
    spec:
      containers:
        - args:
            - -jar
            - /opt/myapp.jar
            - --server.port=8080
          command:
            - java
          env:
            - name: HOST_IP
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: status.hostIP
          image: registry.cn-hangzhou.aliyuncs.com/rookieops/myapp:latest
          imagePullPolicy: IfNotPresent
          lifecycle:
            preStop:
              exec:
                command:
                  - /bin/sh
                  - -c
                  - /bin/sleep 30
          livenessProbe:
            failureThreshold: 3
            httpGet:
              path: /hello
              port: 8080
              scheme: HTTP
            initialDelaySeconds: 60
            periodSeconds: 15
            successThreshold: 1
            timeoutSeconds: 1
          name: myapp
          ports:
            - containerPort: 8080
              name: http
              protocol: TCP
          readinessProbe:
            failureThreshold: 3
            httpGet:
              path: /hello
              port: 8080
              scheme: HTTP
            periodSeconds: 15
            successThreshold: 1
            timeoutSeconds: 1
          resources:
            limits:
              cpu: "1"
              memory: 2Gi
            requests:
              cpu: 100m
              memory: 1Gi
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
      dnsPolicy: ClusterFirstWithHostNet
      imagePullSecrets:
        - name: gitlab-registry

kustomization.yaml

# Example configuration for the webserver
# at https://github.com/monopole/hello
commonLabels:
  app: hello

resources:
- deployment.yaml
- service.yaml
- ingress.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
images:
- name: registry.cn-hangzhou.aliyuncs.com/rookieops/myapp
  newTag: "20201127150733_70"
namespace: dev

在Jenkins上配置共享库

（1）需要在Jenkins上添加凭证

图片

image.png

（2）在Jenkins的系统配置里面配置共享库（系统管理–>系统配置）

图片

image.png

然后点击应用并保存

然后我们可以用一个简单的Jenkinsfile测试一下共享库，看配置是否正确。

在Jenkins上创建一个项目，如下：

图片

image.png

然后在最地下的pipeline处贴入以下代码：

def labels = "slave-${UUID.randomUUID().toString()}"
// 引用共享库
@Library("jenkins_shareLibrary")

// 应用共享库中的方法
def tools = new org.devops.tools()

pipeline {
    agent {
    kubernetes {
        label labels
      yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    some-label: some-label-value
spec:
  volumes:
  - name: docker-sock
    hostPath:
      path: /var/run/docker.sock
      type: ''
  containers:
  - name: jnlp
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/inbound-agent:4.3-4
  - name: maven
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/maven:3.5.0-alpine
    command:
    - cat
    tty: true
  - name: docker
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/docker:19.03.11
    command:
    - cat
    tty: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
"""
    }
  }
    stages {
        stage('Checkout') {
            steps {
                script{
                    tools.PrintMes("拉代码","green")
                }
            }
        }
        stage('Build') {
            steps {
                container('maven') {
                    script{
                        tools.PrintMes("编译打包","green")
                    }
                }
            }
        }
        stage('Make Image') {
            steps {
                container('docker') {
                    script{
                        tools.PrintMes("构建镜像","green")
                    }
                }
            }
        }
    }
}

然后点击保存并运行，如果看到输出有颜色，就代表共享库配置成功，如下：

图片

image.png

到此共享库配置完成。

编写Jenkinsfile

整个java的Jenkinsfile如下：

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

// 引用共享库
@Library("jenkins_shareLibrary")

// 应用共享库中的方法
def tools = new org.devops.tools()
def sonarapi = new org.devops.sonarAPI()
def sendEmail = new org.devops.sendEmail()
def build = new org.devops.build()
def sonar = new org.devops.sonarqube()

// 前端传来的变量
def gitBranch = env.branch
def gitUrl = env.git_url
def buildShell = env.build_shell
def image = env.image
def dockerRegistryUrl = env.dockerRegistryUrl
def devops_cd_git = env.devops_cd_git



pipeline {
    agent {
    kubernetes {
        label labels
      yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    some-label: some-label-value
spec:
  volumes:
  - name: docker-sock
    hostPath:
      path: /var/run/docker.sock
      type: ''
  - name: maven-cache
    persistentVolumeClaim:
      claimName: maven-cache-pvc
  containers:
  - name: jnlp
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/inbound-agent:4.3-4
  - name: maven
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/maven:3.5.0-alpine
    command:
    - cat
    tty: true
    volumeMounts:
    - name: maven-cache
      mountPath: /root/.m2
  - name: docker
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/docker:19.03.11
    command:
    - cat
    tty: true
    volumeMounts:
    - name: docker-sock
      mountPath: /var/run/docker.sock
  - name: sonar-scanner
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/sonar-scanner:latest
    command:
    - cat
    tty: true
  - name: kustomize
    image: registry.cn-hangzhou.aliyuncs.com/rookieops/kustomize:v3.8.1
    command:
    - cat
    tty: true
"""
    }
  }

    environment{
        auth = 'joker'
    }

    options {
        timestamps()    // 日志会有时间
        skipDefaultCheckout()   // 删除隐式checkout scm语句
        disableConcurrentBuilds()   //禁止并行
        timeout(time:1,unit:'HOURS') //设置流水线超时时间
    }


    stages {
        // 拉取代码
        stage('GetCode') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: "${gitBranch}"]],
                    doGenerateSubmoduleConfigurations: false,
                    extensions: [],
                    submoduleCfg: [],
                    userRemoteConfigs: [[credentialsId: '83d2e934-75c9-48fe-9703-b48e2feff4d8', url: "${gitUrl}"]]])
                }
            }

        // 单元测试和编译打包
        stage('Build&Test') {
            steps {
                container('maven') {
                    script{
                        tools.PrintMes("编译打包","blue")
                        build.DockerBuild("${buildShell}")
                    }
                }
            }
        }
        // 代码扫描
        stage('CodeScanner') {
            steps {
                container('sonar-scanner') {
                    script {
                        tools.PrintMes("代码扫描","green")
                        tools.PrintMes("搜索项目","green")
                        result = sonarapi.SearchProject("${JOB_NAME}")
                        println(result)

                        if (result == "false"){
                            println("${JOB_NAME}---项目不存在,准备创建项目---> ${JOB_NAME}！")
                            sonarapi.CreateProject("${JOB_NAME}")
                        } else {
                            println("${JOB_NAME}---项目已存在！")
                        }

                        tools.PrintMes("代码扫描","green")
                        sonar.SonarScan("${JOB_NAME}","${JOB_NAME}","src")

                        sleep 10
                        tools.PrintMes("获取扫描结果","green")
                        result = sonarapi.GetProjectStatus("${JOB_NAME}")

                        println(result)
                        if (result.toString() == "ERROR"){
                            toemail.Email("代码质量阈错误！请及时修复！",userEmail)
                            error " 代码质量阈错误！请及时修复！"

                        } else {
                            println(result)
                        }
                    }
                }
            }
        }
        // 构建镜像
        stage('BuildImage') {
            steps {
                withCredentials([[$class: 'UsernamePasswordMultiBinding',
                credentialsId: 'dockerhub',
                usernameVariable: 'DOCKER_HUB_USER',
                passwordVariable: 'DOCKER_HUB_PASSWORD']]) {
                    container('docker') {
                        script{
                            tools.PrintMes("构建镜像","green")
                            imageTag = tools.createVersion()
                            sh """
                            docker login ${dockerRegistryUrl} -u ${DOCKER_HUB_USER} -p ${DOCKER_HUB_PASSWORD}
                            docker build -t ${image}:${imageTag} .
                            docker push ${image}:${imageTag}
                            docker rmi ${image}:${imageTag}
                            """
                        }
                    }
                }
            }
        }
        // 部署
        stage('Deploy') {
            steps {
                 withCredentials([[$class: 'UsernamePasswordMultiBinding',
                credentialsId: 'ci-devops',
                usernameVariable: 'DEVOPS_USER',
                passwordVariable: 'DEVOPS_PASSWORD']]){
                    container('kustomize') {
                        script{
                            APP_DIR="${JOB_NAME}".split("_")[0]
                            sh """
                            git remote set-url origin http://${DEVOPS_USER}:${DEVOPS_PASSWORD}@${devops_cd_git}
                            git config --global user.name "Administrator"
                            git config --global user.email "coolops@163.com"
                            git clone http://${DEVOPS_USER}:${DEVOPS_PASSWORD}@${devops_cd_git} /opt/devops-cd
                            cd /opt/devops-cd
                            git pull
                            cd /opt/devops-cd/${APP_DIR}
                            kustomize edit set image ${image}:${imageTag}
                            git commit -am 'image update'
                            git push origin master
                            """
                        }
                    }
                }
            }
        }
        // 接口测试
        stage('InterfaceTest') {
            steps{
                sh 'echo "接口测试"'
            }
        }
    }
    // 构建后的操作
    post {
        success {
            script{
                println("success:只有构建成功才会执行")
                currentBuild.description += "\n构建成功！"
                // deploy.AnsibleDeploy("${deployHosts}","-m ping")
                sendEmail.SendEmail("构建成功",toEmailUser)
                // dingmes.SendDingTalk("构建成功 ✅")
            }
        }
        failure {
            script{
                println("failure:只有构建失败才会执行")
                currentBuild.description += "\n构建失败!"
                sendEmail.SendEmail("构建失败",toEmailUser)
                // dingmes.SendDingTalk("构建失败 ❌")
            }
        }
        aborted {
            script{
                println("aborted:只有取消构建才会执行")
                currentBuild.description += "\n构建取消!"
                sendEmail.SendEmail("取消构建",toEmailUser)
                // dingmes.SendDingTalk("构建失败 ❌","暂停或中断")
            }
        }
    }
}

需要在Jenkins上创建两个凭证，一个id叫dockerhub，一个叫ci-devops，还有一个叫sonar-admin-user。

dockerhub是登录镜像仓库的用户名和密码。

ci-devops是管理YAML仓库的用户名和密码。

sonar-admin-user是管理sonarqube的用户名和密码。

然后将这个Jenkinsfile保存到shareLibrary的根目录下，命名为java.Jenkinsfile。

图片

image.png

在Jenkins上配置项目

在Jenkins上新建一个项目，如下：

图片

image.png

然后添加以下参数化构建。

图片

image.png

图片

image.png

图片

image.png

图片

image.png

图片

image.png

图片

image.png

图片

image.png

然后在流水线处配置Pipeline from SCM

图片

image.png

图片

image.png

此处需要注意脚本名。

然后点击应用保存，并运行。

图片

image.png

也可以在sonarqube上看到代码扫描的结果。

图片

image.png

在Argocd上配置CD流程

在argocd上添加代码仓库，如下：

图片

image.png

图片

image.png

然后创建应用，如下：

图片

image.png

图片

image.png

点击创建后，如下：

图片

image.png

点进去可以看到更多的详细信息。

图片

image.png

argocd有一个小bug，它ingress的健康检查必须要loadBalance有值，不然就不通过，但是并不影响使用。

然后可以正常访问应用了。

图片

image.png

node项目的Jenkinsfile大同小异，由于我没有测试用例，所以并没有测试。

集成Gitlab，通过Webhook触发Jenkins

在Jenkins中选择项目，在项目中配置gitlab触发，如下：

图片

image.png

生成token，如下

图片

image.png

在gitlab上配置集成。进入项目–>项目设置–>集成

图片

image.png

配置Jenkins上生成的回调URL和TOKEN

图片

image.png

到此配置完成，然后点击下方test，可以观察是否触发流水线。

图片

image.png

也可以通过修改仓库代码进行测试。

写在最后

本片文章是纯操作步骤，大家在测试的时候可能会对Jenkinsfile做细微的调整，不过整体没什么问题。

公众号：运维开发故事

github：https://github.com/orgs/sunsharing-note/dashboard

爱生活，爱运维

如果你觉得文章还不错，就请点击右上角选择发送给朋友或者转发到朋友圈。您的支持和鼓励是我最大的动力。喜欢就请关注我吧~

图片

扫码二维码

关注我，不定期维护优质内容

温馨提示

如果你喜欢本文，请分享到朋友圈，想要获得更多信息，请关注我。

                                          ........................
运维开发故事
关注
专栏目录
基于Jenkins+Argocd+Argo Rollouts的DevOps实现并用金丝雀发布
wanger5354的博客
01-09 2305
文章会校对更新，公众号无法更新，可以关注一下博客：https://www.coolops.cn本文主要介绍使用Jenkins配合argocd以及argo rollouts实现CI/CD。其中jenkins配合argocd做CI/CD前面已经介绍过了，这里不再赘述，不懂的地方可以移步《使用Jenkins和Argocd实现CI/CD》。本篇文章新增了如下几个功能：优化argocd的触发CD的速度使用argo rollouts进行金丝雀发布给代码仓库打tag优化Argocd触发CD的速度Argo CD每三分钟轮询
微服务CI/CD实践（三）Jenkins部署及环境配置
lbmydream的博客
08-29 1443
微服务CI/CD实践系列： 微服务CI/CD实践（一）环境准备及虚拟机创建 微服务CI/CD实践（二）服务器先决准备 微服务CI/CD实践（三）gitlab部署及nexus3部署 微服务CI/CD实践（四）Jenkins部署及环境配置 微服务CI/CD实践（五）Jenkins + Dokcer 部署微服务后端项目 微服务CI/CD实践（六）Jenkins + Dokcer 部署微服务前端VUE项目 微服务CI/CD实践（七）Minio服务器部署及应用Jenkins是一个可持续集成、持续交互、持续部署的自
Jenkins+Argocd+Kubernetes+Gitlab+Harbor搭建CI/CD流程（六）之持续集成
CheChe294的博客
06-13 1795
刚接触CI/CD，想要快速搭建一套CI/CD流程？纯运维，开发基础很差，看不懂网上搭建CI/CD流程的例子？那么看这篇文章就对了，绝对的简单易懂且详细！
Jenkins+Argocd+Kubernetes+Gitlab+Harbor搭建CI/CD流程（七）之持续部署
CheChe294的博客
06-13 2058
刚接触CI/CD，想要快速搭建一套CI/CD流程？纯运维，开发基础很差，看不懂网上搭建CI/CD流程的例子？那么看这篇文章就对了，绝对的简单易懂且详细！
cd返回上一 git_使用Jenkins和Argocd实现CI/CD
weixin_29602351的博客
12-26 698
欢迎关注个人公众号：运维开发故事更多精彩内容等你来看。CI/CD并不是陌生的东西，大部分企业都有自己的CI/CD，不过今天我要介绍的是使用Jenkins和GitOps实现CI/CD。整体架构如下：涉及的软件以及版本信息如下：软件版本涉及的技术：Jenkins shareLibraryJenkins pipelineJenkinsfileArgocdsonarqube api操作软件安装软件安装我这...
Kubernetes+Gitlab+Jenkins+ArgoCD多集群部署
HYXRX的博客
11-22 1746
在企业级环境中,由于业务的需要会有许多Kubernetes集群需要管理,比如Dev环境,UAT环境,Pro环境等. 每次发布和上线都需要分别登录不同集群进行部署项目.如果我们使用了ArgoCD,它可以支持多集群部署,大大提高了效率和准确性. ArgoCD允许同时向多个集群部署应用,还可以轻松地管理不同环境的配置,轻松部署应用程序,提高生产效率.
云原生CI/CD工具对比
众安DevOps平台
03-13 750
在云原生时代下，传统的CI/CD工具的缺点越来越明显，基于Kubernetes 能力打造新的云原生CI/CD平台逐渐成为主流。
持续集成和持续部署（CI/CD）
最新发布
hongfu951的专栏
09-03 1031
## 1. 持续集成（CI） **定义**：持续集成是将代码变更自动测试并合并到共享代码库中的实践，每天多次进行。这一过程有助于在开发周期早期发现集成问题。 ### 关键组成部分： - **版本控制系统（VCS）**：CI 依赖 VCS（如 Git）来管理代码变更。开发者频繁地将代码变更推送到中央代码库。 - **自动化测试**：每次提交代码到代码库时，都会运行自动化测试。这些测试包括单元测试、集成测试和端到端测试，以确保新变更不会破坏现有功能。 - **构建自动化**：CI 工具在代码变更后自动构建
什么是 CI/CD？持续集成和持续交付解释
Yanan990830的博客
05-17 5677
持续集成 (CI) 和持续交付 (CD)，也称为 CI/CD，体现了应用程序开发团队用来更频繁、更可靠地交付代码更改的文化、操作原则和一组实践。 CI/CD 是dvoeps团队的最佳实验。这也是敏捷方法的最佳实践。通过自动化集成和交付，CI/CD 让软件开发团队专注于满足业务需求，同时确保代码质量和软件安全。
KubeSphere+Kubernetes+GitLab+Harbor+SonarQube构建企业CI/CD持续集成持续发布平台
背锅神童的博客
03-07 908
kubesphere、kubernetes、sonar、gitlab、CI/CD
Java版水果管理系统源码-pipeline-jenkins-argocd:管道詹金斯argocd
06-05
Java版水果管理系统源码 Get Started 本套发布cicd工具链应用于kubernetes服务发布，通过jenkins的pipeline，使用jenkinfile和argocd实现了对业务服务的打包、镜像制作推送和部署。借助于jenkins参数化功能，将项目信息选择和填写入参数后执行既可生成一个部署链。 requirements Jenkins 2.121+ helm chart template harbor repository kubernetes docker 注：本文不包含jenkins和argocd的部署 Architecture 仓库信息 Helm chart: https://github.com/wayne-beep/helm-chart-template.git 1. 创建初始化jenkins job jenkins创建统一pipeline类型初始化job（有必要为初始化job新建view。job名称，例：devops-init-jenkinsjob），使用pipeline script from SCM 模式的Git项配置初始化pipeline仓库地址
ArgoCD实战：从零到一搭建CI_CD流程
本节将重点介绍为什么选择ArgoCD作为CI/CD工具的原因，探讨其优势和适用场景，使读者能够了解ArgoCD的价值，并做出明智的选择。 ## 1.3 本文的结构和概览 最后，我们将概述本文的整体结构和各章节内容，为读者提供...
基于Jenkins + Argo 实现多集群的持续交付
KubeSphere
03-20 1693
前面我们已经掌握了如何通过 Jenkins + Argo CD 的方式实现单集群的持续交付，明白了整个 CI/CD 过程中不同工具在流水线中的关系。所以接下来我们将更深入的了解 Argo CD 的特性。KubeSphere DevOps 基于 Jenkins + Argo 实现单集群的持续交付实践。通过上述 List generator 的定义参数，对应好模版，这种类型都属于 Key/Values 类型。source:最后运行流水行以后，等待流水线执行完毕。
云原生时代：从 Jenkins 到 Argo Workflows，构建高效 CI Pipeline
阿里巴巴云原生的博客
06-05 1253
ACK One Serverless Argo 工作流作为全托管的 Argo 工作流服务，可以帮助您实现更大规模、具有更快的运行速度、及更低成本的 CI Pipeline，与 ACK One GitOps[8]（Argo CD）、Argo Event 等事件驱动架构可以构建完整的自动化 CI/CD Pipeline。
实战：k8s里通过argoCD部署jenkins-2023.7.24(测试成功)
weixin_39246554的博客
08-04 422
devops
Jenkins+Argocd+Kubernetes+Gitlab+Harbor搭建CI/CD流程（一）之流程介绍
CheChe294的博客
06-13 2162
刚接触CI/CD，想要快速搭建一套CI/CD流程？纯运维，开发基础不好，看不懂网上搭建CI/CD流程的例子？那么看这篇文章就对了，绝对的简单易懂且详细！
Jenkins+Argocd+Kubernetes+Gitlab+Harbor搭建CI/CD流程（五）之Jenkins搭建
CheChe294的博客
06-13 917
刚接触CI/CD，想要快速搭建一套CI/CD流程？纯运维，开发基础很差，看不懂网上搭建CI/CD流程的例子？那么看这篇文章就对了，绝对的简单易懂且详细！
Devops系列六（CI篇之jenkinsfile）jenkins将gitlab helm yaml和argocd 串联，自动部署到K8S
天草二十六
07-08 1835
上文我们说了pipeline，已为本文铺路不少，接下里就是将之串联起来。先想说下，为什么是jenkinsfile, 因为jenkins job还支持pipeline方式。这种方式，不建议实际使用，仅限于测试或调试groovy代码。下面贴出来，我们的使用方式。好处是：采用分布式的思想，改动git上的jenkinsfile，就可以让所有的job更新。
Bamboo与Jenkins：CI/CD工具深度对比
Bamboo是什么？ Bamboo是Atlassian公司开发的一款CI/CD工具，专为那些寻求更全面解决方案的企业设计。与Jenkins相比，Bamboo...在做出决定前，建议进行详细的评估和试点项目，以确保所选工具能够满足你的CI/CD需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值