1-jenkins流水线相关案例

已于 2024-05-23 18:54:27 修改
阅读量528 收藏 5
点赞数 3
分类专栏： Jenkins 文章标签： jenkins elasticsearch 运维
于 2024-05-09 22:54:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011197085/article/details/138635382
版权

案例一：

这个脚本包括从Git仓库拉取代码、进行Maven构建，并将构建好的jar包复制到指定服务器。

pipeline {
    agent any
    stages {
        stage('Prepare') {
            steps {
                script {
                    // 判断是否存在目录，没有则克隆，有则拉取
                    if (!fileExists('supervise-cloud')) {
                        echo "Cloning repository"
                        sh 'git clone ssh://git@192.168.0.99:9981/zhjg/zhengke/supervise-cloud.git'
                    } else {
                        echo "Pulling latest changes"
                        sh '''
                            cd supervise-cloud
                            git pull
                        '''
                    }
                }
            }
        }
        stage('Build') {
            steps {
                echo "Maven build start"
                sh '''
                    export MAVEN_HOME=/root/apache-maven-3.9.2
                    export JAVA_HOME=/usr/local/java/jdk-1.8.0
                    export PATH=$MAVEN_HOME/bin:$JAVA_HOME/bin:$PATH
                    cd supervise-cloud
                    mvn clean compile package -Dmaven.test.skip=true
                '''
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying artifacts"
                sh '''
                    scp supervise-cloud/supervise-auth/target/supervise-auth.jar root@192.168.0.106:/root
                    scp supervise-cloud/supervise-other-module/target/*.jar root@192.168.0.106:/root
                '''
            }
        }
    }
}

详细说明：

  1. Prepare 阶段：这个阶段会检查本地是否已经存在项目目录。如果不存在，则执行 git clone 克隆仓库；如果存在，则执行 git pull 拉取最新代码。
  2. Build 阶段：设置环境变量并进入项目目录，使用 Maven 进行构建。这里跳过了测试并且指定了项目和pom文件位置。
  3. Deploy 阶段：使用 scp 命令将构建好的 jar 包复制到远程服务器上。这里需要确保 Jenkins 服务器有权限访问目标服务器，并且ssh密钥已正确设置。

案例二:

需要在Jenkins流水线中停止supervise-gateway.jar应用，可以通过设置一个专门的停止阶段来实现。这个阶段将会使用kill命令或其他方式来停止正在运行的Java进程。

Jenkinsfile 示例

假设应用是通过一个Java命令启动的，并且知道这个应用相关的一些信息（如使用的jar文件名），你可以在Jenkins流水线中这样写：

pipeline {
    agent any

    stages {
        stage('Stop Application') {
            steps {
                script {
                    // 查找正在运行的Java应用的PID
                    sh '''
                    PID=$(ps aux | grep '[s]upervise-gateway.jar' | awk '{print $2}')
                    if [ -z "$PID" ]; then
                      echo "No application running."
                    else
                      echo "Stopping application with PID: $PID"
                      kill $PID
                      # 确认进程是否已经停止
                      while kill -0 $PID 2> /dev/null; do 
                        echo "Waiting for application to stop..."
                        sleep 1
                      done
                      echo "Application stopped."
                    fi
                    '''
                }
            }
        }
    }
}

这个流水线脚本做了以下几件事：

  1. 查找Java进程：使用ps和grep命令查找包含supervise-gateway.jar的Java进程。这里使用[s]upervise-gateway.jar的搜索模式是为了避免匹配grep命令自己的进程。

  2. 停止进程：使用kill命令发送终止信号到找到的进程ID。如果找到多个进程，这个脚本将会停止第一个找到的进程。

  3. 确认停止：脚本会检查进程是否停止，如果没有停止，它会每秒检查一次直到进程停止。

案例三：

要将 Jenkins 的工作目录名称设置为一个变量，你可以在 Jenkinsfile 的开始部分定义一个环境变量，并在整个流程中使用这个变量。这样，你可以在不同的情况下更容易地修改工作目录的名称。下面是如何修改你的 Jenkinsfile 来实现这一点：

pipeline {
    agent any
    environment {
        WORKSPACE_DIR = 'test' // 可以根据需要更改这个变量的值
    }
    stages {
        stage('Prepare') {
            steps {
                script {
                    // 检查目录是否存在，如果不存在则克隆，如果存在则从dev分支拉取最新代码
                    if (!fileExists('supervise-cloud')) {
                        echo "Cloning repository"
                        sh 'git clone -b dev ssh://git@192.168.0.99:9981/zhjg/zhengke/supervise-cloud.git'
                    } else {
                        echo "Pulling latest changes"
                        sh '''
                            cd supervise-cloud
                            git checkout dev
                            git pull
                        '''
                    }
                }
            }
        }
        stage('Build') {
            steps {
                echo "Maven build start"
                sh '''
                    export MAVEN_HOME=/root/apache-maven-3.9.2
                    export JAVA_HOME=/usr/local/java/jdk-1.8.0
                    export PATH=$MAVEN_HOME/bin:$JAVA_HOME/bin:$PATH
                    cd supervise-cloud
                    mvn clean compile package -Dmaven.test.skip=true
                '''
            }
        }
        stage('Deploy') {
            steps {
                script {
                    // 使用ssh连接到远程服务器，进行部署操作
                    sh '''
                        ssh -o StrictHostKeyChecking=no zhjgapp@192.168.0.108 << remotessh
                        if pgrep -f supervise-auth.jar; then
                            pkill -f supervise-auth.jar
                            echo "Application stopped"
                        else
                            echo "No running application found"
                        fi
                        if [ -f /home/zhjgapp/supervise-cloud/auth/supervise-auth.jar ]; then
                            mv /home/zhjgapp/supervise-cloud/auth/supervise-auth.jar /home/zhjgapp/supervise-cloud/back/supervise-auth-`date +%Y%m%d`.jar
                            echo "Old application backed up as supervise-auth-`date +%Y%m%d`.jar"
                        fi
                        exit
                        remotessh
                    '''
                    // 将新的jar文件scp到目标服务器
                    sh '''
                        scp -o StrictHostKeyChecking=no ${WORKSPACE_DIR}/supervise-cloud/supervise-auth/target/supervise-auth.jar zhjgapp@192.168.0.108:/home/zhjgapp/supervise-cloud/auth/
                    '''
                    // 重新登录到远程服务器启动新的应用
                    sh '''
                        ssh -o StrictHostKeyChecking=no zhjgapp@192.168.0.108 << remotessh
                        cd /home/zhjgapp/supervise-cloud/auth/
                        nohup java -Dfile.encoding=utf-8 -Xms512m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m -jar supervise-auth.jar > /dev/null 2>&1 &
                        echo "Application started"
                        exit
                        remotessh
                    '''
                }
            }
        }
    }
    post {
        always {
            echo "Pipeline execution complete"
        }
    }
}

这里，WORKSPACE_DIR 变量定义在 environment 块内，并在 scp 命令中使用 ${WORKSPACE_DIR} 来代替原先直接使用的目录名。你可以根据需要轻松更改 WORKSPACE_DIR 的值，以适应不同的部署或环境需求。

案例三完整版

pipeline {
    agent any
    environment {
        WORKSPACE_DIR = 'test-zhjg-supervise-gateway' //jenkins工作目录名称
    }
    stages {
        stage('Prepare') {
            steps {
                script {
                    // 检查目录是否存在，如果不存在则克隆，如果存在则从dev分支拉取最新代码
                    if (!fileExists('supervise-cloud')) {
                        echo "Cloning repository"
                        sh 'git clone -b dev ssh://git@192.168.0.99:9981/zhjg/zhengke/supervise-cloud.git'
                    } else {
                        echo "Pulling latest changes"
                        sh '''
                            cd supervise-cloud
                            git checkout dev
                            git pull
                        '''
                    }
                }
            }
        }
        stage('Build') {
            steps {
                echo "Maven build start"
                sh '''
                    export MAVEN_HOME=/root/apache-maven-3.9.2
                    export JAVA_HOME=/usr/local/java/jdk-1.8.0
                    export PATH=$MAVEN_HOME/bin:$JAVA_HOME/bin:$PATH
                    cd supervise-cloud
                    mvn clean compile package -Dmaven.test.skip=true
                '''
            }
        }
        stage('Deploy') {
            steps {
                script {
                    // 使用ssh连接到远程服务器，停止现有服务&备份jar包
                    sh '''
                        ssh -o StrictHostKeyChecking=no zhjgapp@192.168.0.108 << remotessh
                        if pgrep -f supervise-gateway.jar; then
                            pkill -f supervise-gateway.jar
                            echo "Application stopped"
                        else
                            echo "No running application found"
                        fi
                        if [ -f /home/zhjgapp/supervise-cloud/gateway/supervise-gateway.jar ]; then
                            mv /home/zhjgapp/supervise-cloud/gateway/supervise-gateway.jar /home/zhjgapp/supervise-cloud/back/supervise-gateway-`date +%Y%m%d-%H%M%S`.jar
                            echo "Old application backed up as supervise-gateway-`date +%Y%m%d-%H%M%S`.jar"
                        fi
                        # 删除超过30天的备份文件
                        find /home/zhjgapp/supervise-cloud/back/ -mtime +30 -type f -name '*.jar' -exec rm {} \\;
                        echo "Removed backups older than 30 days"
                        exit
                        remotessh
                    '''
                    
                    // 将新的jar文件scp到目标服务器
                    sh '''
                        scp -o StrictHostKeyChecking=no /root/.jenkins/workspace/${WORKSPACE_DIR}/supervise-cloud/supervise-gateway/target/supervise-gateway.jar zhjgapp@192.168.0.108:/home/zhjgapp/supervise-cloud/gateway/
                    '''
                    
                    // 重新登录到远程服务器启动新的应用
                    sh '''
                        ssh -o StrictHostKeyChecking=no zhjgapp@192.168.0.108 << remotessh
                        cd /home/zhjgapp/supervise-cloud/gateway/
                        nohup java -Dspring.profiles.active=test -Dfile.encoding=utf-8 -Xms512m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m -jar supervise-gateway.jar > /dev/null 2>&1 &
                        echo "Application started"
                        exit
                        remotessh
                    '''
                }
            }
        }
    }
    post {
        always {
            echo "Pipeline execution complete"
        }
    }
}

这段代码是一个 Jenkins Pipeline 脚本，它定义了一个自动化流程，主要用于从源代码管理（如 Git）获取代码，构建项目，部署到服务器，并执行相关的清理工作。这种流程通常用于持续集成和持续部署（CI/CD）。下面是对各个部分的简单解释：

Pipeline 结构

  1. agent any: 这指示 Jenkins 可以在任何可用的节点上运行这个 pipeline。

  2. environment: 定义环境变量，这里定义的是 WORKSPACE_DIR，即 Jenkins 工作目录名称。

Stages 解释

Prepare 阶段
  • 检查目录: 判断 supervise-cloud 目录是否存在。
    • 如果不存在，执行 git clone 命令从远程 Git 仓库克隆代码。
    • 如果存在，切换到 dev 分支并拉取最新代码，以保持代码更新。
Build 阶段
  • 构建: 使用 Maven 来构建项目，这包括编译代码和打包。
    • 设置 Maven 和 Java 的环境变量。
    • 执行 mvn clean compile package 命令来清理、编译和打包应用，同时跳过单元测试。
Deploy 阶段
  • 部署:
    • 停止服务: 使用 ssh 连接到远程服务器，检查并停止正在运行的 supervise-gateway.jar 应用。
    • 备份旧应用: 如果找到旧的 jar 文件，将其移动到备份目录，并以当前日期和时间为后缀重命名。
    • 清理旧备份: 删除30天前的备份文件以节省空间。
    • 部署新应用: 将新构建的 jar 文件通过 scp 命令复制到远程服务器。
    • 启动新服务: 在远程服务器上启动新的 jar 文件。

Post Actions

  • always: 无论 pipeline 执行成功或失败，都会执行的步骤，这里是打印“Pipeline execution complete”。

总结

这个 Jenkins Pipeline 脚本为开发提供了一个自动化的构建、部署流程，帮助团队实现快速迭代和部署，确保代码的快速交付和部署到生产环境中。通过自动化这些步骤，可以减少人为错误，提高效率和可靠性。

案例四

pipeline {
    agent any

    environment {
        work_space = "${env.WORKSPACE}"
        work_base = 'fangzhi805-parent'
        git_url = 'http://jenkins:Jxxxxft@git.xxxxxx.com:180/fangzhi805/fangzhi805-parent.git'
        git_branch = 'dev'
        target_env = 'dev'
        gitfile = "${work_space}/${work_base}/.git/config"
        package_path = 'ucenter-parent/ucenter-biz'
        server_ip_list = "10.217.88.212"
        deploy_server_user = 'fangzhi'
        deploy_server_bin_dir = '/home/fangzhi/ucenter/bin'
        deploy_server_bin_back_dir = '/home/fangzhi/ucenter/binback'
        deploy_server_sh_dir = '/home/fangzhi/ucenter/shbin'
        deploy_stop_sh='ucenterbiz_stop.sh'
        deploy_start_sh='ucenterbiz_start.sh'
    }

    stages {
        stage('git clone/pull') {
            steps {
                echo "git clone/pull start"

                /*第一次用git clone*/
                echo "gitfile: ${gitfile}"
                script {
                    if (fileExists(gitfile) == false) {
                        sh 'git clone -b ${git_branch} ${git_url}'
                    }
                }

                /*第二次以及以后用git pull*/
                sh '''
				cd ${work_base}
                git pull
                '''

                echo "git clone/pull end"
            }
        }
        stage('build') {
            steps {
                echo "maven build start"
                sh '''
                export MAVEN_HOME=/root/apache-maven-3.9.6
                export JAVA_HOME=/root/jdk-21.0.2
                export PATH=$MAVEN_HOME/bin:$JAVA_HOME/bin:$PATH
                cd ${work_base}
                mvn clean compile package -Dmaven.test.skip=true -pl ${package_path} -am -f pom.xml
                '''
                echo "maven build end"
            }
        }
        stage('deploy') {
            steps {
                script {
                    if (server_ip_list.length() == 0) {
                        println("没有可用于执行的服务器")
                    } else {
                        for ( deploy_server_ip in server_ip_list.tokenize(",")) {
                            echo "deploy_server ${deploy_server_ip}"
                            echo "remote 1 start"
                            sh """
                            #登陆服务器
                            ssh -o StrictHostKeyChecking=no ${deploy_server_user}@${deploy_server_ip} << remotessh
             
                            #停止服务
                            cd ${deploy_server_sh_dir}
                            sh ${deploy_stop_sh}
    
                            #可执行文件备份
                            mkdir -p ${deploy_server_bin_back_dir}
                            mkdir -p ${deploy_server_bin_dir}
                            tar -czvf ${deploy_server_bin_back_dir}/bin.`date +%Y%m%d%H%M%S`.tgz ${deploy_server_bin_dir}
                            rm -rf ${deploy_server_bin_dir}/*
                            exit
                            remotessh
                            """
                            echo "remote 1 end"

                            echo "remote 2 start"
                            echo "scp -o StrictHostKeyChecking=no -r  ${work_space}/${work_base}/${package_path}/target/*  ${deploy_server_user}@${deploy_server_ip}:${deploy_server_bin_dir}/ "
   
                            sh """
                            #应用部署
                            scp -o StrictHostKeyChecking=no -r ${work_space}/${work_base}/${package_path}/target/*  ${deploy_server_user}@${deploy_server_ip}:${deploy_server_bin_dir}/
                            """
                            echo "remote 2 end"

                            echo "remote 3 start"
                            sh """
                            #启动服务
                            ssh -o StrictHostKeyChecking=no ${deploy_server_user}@${deploy_server_ip} << remotessh
                            cd ${deploy_server_sh_dir}
                            sh ${deploy_start_sh}
                            exit
                            remotessh
                            """
                            echo "remote 3 end"
                        }
                    }
                }
            }
        }
    }
}

这段代码是 Jenkins 的声明式 pipeline 脚本，用于自动化地执行软件的版本控制拉取、构建、和部署过程。这里面详细定义了各个阶段的操作，我将逐一解释每个阶段的作用和操作：

环境变量设定 (environment)

  • 定义了一系列的环境变量，这些变量被用于后续的各个阶段，包括工作目录、Git 仓库地址、分支名、部署脚本的位置等。

Git 克隆/拉取 (git clone/pull)

  • 检查 .git/config 文件是否存在来决定是进行 git clone 还是 git pull。如果是第一次，则通过 git clone 命令从指定的仓库和分支拉取代码；如果不是第一次，则直接在已有的目录中执行 git pull 来更新代码。

构建 (build)

  • 使用 Maven 进行构建。首先设置 Maven 和 Java 的环境变量，然后在指定的模块目录中执行 Maven 命令进行编译和打包，跳过单元测试。

部署 (deploy)

  • 检查服务器 IP 列表，如果非空，则对每个服务器进行以下操作：
    • 停止服务：登录到服务器，执行停止服务的脚本。
    • 备份当前部署：在服务器上创建备份目录，备份当前的可执行文件，并清空部署目录。
    • 部署新应用：通过 scp 命令将新构建的应用文件从 Jenkins 服务器传输到目标服务器的部署目录。
    • 启动服务：在服务器上执行启动服务的脚本。

Jenkins Pipeline 的流程控制

  • 这个 pipeline 具备了自动化部署的完整流程：从源码的版本控制开始，到应用的构建、部署，再到最后的启动服务，整个流程都是自动化的。这样可以极大地提升软件开发和部署的效率，减少人为错误，确保部署的一致性和可重复性。

安全性和健壮性注意事项

  • 使用了 SSH 的 StrictHostKeyChecking=no 选项来避免人工干预。在生产环境中，建议更安全地处理 SSH 密钥和主机密钥的确认过程，例如使用已知的主机密钥文件。
  • 通过在 SSH 和 SCP 命令中指定用户和服务器 IP 进行操作，需要确保 Jenkins 服务器具有相应服务器的适当访问权限，并且部署账户的安全性得到妥善管理。
  • 备份和清理操作有助于防止新部署影响现有环境，并提供回滚的可能性，增加系统的稳定性和可恢复性。

案例五

pipeline {
    agent any

    environment {
        // 定义环境变量以便在脚本中复用
        job_name = "${JOB_NAME}" // 作业名称
        repo_url = "http://jenkins:JieYiS%40ft@192.168.1.182:11180/kushan/firefightingproject/kunshan-fire-web.git" // Git 仓库 URL
        branch = "dev" // 分支名称
        node_path = "/root/node-v18.20.1-linux-x64/bin" // 容器中Node.js 路径
        npm_registry = "http://192.168.1.111:31111/repository/npm-group/" // npm 注册表地址
        remote_user = "firemanager" // 远程服务器用户名
        remote_host = "192.168.1.223" // 远程服务器地址
        remote_path = "/home/firemanager/web" // 远程服务器路径
        local_workspace = "/root/.jenkins/workspace/dev-kunshan-fire-web/kunshan-fire-web" // 本地工作空间路径
    }

    stages {
        stage('git clone/pull') {
            steps {
                script {
                    // 检查存储库目录是否存在
                    if (!fileExists('kunshan-fire-web')) {
                        echo "git clone start"
                        // 如果目录不存在，则克隆存储库
                        sh "git clone -b ${branch} ${repo_url}"
                    } else {
                        echo "git pull start"
                        // 如果目录存在，则拉取最新更改
                        sh '''
                            cd kunshan-fire-web
                            git pull
                        '''
                    }
                }
            }
        }

        stage('install and build') {
            steps {
                script {
                    // 检查 node_modules 目录是否存在，以确定是否需要安装依赖项
                    if (!fileExists("${local_workspace}/node_modules")) {
                        echo "npm install start"
                        // 设置 npm 注册表并安装依赖项（如果 node_modules 不存在）
                        sh '''
                            export PATH=${node_path}:$PATH
                            npm config set registry ${npm_registry}
                            cd kunshan-fire-web
                            yarn
                        '''
                    }
                    // 始终构建项目
                    echo "yarn build start"
                    sh '''
                        export PATH=${node_path}:$PATH
                        cd kunshan-fire-web
                        yarn build:prod
                    '''
                }
            }
        }

        stage('deploy') {
            steps {
                script {
                    // 连接到远程服务器并删除现有的 dist 目录
                    echo "remote 1 start"
                    sh '''
                        ssh -o StrictHostKeyChecking=no ${remote_user}@${remote_host} << remotessh
                        cd ${remote_path}
                        rm -rf dist
                        exit
                        remotessh
                    '''
                    echo "remote 1 end"

                    // 将新的 dist 目录复制到远程服务器
                    echo "remote 2 start"
                    sh '''
                        scp -o StrictHostKeyChecking=no -r ${local_workspace}/dist ${remote_user}@${remote_host}:${remote_path}/
                    '''
                    echo "remote 2 end"
                }
            }
        }
    }
}

前端发布流水线

案例四
pipeline {
agent any

stages {
    stage('Git 克隆/拉取') {
        steps {
            echo "Git 克隆/拉取 开始"
            script {
                // 如果项目目录不存在，则进行克隆
                if (!fileExists("supervise-web")) {
                    echo "克隆仓库"
                    sh 'git clone -b dev ssh://git@192.168.0.99/zhjg/zhengke/supervise-web.git'
                } else {
                    // 如果项目目录存在，则进行拉取
                    echo "拉取最新代码"
                    dir('supervise-web') {
                        sh 'git pull origin dev'
                    }
                }
            }
            echo "Git 克隆/拉取 结束"
        }
    }

    stage('安装依赖和构建') {
        steps {
            echo "npm 安装 开始"
            script {
                sh '''
                    # 设置 Node.js 环境路径
                    export PATH=/root/node-v16.20.2-linux-x64/bin:$PATH
                    # 设置 npm 仓库地址
                    npm config set registry http://repo.jieyisoft.com:31111/repository/npm-group/
                    cd supervise-web
                    # 检查 node_modules 目录是否存在
                    if [ ! -d "node_modules" ]; then
                        echo "安装依赖包"
                        yarn install
                    else
                        echo "依赖包已存在，跳过安装"
                    fi
                    # 构建项目
                    yarn build:stage118
                '''
            }
            echo "npm 安装 结束"
        }
    }

    stage('部署') {
        steps {
            echo "远程备份和部署 开始"

            // 在远程服务器上备份旧文件并删除
            sh '''
                ssh -o StrictHostKeyChecking=no root@192.168.0.106 << 'EOF'
                    cd /home/project/supervise-ui/test
                    tar -czvf ../bak/test_bak_$(date +%Y%m%d).tar.gz ./*
                    rm -rf /home/project/supervise-ui/test/*
                    exit
                EOF
            '''

            // 将新文件复制到远程服务器
            sh '''
                scp -o StrictHostKeyChecking=no -r /root/.jenkins/workspace/test-zhjg-supervise-web/supervise-web/dist/test/* root@192.168.0.106:/home/project/supervise-ui/test/
            '''
            echo "远程备份和部署 结束"
        }
    }
}

}

ascarl2010
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
京峰教育-jenkins持续集成&pipeline实战v2.docx
09-26
四、Jenkins 部署流水线 Pipeline 案例实战 * 介绍 Pipeline 的概念和原理 * 介绍如何使用 Jenkins 部署流水线 Pipeline * 介绍如何实现自动化构建、测试和部署 五、总结 * 本资源摘要信息涵盖了京峰教育提供的 ...
hello-jenkins:我的虚拟示例应用程序来测试 Jenkins
06-13
4. **Jenkinsfile**：Jenkinsfile是Jenkins的流水线定义，用Groovy编写，描述了构建、测试和部署的步骤。 5. **持续集成(CI)**：理解CI的基本原则，如频繁集成、自动构建和测试，以及如何通过Jenkins实现这些原则。 ...
Jenkins流水线的实际案例（附源码）.docx
01-12
Jenkins流水线的实际案例（附源码）
Jenkins打包插件配置
03-12
- **Pipeline Plugins**（如：`Pipeline`，`Workflow`，`Multibranch Pipeline`等）：提供声明式或脚本式流水线语法，实现自动化构建、测试和部署流程。 ### 4. 插件管理与更新 - **更新插件**：在Jenkins管理界面...
10.k8s部署微服务网站企业级实战案例-仅文档
06-07
自建k8s集群，并且在自建k8s集群中，部署生产微服务的企业实际应用的项目案例，全程包括快速自建k8s集群，docker安装，jenkins安装，编写jenkinsfile文件和k8s的yaml文件，在jenkins中创建流水线项目，部署项目各个...
SpringBoot整合elasticsearch-java
最新发布
JackMa的博客
07-21 224
系统使用的是ElasticSearch8.2.0。
kubernetes集群部署elasticsearch集群，包含无认证和有认证模式
jiang0615csdn的博客
07-17 1139
kubernetes集群部署elasticsearch集群，包含无认证和有认证模式
【无标题】Elasticsearch for windows
zwm_yy的博客
07-18 711
一、windows安装Elasticsearch1、Elasticsearch：用于存储数据、计算和搜索；2、Logstash/Beats：用于数据搜集3、Kibana：用于数据可视化以上三个被称为ELK，常用语日志搜集、系统监控和状态分析二、下载Elasticsearch、Kibana、IK；1、因为ES和Kibana属于同一家公司的产品，所以kibana的下载方式和elasticsearch基本一致，可放在同级文件夹。
解决Jenkins打包失败问题：手动执行成功但Jenkins执行失败
唐宋元明清临的博客
07-17 283
使用Jenkins执行命令打包，失败。在命令行使用相同命令，成功。
SpringBoot RestHighLevelClient 按版本更新
风信子
07-18 511
RestHighLevelClient 是 Elasticsearch 提供的一个用于与 Elasticsearch 集群交互的高级 REST 客户端。它是基于 Java 的客户端，旨在提供一种简单且功能丰富的方式来执行各种 Elasticsearch 操作，包括索引、搜索、更新和删除文档，以及管理索引和集群。
Jenkins - apt 安装软件包 404 Not Found
wumingxiaoyao的博客
07-21 543
解决 apt 安装软件包失败问题：apt 安装软件包，有时会安装到老版本的，而软件包在 repository 里已经更新成新版本，会抛 404 Not Found，导致安装会失败。
持续集成08--Jenkins邮箱发送构建信息及测试报告
lw1558533893的博客
07-18 1263
通过本章节“持续集成07--Jenkins配置邮箱”的学习，可以基本掌握在Jenkins中配置邮件发送功能的关键步骤。从SMTP服务器的配置到邮件内容的自定义，再到触发邮件发送的条件设置，每一步都详细阐述了如何操作。现这将大大提升团队的响应速度和协作效率，为持续集成和持续部署流程的顺利进行提供有力保障。同时，通过自定义邮件内容，还可以根据实际需求调整通知的详细程度和格式，使团队成员能够更加清晰地了解构建状态和需要采取的行动。
生成Elasticsearch xpack安全认证证书
qq_37647812的博客
07-17 632
生成Elasticsearch xpack安全认证证书
【Jenkins】Pipeline使用初体验
星Yeah 的博客
07-18 375
【Jenkins】Pipeline使用初体验，实现自动化测试
【jenkins+cmake+svn管理c++项目】msbuild: command not found
qq_41104439的博客
07-18 429
“Execute Shell” 与 “Execute Windows batch command” `Execute shell`：这个步骤类型是为Unix/Linux/macOS环境设计的，它会在这些系统的shell（如bash、sh等）中执行我提供的命令。由于这些系统默认不包含MSBuild（因为它是Windows的一部分），所以当你尝试在这个步骤中执行msbuild命令时，它会找不到该命令。
jenkins 使用教程
07-17 1422
全局角色(Global roles)与项目角色(item roles)的区别就是，项目角色只能管理项目，没有管理jenkins的权限配置,全局角色适用于Jenkins中的任何项目，并覆盖您在项目角色中指定的任何内容。由于这里是根据tag进行拉取代码的，第一次构建的时候，页面上不出现选项，成功后，再次构建的时候，就会提示要选择tag，进行拉取代码了。这里把jenkins运行用户改为root。这里有个问题，如果同样的tag，被推送到harbor仓库以后，再次推送的是推不上相同的tag的，只能删除。
Chromium CI/CD 之Jenkins实用指南2024- Windows节点开启SSH服务（七）
守城小轩的技术窝棚
07-18 1064
通过以上步骤，我们成功地在Windows虚拟机上安装并配置了OpenSSH服务器。这为使用Jenkins进行自动化部署和远程管理提供了一个可靠、安全的连接方式。在接下来的章节中，我们将继续探讨如何在Jenkins中创建Windows节点，实现更高效的持续集成和部署流程。请继续关注《Chromium CI/CD 之 Jenkins - 添加Windows节点（八）》。
Jenkins 使用与网络环境影响分析
5. **工作流和流水线** - 解释Jenkins的工作流和Pipeline的概念，以及如何编写和管理Pipeline脚本，实现更复杂的工作流程自动化。 6. **分布式构建** - 探讨如何设置Jenkins的主从架构，利用多台机器进行分布式构建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ascarl2010

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值