精华内容
下载资源
问答
  • Jenkins_Nexus_Integration
  • Jenkins搭配Nexus部署到云目标环境 1、安装Jenkins 根据url: https://jenkins.io/doc/pipeline/tour/getting-started/的步骤安装Jenkins 2、安装Nexus 按照...

    Jenkins搭配Nexus部署到云目标环境

    1、安装Jenkins
    根据https://jenkins.io/doc/pipeline/tour/getting-started/的步骤安装Jenkins

    2、安装Nexus
    按照https://help.sonatype.com/repomanager2/installing-and-running/installing的步骤安装Nexus

    3、为Jenkins配置Nexus插件
    根据https://help.sonatype.com/integrations/nexus-and-continuous-integration/nexus-repository-manager-2.x-for-jenkins的步骤配置Nexus插件

    4、为Jenkins添加和配置Maven Metadata for CI server插件
    这个插件添加了一个新的构建参数类型,用于解析读取存储库的工件版本。
    在任何jenkins作业中,启用"This build is parametrerized"复选框,从出现的下拉菜单中选择 “List maven artifact versions”,配置您想要检索版本的工件。示例如下:
    配置nexus路径
    5、添加一个名为build-test的作业,用于构建项目,并将war包和tar.gz包上传到Nexus服务器。

    a.创建一种名为build-test的管道作业类型,然后单击“Ok”按钮保存。
    

    Jenkins添加项目
    b.为build-test添加一个参数
    在这里插入图片描述
    c. 拷贝如下代码到pipeline脚本中

    pipeline {
        environment {
          DEV_VERSION = "${var_version}"
          DEV_BRANCH = "branch"
       }
        agent any
        stages {
            stage('Checkout') {
                steps {
                    timeout(10) {
                     checkout([$class: 'GitSCM', branches: [[name: "${DEV_BRANCH}_${DEV_VERSION}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'api-portal-dex']], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'ce46885b-859c-40fe-bdaf-a6046d045044', url: 'xxx.git']]])
                    checkout([$class: 'GitSCM', branches: [[name: "${DEV_BRANCH}_${DEV_VERSION}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'api-mgmt-dex']], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'ce46885b-859c-40fe-bdaf-a6046d045044', url: 'xxx.git']]])
                    }
                }
            }
            stage('Maven Build') {
                steps {
                    timeout(10) {
                        echo 'Maven Build Start'
                        script {
                            dir('api-mgmt-dex') {
                                def mvnHome = tool name: 'M3', type: 'maven'
                                sh "${mvnHome}/bin/mvn clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Dmaven.test.failure.ignore=true"
                            }
                        }
                    }
                }
            }
            stage('Publish') {
            steps {
                    timeout(10) {
                    echo 'Publish Start'
                    script {
                            def nodeHome = tool name: 'NodeJS', type: 'nodejs'
                            env.PATH = "${nodeHome}/bin:${env.PATH}"
                            sh '''cd ./api-portal-dex
                            npm install
                            npm run dist'''
                            sh 'tar -zcvf ./api-portal-dex/portal-${DEV_VERSION}.tar.gz ./api-portal-dex/dist'
                        }
                    nexusPublisher nexusInstanceId: 'LocalNexus', nexusRepositoryId: 'releases', packages: [[$class: 'MavenPackage', mavenAssetList: [[classifier: '', extension: '', filePath: "./api-portal-dex/portal-${DEV_VERSION}.tar.gz"]], mavenCoordinate: [artifactId: 'portal', groupId: 'pif', packaging: 'tar.gz', version: "${DEV_VERSION}"]]]
     
                    nexusPublisher nexusInstanceId: 'LocalNexus', nexusRepositoryId: 'releases', packages: [[$class: 'MavenPackage', mavenAssetList: [[classifier: '', extension: '', filePath: "./api-mgmt-dex/gateway/target/gateway-${DEV_VERSION}.war"]], mavenCoordinate: [artifactId: 'gateway', groupId: 'pif', packaging: 'war', version: "${DEV_VERSION}"]]]
     
                    nexusPublisher nexusInstanceId: 'LocalNexus', nexusRepositoryId: 'releases', packages: [[$class: 'MavenPackage', mavenAssetList: [[classifier: '', extension: '', filePath: "./api-mgmt-dex/reporting/target/reporting-${DEV_VERSION}.war"]], mavenCoordinate: [artifactId: 'reporting', groupId: 'pif', packaging: 'war', version: "${DEV_VERSION}"]]]
                         
                    }
                }
            }
     
        }
        post {
            success {
                emailext (
                    subject: "SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """<p>SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]':</p>
                     <p>Check console output at "<a href='${env.BUILD_URL}'>${env.JOB_NAME} [${env.BUILD_NUMBER}]</a>"</p>""",
                    attachLog: true,
                    to: 'xxx@qq.com'
                    )
            }
            failure {
                emailext (
                    subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """<p>FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]':</p>
                     <p>Check console output at "<a href='${env.BUILD_URL}'>${env.JOB_NAME} [${env.BUILD_NUMBER}]</a>"</p>""",
                    attachLog: true,
                    to: 'xxx@qq.com'
                    )
            }
        }
    }
    

    6、添加一个名为deploy-test的作业,用于下载war和tar.gz包并将它们部署到AWS服务器。

    a.创建一种名为deploy-test的管道作业类型,然后单击“Ok”按钮保存。
    b.为deploy-test添加一个参数
    在这里插入图片描述

    c. 拷贝如下代码到pipeline脚本中

    pipeline {
        environment {
          DEV_PIF_USER = "testd"
          QA_PIF_USER = "testr"
          STAGE_PIF_USER = "tests"
          PROD_PIF_USER = "testp"
     
          DEV_AMP_HOST_1 = "10.0.44.68"
          DEV_AMP_HOST_2 = "10.0.44.112"
          DEV_MPE_HOST_1 = "10.0.44.235"
          DEV_MPE_HOST_2 = "10.0.44.249"
          DEV_MRM_HOST_1 = "10.0.44.133"
          DEV_MRM_HOST_2 = "10.0.44.176"
     
          QA_AMP_HOST_1 = "10.0.33.83"
          QA_AMP_HOST_2 = "10.0.33.125"
          QA_MPE_HOST_1 = "10.0.33.234"
          QA_MPE_HOST_2 = "10.0.33.252"
          QA_MRM_HOST_1 = "10.0.33.153"
          QA_MRM_HOST_2 = "10.0.33.177"
     
          STAGE_AMP_HOST_1 = "10.0.22.69"
          STAGE_AMP_HOST_2 = "10.0.22.117"
          STAGE_MPE_HOST_1 = "10.0.22.237"
          STAGE_MPE_HOST_2 = "10.0.22.249"
          STAGE_MRM_HOST_1 = "10.0.22.155"
          STAGE_MRM_HOST_2 = "10.0.22.158"
          STAGE_MRM_HOST_3 = "10.0.22.185"
          STAGE_MRM_HOST_4 = "10.0.22.170"
     
          PROD_AMP_HOST_1 = "10.0.11.69"
          PROD_AMP_HOST_2 = "10.0.11.123"
          PROD_MPE_HOST_1 = "10.0.11.238"
          PROD_MPE_HOST_2 = "10.0.11.246"
          PROD_MRM_HOST_1 = "10.0.11.148"
          PROD_MRM_HOST_2 = "10.0.11.167"
          PROD_MRM_HOST_3 = "10.0.11.151"
          PROD_MRM_HOST_4 = "10.0.11.169"
     
          server="http://xxx:8081/nexus/service/local/artifact/maven/content"
          group="test"
          artifact_gateway="backend"
          artifact_reporting="reporting"
          artifact_portal="portal"
          version="${var_version}"
     
          repo="${var_repo}"
           
          nexus_user="xxx"
          nexus_passwd="xxx"
     
       }
        agent any
        stages {
             
            stage('Download Artifact From Nexus') {
                steps {
                    timeout(10) {
                        echo 'Download Artifact From Nexus Start'
                        script {
                           sh '''
                                  curl -o "gateway-"${version}".war" -X GET -u $nexus_user:$nexus_passwd $server"?g="$group"&a=gateway&v="$version"&r="releases"&e=war"
                                  curl -o "reporting-"${version}".war" -X GET -u $nexus_user:$nexus_passwd $server"?g="$group"&a=reporting&v="$version"&r="releases"&e=war"
                                  curl -o "portal-"${version}".tar.gz" -X GET -u $nexus_user:$nexus_passwd $server"?g="$group"&a=portal&v="$version"&r="releases"&e=tar.gz"
                              '''
                        }
                    }
                }
            }
            stage('Deploy') {
                steps {
                    timeout(10) {
                        echo 'Deploy Start'
                        script {
                             sh '''
                                    tar -zxvf ./portal-${version}.tar.gz
                                '''
                        }
                        sshagent(credentials: ['22630c00-9964-425a-bd57-26a673806d17']) {
     
                            sh '''
                                  if [ ${var_repo} = "dev" ]
                                  then
                                      echo 'dev env start deploying'
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${DEV_PIF_USER}@${DEV_AMP_HOST_1}:/app/pif/html
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${DEV_PIF_USER}@${DEV_AMP_HOST_2}:/app/pif/html
     
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_AMP_HOST_1} sudo /etc/init.d/dex_pifamp restart
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_AMP_HOST_2} sudo /etc/init.d/dex_pifamp restart
     
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${DEV_PIF_USER}@${DEV_MPE_HOST_1}:/home/${DEV_PIF_USER}/gateway.war
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${DEV_PIF_USER}@${DEV_MPE_HOST_2}:/home/${DEV_PIF_USER}/gateway.war
     
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${DEV_PIF_USER}@${DEV_MRM_HOST_1}:/home/${DEV_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${DEV_PIF_USER}@${DEV_MRM_HOST_2}:/home/${DEV_PIF_USER}/reporting.war
     
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_MPE_HOST_1} /home/${DEV_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_MPE_HOST_2} /home/${DEV_PIF_USER}/.script/deploy.sh
     
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_MRM_HOST_1} /home/${DEV_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${DEV_PIF_USER} ${DEV_MRM_HOST_2} /home/${DEV_PIF_USER}/.script/deploy.sh
     
                                  elif [ ${var_repo} = "qa" ]
                                  then
                                      echo 'qa env start deploying'
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${QA_PIF_USER}@${QA_AMP_HOST_1}:/app/pif/html
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${QA_PIF_USER}@${QA_AMP_HOST_2}:/app/pif/html
     
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_AMP_HOST_1} sudo /etc/init.d/dex_pifamp restart
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_AMP_HOST_2} sudo /etc/init.d/dex_pifamp restart
     
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${QA_PIF_USER}@${QA_MPE_HOST_1}:/home/${QA_PIF_USER}/gateway.war
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${QA_PIF_USER}@${QA_MPE_HOST_2}:/home/${QA_PIF_USER}/gateway.war
     
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${QA_PIF_USER}@${QA_MRM_HOST_1}:/home/${QA_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${QA_PIF_USER}@${QA_MRM_HOST_2}:/home/${QA_PIF_USER}/reporting.war
     
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_MPE_HOST_1} /home/${QA_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_MPE_HOST_2} /home/${QA_PIF_USER}/.script/deploy.sh
                                       
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_MRM_HOST_1} /home/${QA_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${QA_PIF_USER} ${QA_MRM_HOST_2} /home/${QA_PIF_USER}/.script/deploy.sh
     
                                  elif [ ${var_repo} = "stage" ]
                                  then
                                      echo 'stage env start deploying'
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${STAGE_PIF_USER}@${STAGE_AMP_HOST_1}:/app/pif/html
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${STAGE_PIF_USER}@${STAGE_AMP_HOST_2}:/app/pif/html
     
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_AMP_HOST_1} sudo /etc/init.d/dex_pifamp restart
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_AMP_HOST_2} sudo /etc/init.d/dex_pifamp restart
     
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${STAGE_PIF_USER}@${STAGE_MPE_HOST_1}:/home/${STAGE_PIF_USER}/gateway.war
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${STAGE_PIF_USER}@${STAGE_MPE_HOST_2}:/home/${STAGE_PIF_USER}/gateway.war
     
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${STAGE_PIF_USER}@${STAGE_MRM_HOST_1}:/home/${STAGE_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${STAGE_PIF_USER}@${STAGE_MRM_HOST_2}:/home/${STAGE_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${STAGE_PIF_USER}@${STAGE_MRM_HOST_3}:/home/${STAGE_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${STAGE_PIF_USER}@${STAGE_MRM_HOST_4}:/home/${STAGE_PIF_USER}/reporting.war
     
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MPE_HOST_1} /home/${STAGE_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MPE_HOST_2} /home/${STAGE_PIF_USER}/.script/deploy.sh
                                       
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MRM_HOST_1} /home/${STAGE_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MRM_HOST_2} /home/${STAGE_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MRM_HOST_3} /home/${STAGE_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${STAGE_PIF_USER} ${STAGE_MRM_HOST_4} /home/${STAGE_PIF_USER}/.script/deploy.sh
     
                                  elif [ ${var_repo} = "prod" ]
                                  then
                                      echo 'prod env start deploying'
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${PROD_PIF_USER}@${PROD_AMP_HOST_1}:/app/pif/html
                                      scp -o StrictHostKeyChecking=no -r ./api-portal-dex/dist/* ${PROD_PIF_USER}@${PROD_AMP_HOST_2}:/app/pif/html
     
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_AMP_HOST_1} sudo /etc/init.d/dex_pifamp restart
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_AMP_HOST_2} sudo /etc/init.d/dex_pifamp restart
     
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${PROD_PIF_USER}@${PROD_MPE_HOST_1}:/home/${PROD_PIF_USER}/gateway.war
                                      scp -o StrictHostKeyChecking=no ./gateway-${version}.war ${PROD_PIF_USER}@${PROD_MPE_HOST_2}:/home/${PROD_PIF_USER}/gateway.war
     
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${PROD_PIF_USER}@${PROD_MRM_HOST_1}:/home/${PROD_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${PROD_PIF_USER}@${PROD_MRM_HOST_2}:/home/${PROD_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${PROD_PIF_USER}@${PROD_MRM_HOST_3}:/home/${PROD_PIF_USER}/reporting.war
                                      scp -o StrictHostKeyChecking=no ./reporting-${version}.war ${PROD_PIF_USER}@${PROD_MRM_HOST_4}:/home/${PROD_PIF_USER}/reporting.war
     
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MPE_HOST_1} /home/${PROD_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MPE_HOST_2} /home/${PROD_PIF_USER}/.script/deploy.sh
                                       
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MRM_HOST_1} /home/${PROD_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MRM_HOST_2} /home/${PROD_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MRM_HOST_3} /home/${PROD_PIF_USER}/.script/deploy.sh
                                      ssh -o StrictHostKeyChecking=no -l ${PROD_PIF_USER} ${PROD_MRM_HOST_4} /home/${PROD_PIF_USER}/.script/deploy.sh
     
                                  else
                                      echo "The version format is error!"
                                  fi
     
                               '''
                        }
                    }
                }
            }
        }
        post {
            success {
                emailext (
                    subject: "SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """<p>SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]':</p>
                     <p>Check console output at "<a href='${env.BUILD_URL}'>${env.JOB_NAME} [${env.BUILD_NUMBER}]</a>"</p>""",
                    attachLog: true,
                    to: 'xxx@qq.com'
                    )
            }
            failure {
                emailext (
                    subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
                    body: """<p>FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]':</p>
                     <p>Check console output at "<a href='${env.BUILD_URL}'>${env.JOB_NAME} [${env.BUILD_NUMBER}]</a>"</p>""",
                    attachLog: true,
                    to: 'xxx@qq.com'
                    )
            }
        }
    }
    

    d.带参数构建“deploy-test”作业
    在这里插入图片描述

    展开全文
  • SVN-Jenkins-Nexus-Maven-Tomcat持续集成构建调研报告
  • jenkins jboss 最近,我正在整理一个快速启动的Maven项目,以展示组织JBoss Fuse项目的可能方法。 该项目可以在Github上找到: https : //github.com/paoloantinori/fuse_ci 这是我朋友詹姆斯·罗林斯 ( ...

    jenkins jboss

    最近,我正在整理一个快速启动的Maven项目,以展示组织JBoss Fuse项目的可能方法。

    该项目可以在Github上找到: https : //github.com/paoloantinori/fuse_ci

    这是我与朋友詹姆斯·罗林斯James Rawlings)合作后所学到的一点点发展

    该项目提出了一种在Maven多模块项目中组织代码库的方法。

    感谢我收到的反馈和建议,该项目正在不断发展; 但是关键是要显示一种组织项目的所有工件,脚本和配置的方法。

    ci文件夹中,您会发现子文件夹(例如featureskaraf_scripts ,这些子文件夹可能最终在每个项目中创建文件,并带有内联注释,可根据您的特定需求帮助您进行调整和自定义

    该项目还利用Fabric8处理一组托管的OSGi容器的创建,并利用其所有功能来组织工作流,部署的配置和版本控制。

    在这篇博文中,我将向您展示如何在一个非常典型的开发设置(包括JBoss FuseMavenGitNexusJenkins)中部署该示例项目。

    之所以决定涵盖此主题,是因为我发现很多时候我遇到了优秀的开发人员,他们告诉我,即使他们知道持续集成基础架构的附加值,也没有时间致力于这项活动 。 没有多余的时间,他们只专注于发展。

    我不希望您对此话题进行宣传,也不要试图告诉您他们应该做什么。 我喜欢相信他们,并相信他们知道他们的项目优先事项 ,并且他们接受了可用时间,积压和每项活动带来的总体收益之间的权衡。 同样, 我喜欢相信所有人都同意,对于大型和长期项目,CI最佳实践绝对是必须做的事情 ,而且没有人需要争论其价值。

    考虑到所有这些,我想展示一种可能的设置和工作流程,以展示花费一小时的时间来获得可以持续更长的利益的速度

    我不会介绍分步说明。 但是为了证明所有这些工作正常,我创建了一个使用Docker的bash脚本,该脚本将演示如何轻松地编写脚本 ,更重要的是, 它们确实有效!

    如果您想直接跳到最后,可以在这里找到脚本:

    https://github.com/paoloantinori/fuse_ci/blob/master/ci/deploy_scripts/remote_nexus.sh

    它使用了一些我创建并作为Docker Index上的受信任版本发布的Docker映像:

    https://index.docker.io/u/pantinor/fuse/

    https://index.docker.io/u/pantinor/centos-jenkins/

    https://index.docker.io/u/pantinor/centos-nexus/

    因为它们显示了执行的步骤,所以它们是一种方便且可重用的方式来运送可执行文件。 它们也可以看作是记录安装和配置过程的一种方式

    如上所述, 您不一定需要它们 。 您可以自己手动安装和配置服务。 它们只是一种经过验证的开放方式,可以节省您一些时间或向您展示
    我做的方式

    让我们开始描述示例持续集成设置的组件:

    1. JBoss保险丝6.1
    2. 这是我们要部署到的运行时 。 它放在专用的盒子里。 它与Nexus交互,作为我们生成和发布的工件的来源。

    3. 关系
    4. 这是我们用来存储从代码库生成的二进制文件的软件。 JBoss Fuse可以访问它, JBoss Fuse可以从中下载工件, Jenkins可以访问它,并在其上发布二进制文件,这是成功构建工作的最后一步。

    5. 詹金斯
    6. 这是我们的构建作业调用程序 。 如果使用Git签出的代码成功构建,它就会将其输出发布到Nexus ,并构建其输出。

    7. Git服务器
    8. 它是远程代码存储库持有人。 Jenkins可以访问它以下载我们要构建的最新版本的代码,并且当所有开发人员共享他们的代码以及要在Continous Integration服务器上进行构建时,所有开发人员都将使用它。 在我们的例子中,git服务器只是一个通过ssh访问的文件系统

    未命名
    http://yuml.me/edit/7e75fab5

    吉特

    首先要做的是设置git充当我们的源代码管理( SCM )。
    您可能会猜到,从SVN到Mercurial,我们可能都使用过其他所有类似的软件来完成这项工作,但是我更喜欢git因为它是最受欢迎的选择之一,并且因为它是与Fabric8配置直接交互的官方支持工具
    我们对git要求不高。 我们只需要一个文件系统来存储我们的共享代码,以及一个允许访问该代码的传输服务 。 为了简单起见,我决定使用SSH作为传输协议 。 这意味着在将要存储代码的盒子上,我们只需要启动sshd守护程序,一些有效用户以及他们可以访问的文件夹。 就像是:

    yum install -y sshd git
    service sshd start
    adduser fuse
    mkdir -p /home/fuse/fuse_scripts.git
    chmod a+rwx /home/fuse/fuse_scripts.git # or a better stratey based on guid

    唯一的git特定步骤是使用初始化git存储库

    git init --bare /home/fuse/fuse_scripts.git

    关系

    Nexus OSS是一个存储库管理器,可用于存储Maven工件。
    它作为Java Web应用程序实现。 因此, 安装Nexus非常简单
    多亏了Jetty的嵌入式实例为其提供了支持,所以只需提取分发存档并启动二进制文件即可:

    wget http://www.sonatype.org/downloads/nexus-latest-bundle.tar.gz /tmp/nexus-latest-bundle.tar.gz
    tar -xzvf /tmp/nexus-latest-bundle.tar.gz -C /opt/nexus
    /opt/nexus/nexus-*/bin/nexus

    Nexus启动后,默认情况下将在以下端点上可用: http:// your_ip / 8081 / nexus,其中admin作为用户, admin123作为密码。
    关联1

    詹金斯

    Jenkins是我们将用来构建项目的工作计划程序 。 我们希望以这样一种方式配置Jenkins,使其能够直接连接到我们的git repo来下载项目源。 为此,我们需要一个附加插件Git Plugin 。 显然,我们还需要在盒子上安装javamaven 。 由于Jenkins配置由涉及与多个管理页面的交互的各个步骤组成,因此,我仅对需要执行的重要步骤提供一些提示 。 出于这个原因, 我强烈建议您检查我的完全自动化脚本 ,该脚本可以完全自动化 。 就像Nexus一样,Jenkins被实现为Java Web应用程序。 因为我喜欢使用CentosFedora之类的RHEL兼容发行 ,所以我以简化的方式安装Jenkins。 与其像Nexus那样手动提取存档,不如定义一个新的yum repo ,让yum为我处理安装和配置即服务:

    wget http://pkg.jenkins-ci.org/redhat/jenkins.repo -O /etc/yum.repos.d/jenkins.repo
    rpm --import http://pkg.jenkins-ci.org/redhat/jenkins-ci.org.key
    yum install jenkins
    service jenkins start

    Jenkins启动后,您将在此处找到它的Web界面: http:// your_ip:8080 /
    默认情况下,它是在单用户模式下配置的,对于我们的演示来说就足够了。 您可能需要验证http:// your_ip:8080 / configure以检查JDK,Maven和git的值是否看起来不错。 如果您在Jenkins之前已经安装了那些软件,则通常会自动将它们拾取。 然后,您需要安装Git插件http:// your_ip:8080 / pluginManager
    外挂程式 配置完所有内容后,在重新启动 Jenkins实例之后,我们将能够看到表单中的新选项,该选项允许我们创建Maven构建作业。 在“ 源代码管理 ”部分下,现在有了git选项。 只需提供SSH服务器的坐标即可,例如:

    ssh://fuse@172.17.0.5/home/fuse/fuse_scripts.git


    工作1

    在“ 构建 ”部分的“ 目标和选项”下 ,我们需要明确告知Maven我们要调用deploy阶段,并提供Nexus实例的IP地址:

    clean deploy -DskipTests -Dip.nexus=172.17.0.3

    最后一个配置步骤是在高级maven属性中指定另一个maven设置文件 ,该文件与源代码一起存储:

    https://github.com/paoloantinori/fuse_ci/blob/master/my_settings.xml

    当其中包含工件时,其中包含要显示给Nexus的用户和密码。

    工作2

    配置已经完成,但是我们还需要其他步骤使Jenkins与Git一起工作

    由于我们将SSH用作传输协议,因此在首次连接SSH服务器 ,将要求我们确认要连接的服务器是安全的,并且其指纹是我们期望的指纹 。 该挑战操作将阻止构建作业,因为是批处理作业,不会有任何人确认SSH凭据。

    为了避免所有这些,一个窍门是通过SSH连接到Jenkins框,成为用于运行Jenkins进程(在我的情况下为jenkins的用户,然后从那里手动连接到ssh git服务器,以执行标识操作以交互方式进行,因此将来不再需要:

    ssh fuse@IP_GIT_SERVER
    The authenticity of host '[172.17.0.2]:22 ([172.17.0.2]:22)' can't be established.
    DSA key fingerprint is db:43:17:6b:11:be:0d:12:76:96:5c:8f:52:f9:8b:96.
    Are you sure you want to continue connecting (yes/no)?

    我使用Jenkins码头工人映像的另一种方法是完全禁用SSH指纹识别 ,这种方法对您来说可能不太安全

    mkdir -p /var/lib/jenkins/.ssh ;  
    printf "Host * \nUserKnownHostsFile /dev/null \nStrictHostKeyChecking no" >> /var/lib/jenkins/.ssh/config ; 
    chown -R jenkins:jenkins /var/lib/jenkins/.ssh

    如果一切配置正确,Jenkins将能够自动下载我们的项目,进行构建并将其发布到Nexus。

    但…

    在此之前,我们需要开发人员将代码推送到git,否则将没有任何源文件可以构建! 为此,您只需要克隆我的存储库,配置一个附加的远程存储库(我们的私有git服务器)并推送:

    git clone git@github.com:paoloantinori/fuse_ci.git
    git remote add upstream ssh://fuse@$IP_GIT/home/fuse/fuse_scripts.git
    git push upstream master

    此时,您可以在Jenkins上触发构建作业。 如果是第一次运行,则Maven将下载所有依赖项,因此可能需要一段时间 。 如果一切成功,您将收到确认您的工件发布到Nexus的确认。

    连结2

    JBoss保险丝

    现在,我们的Nexus服务器已填充了根据我们的代码库构建的Maven工件,我们只需要告诉我们的Fuse实例即可将Nexus用作Maven远程存储库。 教我们如何做:在karaf壳中,我们需要更改属性的值,

    fabric:profile-edit  --pid io.fabric8.agent/org.ops4j.pax.url.mvn.repositories=\"http://172.17.0.3:8081/nexus/content/repositories/snapshots/@snapshots@id=sample-snapshots\" default

    现在我们可以使用以下命令验证集成是否完成:

    cat  mvn:sample/karaf_scripts/1.0.0-SNAPSHOT/karaf/create_containers

    如果一切正常,您将看到类似于以下的输出:

    # create broker profile
    fabric:mq-create --profile $BROKER_PROFILE_NAME $BROKER_PROFILE_NAME
    # create applicative profiles
    fabric:profile-create --parents feature-camel MyProfile
    
    # create broker
    fabric:container-create-child --jvm-opts "$BROKER_01_JVM" --resolver localip --profile $BROKER_PROFILE_NAME root broker
    
    # create worker
    fabric:container-create-child --jvm-opts "$CONTAINER_01_JVM" --resolver localip root worker1
    # assign profiles
    fabric:container-add-profile worker1 MyProfile

    这意味着寻址提供Maven坐标的karaf脚本效果很好,现在您可以使用shell:sourceosgi:install或任何其他需要在Nexus上发布工件的命令。

    结论

    如多次提到的那样,这只是可能的工作流和这些平台之间交互的示例。
    您的团队可能遵循不同的程序或使用不同的工具。
    也许您已经基于新的Fabric8 Maven插件实现了更高级的流程。 无论如何,我邀请对此主题感兴趣的所有人发表评论或一些其他方法的链接,并帮助所有人分享我们的经验

    翻译自: https://www.javacodegeeks.com/2014/05/continuous-integration-with-jboss-fuse-jenkins-and-nexus.html

    jenkins jboss

    展开全文
  • Jenkins 实现 Nexus npm Library 版本发布时遇到的问题 问题说明 使用 Nexus 来开发 前端Library 镜像仓库时,在 执行 npm publish 提交前,需要有 npm adduser 操作来,添加对镜像仓库的 user token, 这个 npm ...

    Jenkins 实现 Nexus npm Library 版本发布时遇到的问题

    问题说明

    使用 Nexus 来开发 前端Library 镜像仓库时,在 执行 npm publish 提交前,需要有 npm adduser 操作来,添加对镜像仓库的 user token, 这个 npm adduser 会触发一个交互界面,来输入username password email 等信息,这在手动发布版本时是没有问题的,但是如果要在 Jenkins Job 中实现自动化的发版,那么 npm adduser 触发的交互界面就会对构建有影响,以下是解决方案。

    解决思路

    1. Jenkins Job 执行过程中在项目根目录下,创建新的 .npmrc 文件,用于配置当前项目的 npm 配置
    2. 使用 _auth 配置来代替在交互界面中输入username:password

    需要创建的 .npmrc 配置

    email=${LIBRARY_EMAIL} # Nexus 需要填写,一个普通的邮件地址即可
    always-auth=true # 强制npm在访问注册表时始终需要身份验证,即使对于GET请求也是如此
    _auth=${libraryAuth} # _auth 是将 username:password 进行base64转码后的结构,也是身份认证的关键
    

    _auth 生成

    _auth 是将 username:password 进行base64转码后的结构吗,可通过如下命令生成

    echo -n 'username:password' | openssl base64
    

    Jenkins 中的实现

    stage("create .npmrc") {
      steps {
        dir("ui-library") {
          script {
            def libraryAuth = sh(returnStdout: true, script: "echo -n 'username:password' | openssl base64").trim()          
            echo "Get _auth = ${libraryAuth}"
            def npmrc = sh(returnStdout: true, script: "echo 'email=xxx@163.com\nalways-auth=true\n_auth=${libraryAuth}\n' > .npmrc")
            echo "${npmrc}"
          }
        }
      }
    }
    

    然后在下一个 阶段中执行 npm publish 即可

    展开全文
  • 这是 Jenkins-CI ( ) 的插件,它允许使用构建中的自定义值更新问题 怎么建? 因为,这是一个标准的 Maven Jenkins 插件项目,插件可以通过运行来构建 $ mvn install 这将创建可安装的插件存档 target/dynamic...
  • 本章我们主要讲述Jenkins与制品库nexus、artifactory集成,上传下载制品。 目录部署功能基本概念上传制品集成jenkins上传制品使用nexus插件上传制品发布制品ne...
    本章我们主要讲述Jenkins与制品库nexus、artifactory集成,上传下载制品。
    

    目录

    • 部署

    • 功能

    • 基本概念

    • 上传制品

    • 集成jenkins上传制品

    • 使用nexus插件上传制品

    • 发布制品

    • nexus接口

    • artifactory集成

      • 构建制品

      • 上传制品


    部署

    测试环境使用Docker安装部署

    docker run -id \
    --privileged=true --name=nexus3 \
    -p 8081:8081 \
    -v ${LOCALDIR}/nexus3/nexus-data:/nexus-data \
    sonatype/nexus3:3.20.1

    安装完成后默认的admin账号密码存储在了数据目录,获取初始化密码后更新账号密码。

    功能

    私服仓库:本地maven私服加快构建速度代理仓库:将公网等第三方提供的仓库代理到本地

    基本概念

    组件是一种资源,在构建过程中需要依赖。它可以是整个应用程序,也可以是静态资源(例如图片)。通常,这些组件是各种文件的存档,包括:类文件中的Java字节码、C对象文件、文本文件、二进制文件。组件的多种格式,例如:Java JAR,WAR,EAR格式;普通ZIP或.tar.gz文件;其他软件包格式,例如NuGet软件包,Ruby gems,NPM软件包;可执行文件格式,例如.exe 或.sh 文件,Android APK文件,各种安装程序格式。

    组件可以由多个嵌套组件本身组成。组件提供了所有构建块和功能。可以通过组装并添加自己的业务相关组件来创建功能强大的完整应用程序。在不同的工具链中,组件称为工件,程序包,捆绑包,归档和其他术语。概念和想法保持不变,组件用作通用术语。组件由一组特定值(坐标)标识。这些坐标的通用集是组,名称和版本的用法。这些坐标的名称和用法随所使用的工具链而变化。组件也可以成为其他元数据的基础

    资产 :例如Maven项目中的pom文件算是资产一部分,包含元数据的重要补充。实际的存档文件(pom.xml)是与组件( jar/war包)关联的资产。但是,更复杂的格式具有与组件(jar包)关联的众多资产(pom)。例如,Maven存储库中的典型JAR组件至少由POM和JAR文件定义-两者均构成属于同一组件的单独资产。其他文件(例如JavaDoc或Sources JAR文件)是属于同一组件的资产。另一方面,Docker格式为资产提供唯一的标识符,并将其称为Docker层。这些资产可用于不同的组件-Docker映像。例如,一个Docker层可以是多个Docker映像引用的特定操作系统。

    上传制品

    我们需要在nexus中创建一个新的仓库maven-hostd,同时我们需要在maven的配置文件settings.xml中配置maven-hostd认证。如下:

        <server>
          <id>maven-hostd</id>
          <username>admin</username>
          <password>admin123</password>
        </server>

    注意使用mvn deploy 发布时,server.id == respository.id。



    集成jenkins上传制品

    步骤:获取Jar包名称、读取pom文件、获取坐标信息、使用mvn deploy上传。

    def jarName = sh returnStdout: true, script: "cd target;ls *.jar"
    jarName = jarName - "\n"
    
    def pom = readMavenPom file: 'pom.xml'
    pomVersion = "${pom.version}"
    pomArtifact = "${pom.artifactId}"
    pomPackaging = "${pom.packaging}"
    pomGroupId = "${pom.groupId}"
    
    println("${pomGroupId}-${pomArtifact}-${pomVersion}-${pomPackaging}")
    
    def mvnHome = tool "M2"
    sh  """
        cd target/
        ${mvnHome}/bin/mvn deploy:deploy-file -Dmaven.test.skip=true  \
                                -Dfile=${jarName} -DgroupId=${pomGroupId} \
                                -DartifactId=${pomArtifact} -Dversion=${pomVersion}  \
                                -Dpackaging=${pomPackaging} -DrepositoryId=maven-hostd \
                                -Durl=http://192.168.1.200:30083/repository/maven-hostd
        """

    使用nexus插件上传制品

    安装nexus artifact uploader插件、使用片段生成器生成DSL。

    开始编写Jenkinsfile

    //use nexus plugin
    def repoName = "maven-hostd"
    def filePath = "target/${jarName}"
    nexusArtifactUploader artifacts: [[artifactId: "${pomArtifact}",
                                        classifier: '',
                                        file: "${filePath}",
                                        type: "${pomPackaging}"]],
                            credentialsId: 'nexus-admin-user',
                            groupId: "${pomGroupId}",
                            nexusUrl: '192.168.1.200:30083',
                            nexusVersion: 'nexus3',
                            protocol: 'http',
                            repository: "${repoName}",
                            version: "${pomVersion}"

    查看上传的日志

    查看仓库制品

    发布制品

    安装Maven Artifact ChoiceListProvider (Nexus)插件

    用户选择制品,在应用服务器通过salt、ansible下载制品并部署

    nexus接口

    package org.devops
    
    
    //封装HTTP
    def HttpReq(reqType,reqUrl,reqBody){
        def sonarServer = "http://192.168.1.200:30083/service/rest"
      
        result = httpRequest authentication: 'nexus-admin-user',
                httpMode: reqType,
                contentType: "APPLICATION_JSON",
                consoleLogResponseBody: true,
                ignoreSslErrors: true,
                requestBody: reqBody,
                url: "${sonarServer}/${reqUrl}",
                quiet: true
        
        return result
    }
    
    
    //获取仓库中所有组件
    
    def GetRepoComponents(repoName){
        apiUrl = "/v1/components?repository=${repoName}"
        response = HttpReq("GET",apiUrl,'')
        
        response = readJSON text: """${response.content}"""
        println(response["items"].size())
        
        return response["items"]
    }
    
    
    //获取单件组件
    
    def GetComponentsId(repoName,groupId,artifactId,version){
        println("获取单件组件ID")
        result = GetRepoComponents(repoName)
        
        for (component in result){
            
            if (component["group"] == groupId && component["name"] == artifactId && component["version"] == version  ){
                
                componentId = component["id"]
                
                return componentId
            }
        }
        
        println(componentId)
    }
    
    //获取组件信息
    def GetSingleComponents(repoName,groupId,artifactId,version){
        println("获取单件组件信息")
        componentId = GetComponentsId(repoName,groupId,artifactId,version)
        apiUrl = "/v1/components/${componentId}"
        response = HttpReq("GET",apiUrl,'')
        
        response = readJSON text: """${response.content}"""
        println(response["assets"]["downloadUrl"])
    }


    artifactory集成

    安装Artifactory插件,配置Artifactory仓库信息(仓库地址、用户认证信息)。

    构建制品

    package org.devops
    
    //Maven打包构建
    def MavenBuild(buildShell){
        def server = Artifactory.newServer url: "http://192.168.1.200:30082/artifactory"
        def rtMaven = Artifactory.newMavenBuild()
        def buildInfo
        server.connection.timeout = 300
        server.credentialsId = 'artifactory-admin-user'
        //maven打包
        rtMaven.tool = 'M2'
        buildInfo = Artifactory.newBuildInfo()
    
        String newBuildShell = "${buildShell}".toString()
        println(newBuildShell)
        rtMaven.run pom: 'pom.xml', goals: newBuildShell, buildInfo: buildInfo
        //上传build信息
        server.publishBuildInfo buildInfo
    }
    
    
    def main(buildType,buildShell){
        if(buildType == "mvn"){
            MavenBuild(buildShell)
        }
    }

    查看构建数据:

    命名规范

    仓库命名规范
    业务/项目-环境类型   例如:demo-dev
    
    制品命名规范
    应用名称-版本号-构建ID.type  
    例如:demo-myapp-service-1.jar
    
    制品目录规范
      业务/项目
        应用名称
           版本号
              制品

    上传制品

    rtUpload (
        serverId: "art1",
        spec:
            """{
            "files": [
                {
                "pattern": "target/${jarName}",
                "target": "${uploadDir}/"
                }
            ]
            }"""
    )


    周末公开课

    展开全文
  • 最近,我正在整理一个快速启动的Maven项目,以展示一种... 这是我朋友詹姆斯·罗林斯 ( James Rawlings)一起工作中学到的一点点进展 该项目提出了一种在Maven多模块项目中组织代码库的方法。 由于我收到的...
  • p 8081:8081 -p 5000:5000 --restart=always -v /data/nexus-data:/nexus-data --name nexus3-v3 -d --restart=always 640570fd0ff5 docker 拉取镜像 docker pull 0.0.0.0:5000/xiebing-docker:v1 11 持续集成/持续...
  • 鉴于此,痛定思痛之下,笔者自主构想研发了一套基于Jenkins+Nexus的增量包发布平台,以期减缓和消除这类痛苦。 2. 实现 相关流程图参见 流程图 - 基于Jenkins+Nexus实现增量包自动发布 。 以上流程图中表明关键点有...
  • - Jenkins - Nexus Gitlab CE https://hub.docker.com/r/gitlab/gitlab-ce/ https://docs.gitlab.com/omnibus/docker/README.html $ docker pull gitlab/gitlab-ce sudo docker ...
  • 本文讲的是沃尔玛如何使用OneOps、JenkinsNexus和Kubernetes管理200+配送中心【编者的话】本文介绍了沃尔玛公司针对全球200+配送中心云化升级的具体情况,包括使用的方案、如何处理原来的虚拟机资源以及改造后的...
  • mvn+jenkins+nexus+svn

    2014-03-27 13:34:37
    http://www.oschina.net/question/565065_66971
  •  本文为一个简单入门,无论是maven、jenkinsnexus、git都不是可以一下学会的,都需要更多的学习和练习才能熟练使用。           转载于:https://www.cnblogs.com/vi-2525/p/8759225.html
  • 前面已经完成了二进制部署Kubernetes集群,下面进行...3、用户在发布应用时需要填写git仓库地址和分支、服务类型、服务名称、资源数量、实例个数,确定后触发Jenkins自动构建; 4、Jenkins的CI流水线自动编译代码并...
  • 序 标题中的低成本指的是软/硬件...软件成本:虚拟化环境为 QNAP 自带 KVM,KVM安装 CentOS6 操作系统,分别安装 Gogs、JenkinsNexus 三台虚拟机。成本为零。 初创团队,为了降低成本,建议使用简单、开源、免费...
  • 2、Nexus 执行程序存储在虚拟机中 3、Nexus 的数据文件通过 NFS 挂载,存储到 NAS 上,方便迁移、升级、备份等。 4、配置代理 maven 阿里云仓库 5、配置代理 spring 阿里云仓库 6、配置代理 npm 淘宝仓库 ...
  • node-cidr-mask-size: "24" feature-gates: "TaintBasedEvictions=false" # 控制器定时节点通信以检查通信是否正常,周期默认5s node-monitor-period: "5s" ## 当节点通信失败后,再等一段时间kubernetes判定节点...
  • 将 SNAPSHOT 版本部署到本地 Nexus 只有二​​进制: mvn deploy 二进制文件,包括 javadoc 和源文件: mvn deploy -P release 执行 RELEASE : mvn release:prepare release:perform 版本更改和标签提交到 ...
  • Docker是什么、原理是什么、优缺点是什么、传统的虚拟机的区别是什么、为什么Docker性能如此强劲。 Docker的镜像、容器、仓库、公服、私服原理,如何使用他们,怎么样使用镜像加速器。 Docker的安装、卸载、启动 ...
  • Nexus 添加 Jenkins repo

    2020-12-28 17:07:46
    他们特定存在于 jenkins 自己的 repo 中,下面是在公司自有的 nexus 中添加 jenkins 仓库的步骤: jenkins 官方 repo 的地址为: https://repo.jenkins-ci.org/public/ 对应的 proxy 地址为:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,303
精华内容 1,721
关键字:

jenkins与nexus