精华内容
下载资源
问答
  • Jenkins持续集成&部署

    2021-03-04 19:39:50
    Jenkins持续集成&部署什么是持续集成CI/CD简介持续集成CI持续交付持续部署CD小结JenkinsJenkins是什么Jenkins安装准备工作安装启动访问Jenkins配置主程序目录JDK配置maven配置插件安装系统设置git配置持续构建...

    什么是持续集成

    • 持续集成是一个开发的实践,需要开发人员定期集成代码到共享存储库。这个概念是为了消除发现的问题,后来出现在构建生命周期的问题。持续集成要求开发人员有频繁的构建。最常见的做法是,每当一个代码提交时,构建应该被触发。

    CI/CD简介

    • 互联网软件的开发和发布,已经形成了一套标准流程,假如把开发工作流程分为以下几个阶段:

    在这里插入图片描述

    • 正如你在上图中看到,[持续集成(Continuous Integration)]、[持续交付(Continuous Delivery)]和[持续部署(Continuous Deployment)]有着不同的软件自动化交付周期。

    持续集成CI

    • 上面整个流程中最重要的组成部分就是持续集成(Continuous integration,简称CI)。
    • 持续集成指的是,频繁地(一天多次)将代码集成到主干。将软件个人研发的部分向软件整体部分交付,频繁进行集成以便更快地发现其中的错误。
    • 它的好处主要有两个:
      • 快速发现错误。每完成一点更新,就集成到主干,可以快速发现错误,定位错误也比较容易。
      • 防止分支大幅偏离主干。如果不是经常集成,主干又在不断更新,会导致以后集成的难度变大,甚至难以集成。
    • 持续集成并不能消除Bug,而是让它们非常容易发现和改正。持续集成的目的,就是让产品可以快速迭代,同时还能保持高质量。它的核心措施是,代码集成到主干之前,必须通过自动化测试。只要有一个测试用例失败,就不能集成。

    持续交付

    • 持续交付(Continuous delivery)指的是,频繁地将软件的新版本,交付给质量团队或者用户,以供评审。如果评审通过,代码就进入生产阶段。
    • 持续交付在持续集成的基础上,将集成后的代码部署到更贴近真实运行环境的「类生产环境」(production-like environments)中。持续交付优先于整个产品生命周期的软件部署,建立在高水平自动化持续集成之上。
    • 持续交付可以看作持续集成的下一步。它强调的是,不管怎么更新,软件是随时随地可以交付的。

    持续部署CD

    • 持续部署(continuous deployment)是持续交付的下一步,指的是代码通过评审以后,自动部署到生产环境。
    • 持续部署的目标是,代码在任何时刻都是可部署的,可以进入生产阶段。
    • 持续部署的前提是能自动化完成测试、构建、部署等步骤。

    小结

    • 总的来说,持续集成、持续交付、持续部署提供了一个优秀的 DevOps 环境。对于整个开发团队来说,能很大地提升开发效率,好处与挑战并行。无论如何,频繁部署、快速交付以及开发测试流程自动化都将成为未来软件工程的重要组成部分。

    Jenkins

    Jenkins是什么

    • Jenkins是一款开源 CI&CD 软件,用于自动化各种任务,包括构建、测试和部署软件。Jenkins 支持各种运行方式,可通过系统包、Docker 或者通过一个独立的 Java 程序。
    • 官网:https://www.jenkins.io/zh/
    • 官方文档:https://www.jenkins.io/zh/doc/
    • Jenkins特性:
      • 开源的java语言开发持续集成工具,支持CI,CD;
      • 易于安装部署配置:可通过yum安装,或下载war包以及通过docker容器等快速实现安装部署,可方便web界面配置管理;
      • 消息通知及测试报告:集成RSS/E-mail通过RSS发布构建结果或当构建完成时通过e-mail通知,生成JUnit/TestNG测试报告;
      • 分布式构建:支持Jenkins能够让多台计算机一起构建/测试;
      • 文件识别:
      • Jenkins能够跟踪哪次构建生成哪些jar,哪次构建使用哪个版本的jar等;
      • 丰富的插件支持:支持扩展插件,你可以开发适合自己团队使用的工具,如git,svn,maven,docker等。

    Jenkins安装

    准备工作

    • 机器需求:
    * 256 MB 内存,建议大于 512 MB
    * 10 GB 的硬盘空间(用于 Jenkins 和 Docker 镜像)
    * Java 8 ( JRE 或者 JDK 都可以)
    * Docker
    

    安装启动

    • 下载安装包,并启动:
    wget http://mirrors.jenkins.io/war-stable/latest/jenkins.war
    nohup java -jar jenkins.war > jenkins.log 2>&1 &
    
    • 查看启动日志:

    在这里插入图片描述

    访问

    • 配置hosts:
    root$ vim /etc/hosts
    myjenkins.com	192.168.254.120
    

    在这里插入图片描述

    • 看到以下界面就是正常的:

    在这里插入图片描述

    • 这里我选择安装推荐的插件

    在这里插入图片描述

    • 上面等插件安装完后,就进入到下面界面,提示要创建第一个admin用户,并设置用户名密码。

    在这里插入图片描述

    • 点击保存并完成,然后进行实例配置,提示配置jenkins URL,这里保持默认即可,继续点击保存并完成

    在这里插入图片描述

    • 提示jenkins已经就绪,现在就可以开始使用jenkins了。

    在这里插入图片描述

    在这里插入图片描述

    Jenkins配置

    ## Path:        Development/Jenkins
    ## Description: Jenkins Automation Server
    ## Type:        string
    ## Default:     "/var/lib/jenkins"
    ## ServiceRestart: jenkins
    #
    # Directory where Jenkins store its configuration and working
    # files (checkouts, build reports, artifacts, ...).
    #
    JENKINS_HOME="/var/lib/jenkins"
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # Java executable to run Jenkins
    # When left empty, we'll try to find the suitable Java.
    #
    JENKINS_JAVA_CMD=""
    
    ## Type:        string
    ## Default:     "jenkins"
    ## ServiceRestart: jenkins
    #
    # Unix user account that runs the Jenkins daemon
    # Be careful when you change this, as you need to update
    # permissions of $JENKINS_HOME and /var/log/jenkins.
    #
    JENKINS_USER="jenkins"
    
    ## Type:        string
    ## Default: "false"
    ## ServiceRestart: jenkins
    #
    # Whether to skip potentially long-running chown at the
    # $JENKINS_HOME location. Do not enable this, "true", unless
    # you know what you're doing. See JENKINS-23273.
    #
    #JENKINS_INSTALL_SKIP_CHOWN="false"
    
    ## Type: string
    ## Default:     "-Djava.awt.headless=true"
    ## ServiceRestart: jenkins
    #
    # Options to pass to java when running Jenkins.
    #
    JENKINS_JAVA_OPTIONS="-Djava.awt.headless=true"
    
    ## Type:        integer(0:65535)
    ## Default:     8080
    ## ServiceRestart: jenkins
    #
    # Port Jenkins is listening on.
    # Set to -1 to disable
    #
    JENKINS_PORT="8080"
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # IP address Jenkins listens on for HTTP requests.
    # Default is all interfaces (0.0.0.0).
    #
    JENKINS_LISTEN_ADDRESS=""
    
    ## Type:        integer(0:65535)
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # HTTPS port Jenkins is listening on.
    # Default is disabled.
    #
    JENKINS_HTTPS_PORT=""
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # Path to the keystore in JKS format (as created by the JDK 'keytool').
    # Default is disabled.
    #
    JENKINS_HTTPS_KEYSTORE=""
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # Password to access the keystore defined in JENKINS_HTTPS_KEYSTORE.
    # Default is disabled.
    #
    JENKINS_HTTPS_KEYSTORE_PASSWORD=""
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # IP address Jenkins listens on for HTTPS requests.
    # Default is disabled.
    #
    JENKINS_HTTPS_LISTEN_ADDRESS=""
    
    
    ## Type:        integer(1:9)
    ## Default:     5
    ## ServiceRestart: jenkins
    #
    # Debug level for logs -- the higher the value, the more verbose.
    # 5 is INFO.
    #
    JENKINS_DEBUG_LEVEL="5"
    
    ## Type:        yesno
    ## Default:     no
    ## ServiceRestart: jenkins
    #
    # Whether to enable access logging or not.
    #
    JENKINS_ENABLE_ACCESS_LOG="no"
    
    ## Type:        integer
    ## Default:     100
    ## ServiceRestart: jenkins
    #
    # Maximum number of HTTP worker threads.
    #
    JENKINS_HANDLER_MAX="100"
    
    ## Type:        integer
    ## Default:     20
    ## ServiceRestart: jenkins
    #
    # Maximum number of idle HTTP worker threads.
    #
    JENKINS_HANDLER_IDLE="20"
    
    ## Type:        string
    ## Default:     ""
    ## ServiceRestart: jenkins
    #
    # Pass arbitrary arguments to Jenkins.
    # Full option list: java -jar jenkins.war --help
    #
    JENKINS_ARGS=""
    

    主程序目录

    在这里插入图片描述

    JDK配置

    在这里插入图片描述

    • Global Tool Configuration:先把JDK安装到Linux服务器,且配置完善

    在这里插入图片描述

    maven配置

    • 首先在服务器上安装并配置好maven

    在这里插入图片描述

    • jenkins 配置:

    在这里插入图片描述

    插件安装

    • 如果jenkins需要安装什么插件,可以直接安装即可。
    • Maven Integration plugin 安装此插件才能构建maven项目

    在这里插入图片描述

    • Deploy to container Plugin 安装此插件,才能将打好的包部署到tomcat上

    在这里插入图片描述

    系统设置

    在这里插入图片描述

    • 如果没安装 maven 插件就没有下面这个配置:

    在这里插入图片描述

    git配置

    • git地址错误:这是由于git客户端版本过低造成的!或者系统中没有安装git所造成的
      在这里插入图片描述
    • 所以,先安装git
    wget https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.1.1.tar.gz
    tar -zxvf git-2.1.1.tar.gz -C /usr/apps/
    cd /usr/apps/git-2.1.1/
    # 编译安装
    make prefix=/usr/local/git all
    make prefix=/usr/local/git install
    

    在这里插入图片描述

    持续构建

    构建maven项目

    • 新建 Item,名字随便起,选择构建一个maven项目。

    在这里插入图片描述

    构建配置

    在这里插入图片描述

    • 源码地址:

    在这里插入图片描述

    • 触发构建器:

    在这里插入图片描述

    构建成功

    在这里插入图片描述

    持续部署

    执行shell脚本

    #!/bin/bash
    
    # 这一句很重要,这样指定了,项目启动之后才不会被Jenkins杀掉。
    export BUILD_ID=dontKillMe
    
    # 指定最后编译好的 jar 存放的位置
    deploy_path=/usr/apps/vshop/vshop-seckill
    
    # Jenkins中编译好的 jar 的位置
    jar_path=/root/.jenkins/workspace/VSHOP-SECKILL/vshop-web/target
    
    # Jenkins中编译好的 jar 名称
    jar_name=seckill-web.jar
    
    # 将编译好的 jar 复制到最后指定的位置
    cp $jar_path/$jar_name  $deploy_path
    
    # 找到之前部署项目的PID
    PID=`jps | grep seckill-web.jar | awk '{print $1}'`
    
    # 杀掉以前可能启动的项目进程
    if [ -n "$PID" ]; then
    	kill -9 $PID
        rm -rf *.log
    fi
    
    # 启动
    nohup java -jar $deploy_path/$jar_name --server.port=8888 > $deploy_path/seckill-web.log 2>&1 &
    
    # 将进程ID存入到seckill-web.pid文件中
    echo $! > $deploy_path/seckill-web.pid
    
    • 以上脚本执行完毕,就会自动启动相应的项目。配置位置如下:

    在这里插入图片描述

    • 注意:必须加上 #!/bin/bash,否则不能启动起来。

    执行完毕

    在这里插入图片描述

    展开全文
  • jenkins持续集成

    2021-11-10 16:11:08
    1.持续集成(CICD) ​ 持续集成(ContinuousIntegration,简称CI),是一种软件开发实践,在实践中指只要代码有变更,就自动运行构建和测试,反馈运行结果。通俗一点来讲,就是绑定项目的代码仓库,SVN或者Git库,...

    1.持续集成(CICD)

    ​ 持续集成(ContinuousIntegration,简称CI),是一种软件开发实践,在实践中指只要代码有变更,就自动运行构建和测试,反馈运行结果。通俗一点来讲,就是绑定项目的代码仓库,SVN或者Git库,自动抓取新的代码,完成构建,甚至执行测试,部署到服务器。

    2.持续集成中概念解释

    2.1 持续集成(Continuous Integration)

    在这里插入图片描述

    ​ 持续集成强调开发人员提交了新代码之后,立刻进行构建、(单元)测试。根据测试结果,我们可以确定新代码和原有代码能否正确地集成在一起。

    2.2 持续交付(Continuous Delivery)

    在这里插入图片描述

    ​ 持续交付是在持续集成的基础上,将集成后的代码部署到更贴近真实运行环境(类生产环境)中。比如,我们完成单元测试后,可以把代码部署到连接数据库的测试环境中更多的测试。如果代码没有问题,可以继续手动部署到生产环境。

    2.3 持续部署(Continuous Deployment)

    在这里插入图片描述

    2.4 持续集成中关键词解释

    持续 (Continuous):不断的获取反馈,响应反馈。

    集成 (Integration):编译、测试、打包

    部署 (Deployment):应用组件或基本设施的代码或配置变更在产品环境生效称为“部署”;

    发布 (Release):具有业务影响的功能变化对最终用户可见称为“发布”

    交付 (Delivery):可以理解为从 Deployment (开发分支)到 Releas(测试分支) 之间的阶段,更多的强调的是一种能力。开发有能力频繁的部署,业务有能力随时发布。

    频繁部署可以有效降低变更带来的风险,同时业务负责人仍然能保持何时向最终用户发布功能的控制。

    3.持续集成优点

    1. 能够快速暴露错误。

    2. 保证代码提交质量。

    3. 定位错误更加容易。

    4. 降低整体集成风险。

    5. 促进产品快速迭代。

    4. 持续集成原理图

    在这里插入图片描述

    5. 部署流程

    1、用户提交代码到Git仓库
    2、Jenkins服务器从指定Git仓库拉去代码,使用maven编译打包。
    3、Jenkins服务器ssh连接应用服务器,将打包好的war或者jar包传送到应用服务器指定位置,例如 tomcat/webapps
    4、Jenkins服务器在应用服务器远程执行脚本文件 重启应用服务器tomcat 或者 在应用服务器执行 java -jar 启动当前项目

    6. Jenkins安装

    Jenkins是什么

    ​ Jenkins是一个开源的、提供友好操作界面的持续集成(CI)工具,起源于Hudson(Hudson是商用的),主要用于持续、自动的构建/测试软件项目、监控外部任务的运行。Jenkins用Java语言编写,可在Tomcat等流行的servlet容器中运行,也可独立运行。通常与版本管理工具、构建工具结合使用。常用的版本控制工具有SVN、GIT,构建工具有Maven、Ant、Gradle。

    6.1 配置步骤

    1)将tomcat、git、jenkins、maven放到存放jenkins的服务器,例如/usr/local/soft/jenkins下

    2)将tomcat解压,并将jenkens放入tomcat的webapps中

    3)需要搭两台tomcat,将jenkins中的端口改掉:分别为:8081ip、8015shutdown、8019AJP/1.3

    4)相关jar包下载地址(自己去官网下也行):https://download.csdn.net/download/weixin_44314059/39664039
    在这里插入图片描述

    6.2 启动Tomcat会自动解压war包

    ./startup.sh
    

    6.3 浏览器访问

    http://192.168.193.110/jenkins/
    

    在这里插入图片描述

    6.4 输入密码登录

    cat /root/.jenkins/secrets/initialAdminPassword 
    

    如果让选择安装插件,不要安装,拆掉就可以

    在这里插入图片描述
    在这里插入图片描述

    7 安装Git

    7.1 Git下载地址

    https://mirrors.edge.kernel.org/pub/software/scm/git/
    

    7.2 Git上传到Linux并解压

    // 1.把git的安装包上传到/usr/local/soft下面
    // 3.解压 tar -zxf git-2.10.0.tar.gz
    

    7.3 安装Git所需要的组件

    yum install -y curl-devel expat-devel gettext-devel openssl-devel zlib-devel
    yum install -y gcc perl-ExtUtils-MakeMaker
    

    7.4 安装Git(源码)

    yum remove git  //删除系统已经有的git ,这个一定要执行
        
    cd /usr/local/soft/git-2.10.0 // 进入到git目录
        
    make prefix=/usr/local/git all   //编译
        
    make prefix=/usr/local/git install // 安装
    

    7.5 配置环境变量

    vim /etc/profile 
    #添加如下配置文件 
    export GIT=/usr/local/git
     
    export PATH=$PATH:$GIT/bin 
        
    #刷新配置文件   
    source /etc/profile  
    
     #测试
    git --version    
    

    8. 安装Maven

    // 1.上传maven.tar.gz到/usr/local/soft
    
    // 2.创建/usr/local/maven目录
    
    // 3. 把maven.tar.gz解压到/usr/local/soft/maven目录下
    

    8.1 配置环境变量

    vim /etc/profile
    

    在这里插入图片描述

    8.2 重新初始化配置文件

    source /etc/profile
    

    8.3 检查maven是否配置成功

    mvn --version
    

    在这里插入图片描述

    8.4 配置阿里云私服

    	 <mirror>
    		<id>alimaven</id>
    		<mirrorOf>central</mirrorOf>
    		<name>aliyun maven</name>
    		<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
    	</mirror>
    

    9.Jenkins配置

    9.1 全局安全配置-取消Jenkins认证

    在这里插入图片描述

    在这里插入图片描述

    9.2 安装GIt插件

    9.2.1 进入插件管理

    在这里插入图片描述

    9.2.2 搜索Git插件并安装

    在这里插入图片描述

    在这里插入图片描述

    9.2.4 使用本地已下载的插件

    由于远程下载比较缓慢,此处将之前下载好的plugins,直接拖拽到root/.jenkins目录下即可

    9.2.4 验证Git插件是否安装成功

    在这里插入图片描述在这里插入图片描述

    9.25 推送项目到码云

    1)创建本地web项目

    2)在码云中创建对应仓库

    3)将本地数据推送到远程仓库

    10.在Jenkins创建一个项目

    在这里插入图片描述

    在这里插入图片描述

    10.1 配置项目描述

    在这里插入图片描述

    10.2 配置Git拉取代码路径

    在这里插入图片描述

    10.3 配置Maven构建命令

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    11.4. 准备部署服务器

    // 1.上传tomcat.tar.gz到服务器
    // 2.注意要修改tomcat的端口号,不要和部署Jenkins服务器的端口号冲突
    // 3.在tomcat/conf/tomcat-users.xml中配置用户
    
     <role rolename="manager-gui"/>
     <role rolename="manager-script"/>
     <role rolename="manager-jmx"/>
     <role rolename="manager-status"/>
     <user username="tomcat" password="tomcat" roles="manager-gui,manager-script,manager-jmx,manager-status"/>
         
    //注意:此处配置后,如果不行,需要将META-INF下的Value标签注释掉    
    

    11.5 配置项目远程发布

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    如果这里没有 “Deploy war/ear to a container”选项 ,说明没有安装 Deploy to container 插件,到插件管理中搜索这个插件安装即可。

    img

    11.6 测试手动构建项目

    在这里插入图片描述

    11.7 设置自动构建项目

    配置自动构建项目

    在这里插入图片描述

    ​ http://192.168.31.73:8081/jenkins/job/jt/build?token=123456

    设置git发送url触发自动部署

    在git仓库点击管理,选择webhooks

    在这里插入图片描述

    他会push后自动发送一个请求,点击添加

    在这里插入图片描述

    但是该ip地址是虚拟机的地址外网无法访问,我们需要设置内网穿透

    使用natapp设置内网穿透,教程官网有,需要下载一个客户端

    在这里插入图片描述

    最后在设置jenkins的跨域保护,在全局安全里面设置

    在这里插入图片描述

    最后测试
    附上用上的相关jar包下载地址(自己去官网下也行):https://download.csdn.net/download/weixin_44314059/39664039

    展开全文
  • 第一部分 Jenkins持续集成平台搭建 一、整体配置 大致流程说明: 开发人员把代码提交到Gitlab代码仓库 Jenkins从Gitlab中拉取项目源码,编译并打成jar包,然后构建成Docker镜像,将镜像上传到Harbor私有仓库。 ...

    第一部分 Jenkins持续集成平台搭建

    一、整体配置

    大致流程说明:

    1. 开发人员把代码提交到Gitlab代码仓库
    2. Jenkins从Gitlab中拉取项目源码,编译并打成jar包,然后构建成Docker镜像,将镜像上传到Harbor私有仓库。
    3. Jenkins发送SSH远程命令,让生产部署服务器到Harbor私有仓库拉取镜像到本地,然后创建容器。
    4. 最后,用户可以访问到容器

    二、代码托管平台搭建

    2.1.GitLab安装及配置

    1.安装相关依赖

    yum -y install policycoreutils openssh-server openssh-clients postfix
    

    2.启动ssh服务&设置为开机启动

    systemctl enable sshd && sudo systemctl start sshd
    

    3.设置postfix开机自启,并启动

    systemctl enable postfix && systemctl start postfix
    

    4.关闭防火墙

    systemctl stop firewalld.service
    

    5.下载GitLab包,并安装

    wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el6/gitlab-ce-12.4.2-ce.0.el6.x86_64.rpm
    
    rpm -i gitlab-ce-12.4.2-ce.0.el6.x86_64.rpm
    

    6.修改GitLab配置

    vim /etc/gitlab/gitlab.rb
    
    external_url 'http://192.168.1.220:8888'
    nginx['listen_port'] = 8888
    

    7.重载配置并启动GitLab

    gitlab-ctl reconfigure
    gitlab-ctl restart
    

    在浏览器输入**http://192.168.1.220:8888** 即可进行访问。

    三、持续集成平台搭建

    3.1.Jenkins安装及配置

    3.1.安装JDK

    yum install java-1.8.0-openjdk* -y
    

    安装目录为:/usr/lib/jvm

    3.2.安装Jenkins

    1.获取Jenkins安装包

    下载地址:https://jenkins.io/zh/download/

    安装文件:jenkins-2.323-1.1.noarch.rpm

    2.把安装包上传到**192.168.1.222**,进行安装

    rpm -ivh jenkins-2.323-1.1.noarch.rpm
    

    3.修改Jenkins配置

    vim /etc/syscofig/jenkins
    
    JENKINS_USER="root
    JENKINS_PORT="8080"
    

    4.启动Jenkins

    systemctl start jenkins
    systemctl enable jenkins //开机自启
    

    5.打开浏览器访问

    http://192.168.1.222:8080

    6.获取admin账户密码

    cat /var/lib/jenkins/secrets/initialAdminPassword
    

    7.自定义Jenkins->安装推荐的插件

    8.创建用户,直接下一步完成。

    3.3.安装Git插件和Git工具

    3.3.1.安装Git工具
    yum install git -y
    
    3.3.2.安装Git插件

    image-20211203153050516

    3.3.3.Git访问配置
    3.3.3.1.用户密码类型

    Jenkins->凭证->系统->全局凭证->添加凭证选择"Username with password",输入Gitlab的用户名和密码,点击"确定"。

    image-20211203153326132 image-20211203153342450
    3.3.3.2.SSH密钥类型

    1.使用root用户生成公钥和私钥

    ssh-keygen -t rsa
    

    2.把生成的公钥放在GitLab中

    ​ 以root账户登录->点击头像->Settings->SSH Keys

    ​ 复制刚才id_rsa.pub文件的内容到这里,点击"Add Key"

    image-20211203171537354

    3.在Jenkins中添加凭证,配置私钥

    ​ 在Jenkins添加一个新的凭证,类型为"SSH Username with private key",把刚才生成私有文件内容复制过来

    image-20211203171627824
    3.3.4.Maven安装

    1.先上传maven软件到**192.168.1.222**中

    #解压
    tar -xzf apache-maven-3.6.3-bin.tar.gz
    #创建maven安装目录
    mkdir -p /usr/local/java/maven
    #移动解压后的文件到安装目录
    mv apache-maven-3.6.3/* /usr/local/java/maven 
    

    2.配置环境

    vim /etc/profile
    
    export JAVA_HOME=/usr/local/java/jdk1.8 
    export MAVEN_HOME=/usr/local/java/maven 
    export PATH=$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin
    
    #重载配置文件
    source /etc/profile
    
    3.3.5.Docker安装

    1.卸载旧版本

    #列出当前所有docker的包
    yum list installed | grep docker
    #卸载docker包
    yum -y remove docker的包名称
    #删除docker的所有镜像和容器
    rm -rf /var/lib/docker
    

    2.安装必要软件包

    sudo yum install -y yum-utils \ device-mapper-persistent-data \ lvm2
    

    3.设置下载的镜像仓库

    sudo yum-config-manager \ --add-repo \ https://download.docker.com/linux/centos/docker-ce.repo
    

    4.安装docker

    sudo yum install docker-ce-20.10.11.ce
    

    5.启动Docker

    #启动
    sudo systemctl start docker
    #设置开机启动
    sudo systemctl enable docker
    

    6.添加阿里云镜像加速地址

    vim /etc/docker/daemon.json
    
    {
        "registry-mirrors": ["https://xmgk9z80.mirror.aliyuncs.com"],
        /*
        	添加Harbor地址到Docker的信任列表,不加后续的镜像上传及拉取会有问题
        	The push refers to repository [xxx.xxx.xxx.xxx:xx/xx/xx] Get https://xxx.xxx.xxx.xxx:xx/xx/: http: server gave HTTP response to HTTPS client
        */
        "insecure-registries": ["192.168.1.221:81"]
    }
    

    7.重启Docker

    sudo systemctl restart docker
    

    3.4.配置JDK、Maven环境

    1.配置JDK环境

    image-20211203160834787

    2.配置maven环境

    image-20211203160901429

    在后续Jenkins构建的时候会出现无法找到jdk和maven,需要创建软连接

    ln -s /usr/local/java/jdk1.8/bin/java /usr/bin/java
    ln -s /usr/local/java/apache-maven-3.6.3/bin/mvn /usr/bin/mvn
    

    3.2.安装SonarQube

    3.2.1.安装MySQL数据库

    1.下载官方repo

    wget -i -c http://dev.mysql.com/get/mysql57-community-release-el7-10.noarch.rpm
    

    2.安装

    yum -y install mysql57-community-release-el7-10.noarch.rpm
    

    3.安装MySQL服务器

    yum -y install mysql-community-server
    

    4.启动MySQL

    systemctl start  mysqld.service
    

    5.查找root用户密码

    grep "password" /var/log/mysqld.log
    

    6.修改root密码

    # 进入数据库
    mysql -uroot -p
    #修改密码
    ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码';
    #开启远程访问
    grant all privileges on *.* to 'root'@'%' identified by 'password' with grant option;
    #刷新MySQL的系统权限相关表
    flush privileges; 
    

    7.修改MySQL编码

    vim /etc/my.cnf
    
    [client]
    default-character-set=utf8
    
    character-set-server=utf8
    collation-server=utf8_general_ci
    

    8.重启MySQL

    systemctl restart mysqld.servie
    

    3.2.2.安装SonarQube

    1.在MySQL数据库中创建sonar数据库

    image-20211203162842436

    2.下载SonarQube安装包

    https://www.sonarqube.org/downloads/

    3.将安装包上传到**192.168.1.222**

    4.解压并设置权限

    #安装unzip
    yum install unzip
    #解压
    unzip sonarqube-6.7.4.zip
    #创建目录
    mkdir /usr/local/java/sonar
    #移动文件
    mv sonarqube-6.7.4/* /usr/local/java/sonar
    #创建sonar用户,必须sonar用于启动,否则报错
    useradd sonar
    #更改sonar目录及文件权限
    chown -R sonar. /usr/local/java/sonar
    

    5.修改sonar配置文件

    vim /usr/local/java/sonar/conf/sonar.properties
    
    sonar.jdbc.username=root 
    sonar.jdbc.password=xxxxxx
    sonar.jdbc.url=jdbc:mysql://localhost:3306/sonar?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useConfigs=maxPerformance&useSSL=false
    

    6.启动sonar

    cd /usr/local/java/sonar
    #启动
    su sonar ./bin/linux-x86-64/sonar.sh start
    

    7.访问sonar

    http://192.168.1.222:9000

    默认账户密码:admin/admin

    8.创建token

    image-20211203163617246

    token一定要记下来,配置需要使用

    3.2.3.安装SonarQube Scanner插件

    1.安装插件

    image-20211203163725614

    2.添加SonarQube凭证

    image-20211203163748343 image-20211203163803670

    3.在Jenkins中配置SonarQube

    image-20211203163929151 image-20211203164109897

    4.SonarQube关闭审查结构上传到SCM功能

    image-20211203164215935

    3.3部署应用环境搭建

    1.安装Publish Over SSH插件

    image-20211203164549314

    2.拷贝公钥到远程服务器

    #拷贝公钥到远程服务器
    ssh-copy-id 192.168.66.103
    

    3.在Jenkins中配置环境

    image-20211203164746349

    四、Docker仓库搭建

    4.1.Harbor安装及配置

    1.安装Docker

    2.安装docker-compose,并添加执行权限

    #安装docker-compose
    sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker- compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
    #添加执行权限
    sudo chmod +x /usr/local/bin/docker-compose
    

    3.下载Harbor安装包

    https://github.com/goharbor/harbor/releases

    4.上传安装包到**192.168.1.221**,并解压

    tar -xzf harbor-offline-installer-v1.9.2.tgz
    mkdir /usr/local/java/harbor
    mv harbor/* /usr/local/java/harbor
    cd /usr/local/java/harbor
    

    5.修改Harbor配置

    vim harbor.yml
    
    hostname: 192.168.1.221
    port: 81
    

    6.安装Harbor

    ./perpare
    ./install.sh
    

    7.启动Harbor

    docker-compose up -d
    

    8.访问Harbor

    http://192.168.1.221:81

    默认账户密码:admin/Harbor12345

    五、部署服务器搭建

    5.1.安装Docker

    安装步骤和上边一致

    {
        "registry-mirrors": ["https://xmgk9z80.mirror.aliyuncs.com"],
        /*
        	添加Harbor地址到Docker的信任列表,不加后续的镜像上传及拉取会有问题
        	The push refers to repository [xxx.xxx.xxx.xxx:xx/xx/xx] Get https://xxx.xxx.xxx.xxx:xx/xx/: http: server gave HTTP response to HTTPS client
        */
        "insecure-registries": ["192.168.1.221:81"]
    }
    

    第二部分 Jenkins持续集成平台使用

    一、Jenkins部分

    1.1.创建一个Item

    image-20211203165009015

    1.2.配置Item

    image-20211203165148657 image-20211203165313564

    3.点击应用保存即可

    这里我们测试Demo为前后端分离,一个后台代码,一个前端代码

    二、代码部分

    2.1.后台代码

    2.1.1.pom文件添加依赖

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- dockerfile插件  -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.4.13</version>
                <configuration>
                    <repository>${project.artifactId}</repository>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    

    2.1.2.添加Dockerfile文件

    在项目根目录添加名为**Dockerfile**文件

    FROM openjdk:8-jdk-alpine
    ARG JAR_FILE
    COPY ${JAR_FILE} app.jar
    EXPOSE 10086
    ENTRYPOINT ["java", "-jar", "/app.jar"]
    

    2.1.3.添加Jenkinsfile文件

    在项目根目录添加名为**Jenkinsfile**文件

    内容根据自己项目进行修改

    //项目分支
    def branch = "master"
    //gitlab平台jenkins凭证ID
    def gitlab_auth = "801603ce-e268-4349-8b8e-6e517e1ea8be"
    //代码仓库地址
    def gitlab_url = "http://192.168.1.220:8888/root/jenkins-demo.git"
    //Harbor平台jenkins凭证ID
    def harbor_auth = "49867939-b8e4-4e4c-a230-71f724022575"
    //Docker镜像仓库地址
    def harbor_url = "192.168.1.221:81"
    //Docker仓库项目名称
    def harbor_project = "jenkins"
    //应用镜像名称
    def image_name = "jenkins-demo"
    //镜像版本号
    def tag = "latest"
    //应用端口
    def port = "10086"
    //部署脚本地址
    def shell_url = "/usr/local/java/jenkins_shell/deploy.sh"
    try{
        node {
            stage('拉取代码') {
                checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${gitlab_auth}", url: "${gitlab_url}"]]])
            }
            stage('编译打包,构建Dokcer镜像') {
                //编译,构建本地镜像
                sh "mvn clean package dockerfile:build"
            }
            stage('上传镜像到Docker仓库') {
                 //给镜像打标签
                sh "docker tag ${image_name} ${harbor_url}/${harbor_project}/${image_name}"
                //登录Harbor,并上传镜像
                withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
                    //登录到Harbor
                    sh "docker login -u ${username} -p ${password} ${harbor_url}"
                    //上传镜像
                    sh "docker push ${harbor_url}/${harbor_project}/${image_name}"
                }
                //删除本地镜像
                sh "docker rmi -f ${image_name}"
                sh "docker rmi -f ${harbor_url}/${harbor_project}/${image_name}"
            }
            stage('代码审查') {
                //定义scanner工具
                script {
                    scannerHome = tool 'scanner'
                }
                //执行SonarQubeScanner
                withSonarQubeEnv('sonarqube') {
                    sh "${scannerHome}/bin/sonar-scanner"
                }
            }
            stage('应用发布') {
                sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '${shell_url} ${harbor_url} ${harbor_project} ${image_name} ${tag} ${port}', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
    }
    catch (err){
        currentBuild.result="FAILURE"
    }
    finally{
        //构建后操作,发送构建结果到指定邮箱
        node(env.BuildMachineLabel){
            stage("发送邮件") {
                emailext(
                    subject: '构建通知: ${PROJECT_NAME} - Build # ${BUILD_NUMBER} - ${BUILD_STATUS}!',
                    body: '${FILE, path="email-template.html"}',
                    to: 'xxxxxx@xx.xx'
                )
            }
        }
    }
    

    2.1.4.添加邮件模板(随意)

    文件名称根据流水线脚本来,我这里设置的是**email-template.html**

    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>${ENV, var="JOB_NAME"}-第${BUILD_NUMBER}次构建日志</title>
    </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>
            <td>(本邮件程序自动下发,请勿回复!)</td>
        </tr>
        <tr>
            <td><h2>
                <font color="#0000FF">构建结果 - ${BUILD_STATUS}</font>
            </h2></td>
        </tr>
        <tr>
            <td><br/>
                <b><font color="#0B610B">构建信息</font></b>
                <hr size="2" width="100%" align="center"/>
            </td>
        </tr>
        <tr>
            <td>
                <ul>
                    <li>项目名称&nbsp;&nbsp;${PROJECT_NAME}</li>
                    <li>构建TAG&nbsp;&nbsp;${BUILD_TAG}</li>
                    <li>构建编号&nbsp;&nbsp;第${BUILD_NUMBER}次构建</li>
                    <li>触发原因:&nbsp;${CAUSE}</li>
                    <li>构建日志:&nbsp;<a href="${BUILD_URL}console">${BUILD_URL}console</a></li>
                    <li>构建&nbsp;&nbsp;Url&nbsp;&nbsp;<a href="${BUILD_URL}">${BUILD_URL}</a></li>
                    <li>工作目录&nbsp;&nbsp;<a href="${PROJECT_URL}ws">${PROJECT_URL}ws</a></li>
                    <li>项目&nbsp;&nbsp;Url&nbsp;&nbsp;<a href="${PROJECT_URL}">${PROJECT_URL}</a></li>
                </ul>
            </td>
        </tr>
        <tr>
            <td><b><font color="#0B610B">Changes Since Last
                Successful Build:</font></b>
                <hr size="2" width="100%" align="center"/>
            </td>
        </tr>
        <tr>
            <td>
                <ul>
                    <li>历史变更记录 : <a href="${PROJECT_URL}changes">${PROJECT_URL}changes</a></li>
                </ul>
                ${CHANGES_SINCE_LAST_SUCCESS,reverse=true, format="Changes for Build #%n:<br/>%c<br/>",showPaths=true,changesFormat="
                <pre>[%a]<br/>%m</pre>
                ",pathFormat="&nbsp;&nbsp;&nbsp;&nbsp;%p"}
            </td>
        </tr>
        <tr>
            <td><b>Failed Test Results</b>
                <hr size="2" width="100%" align="center"/>
            </td>
        </tr>
        <tr>
            <td><pre
                    style="font-size: 11pt; font-family: Tahoma, Arial, Helvetica, sans-serif">$FAILED_TESTS</pre>
                <br/></td>
        </tr>
        <tr>
            <td><b><font color="#0B610B">构建日志 (最后 100行):</font></b>
                <hr size="2" width="100%" align="center"/>
            </td>
        </tr>
        <tr>
            <td><textarea cols="80" rows="30" readonly="readonly"
                          style="font-family: Courier New">${BUILD_LOG, maxLines=100}</textarea>
            </td>
        </tr>
    </table>
    </body>
    </html>
    

    2.2.前端部分

    2.2.1.添加Jenkinsfile文件

    在项目根目录添加名为**Jenkinsfile**文件

    //项目分支
    def branch = "master"
    //gitlab平台jenkins凭证ID
    def gitlab_auth = "801603ce-e268-4349-8b8e-6e517e1ea8be"
    //代码仓库地址
    def gitlab_url = "http://192.168.1.220:8888/root/jenkins-ui.git"
    node {
        stage('拉取代码') {
            checkout([$class: 'GitSCM', branches: [[name: "*/${branch}"]], extensions: [], userRemoteConfigs: [[credentialsId: "${gitlab_auth}", url: "${gitlab_url}"]]])
        }
        stage('node安装及项目构建') {
            nodejs('nodejs') {
                sh '''
                    npm install
                    npm run build
                '''
            }
        }
        stage('项目部署') {
            sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/usr/share/nginx/html', remoteDirectorySDF: false, removePrefix: 'dist', sourceFiles: 'dist/**')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
        }
    }
    

    三、部署服务器部分

    3.1.部署shell脚本

    1.在服务器中创建一个目录,存放部署脚本

    mkdir /usr/local/java/jenkins_shell
    cd /usr/local/java/jenkins_shell
    

    2.创建部署shell脚本

    vim deploy.sh
    
    #! /bin/sh 
    #接收外部参数
    harbor_url=$1 
    harbor_project_name=$2 
    project_name=$3 
    tag=$4 
    port=$5 
    imageName=$harbor_url/$harbor_project_name/$project_name:$tag 
    echo "$imageName" 
    #查询容器是否存在,存在则删除 
    containerId=`docker ps -a | grep -w ${project_name}:${tag} | awk '{print $1}'` 
    if [ "$containerId" != "" ] ; then 
    #停掉容器 
        docker stop $containerId 
        #删除容器 
        docker rm $containerId 
        echo "成功删除容器" 
    fi
    #查询镜像是否存在,存在则删除 
    imageId=`docker images | grep -w $project_name | awk '{print $3}'` 
    if [ "$imageId" != "" ] ; then 
        #删除镜像 
        docker rmi -f $imageId 
        echo "成功删除镜像" 
    fi
    # 登录Harbor私服 
    docker login -u admin -p Harbor12345 $harbor_url 
    # 下载镜像 
    docker pull $imageName 
    # 启动容器 
    docker run -di -p $port:$port $imageName
    echo "容器启动成功"
    

    3.为部署脚本添加执行权限

    chmod +x deploy.sh
    

    四、在Jenkins中进行构建

    构建项目

    image-20211203171756518

    构建日志控制台输出

    image-20211203171906106

    邮件接收内容

    image-20211203172219090 grep -w $project_name | awk '{print $3}'` if [ "$imageId" != "" ] ; then #删除镜像 docker rmi -f $imageId echo "成功删除镜像" fi # 登录Harbor私服 docker login -u admin -p Harbor12345 $harbor_url # 下载镜像 docker pull $imageName # 启动容器 docker run -di -p $port:$port $imageName echo "容器启动成功" ```

    3.为部署脚本添加执行权限

    chmod +x deploy.sh
    

    四、在Jenkins中进行构建

    构建项目

    image-20211203171756518

    构建日志控制台输出

    image-20211203171906106

    邮件接收内容

    image-20211203172219090
    展开全文
  • Jenkins持续集成

    2021-02-20 14:52:28
    持续集成:将不同的模块或者开发人员开发的功能进行整合;持续交付:可以重复性更新程序或者软件项目;持续部署:自动化部署软件项目,定期备份,部署项目异常回滚; 2)Jenkins使用的用户 开发人员:编写好的代码不...

    一、Jenkins概述

    1、Jenkins的作用和用户类型

    1)Jenkins的作用

    持续集成:将不同的模块或者开发人员开发的功能进行整合;
    持续交付:可以重复性更新程序或者软件项目;
    持续部署:自动化部署软件项目,定期备份,部署项目异常回滚;

    2)Jenkins使用的用户

    开发人员:编写好的代码不需要手动编译打包工作,直接将代码提交到SVN或者git中保存;
    运维人员:减轻管理员工作量,避免人工干预,减少错误率;
    测试人员:方便进行简单的代码测试,避免出现程序逻辑错误;

    2、Jenkins的特点和Jenkins的组件

    1)Jenkins的特点

    Jenkins使用JAVA语言编写的程序;
    开源自动化运维工具;
    提供开放的简单易用交付平台;
    方便用户安装和配置软件开发项目;
    提高软件开发效率,保证软件开发质量;
    方便用户持续部署项目和测试项目;

    2)Jenkins需要的组件

    自动构建软件或者程序运行过程:自动编译源代码程序分发编译的程序到服务器、部署程序到服务器、测试部署服务;

    代码存储库:存储用户开发的程序,控制程序的版本,使用SVN或者git;

    持续集成服务:使用Jenkins持续部署开发的项目,对项目进行备份,发现项目异常进行回滚;

    3、Jenkins的特征:

    • 开源的Java语言开发持续继承工具,支持持续继承,持续部署;

    • 易于安装部署配置:可通过yum安装,下载war包以及通过docker容器等快速实现安装部署,使用web界面配置管理;

    • 消息通知及测试报告:集成RSS、E-mail通过RSS发布构建结果或者当构建完成时通过e-mail通知,生成JUnit/TestNG测试报告;

    • 分布式构建:Jenkins可以让多台计算机一起构建/测试(主从构建);

    • 文件识别:Jenkins可以跟踪哪次构建生成哪些jar,哪次构建使用哪个版本的jar等;

    • 丰富的插件支持:1000+插件;

    二、安装配置Jenkins

    1、安装Jenkins

    <!--此案例环境是Docker环境,连接公网,内存4GB,CPU2个-->
    [root@centos01 ~]# wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo   
    <!--下载Jenkins源-->
    [root@centos01 ~]# rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key   <!--导入jenkins公钥-->
    [root@centos01 ~]# yum -y install java-1.8.0-openjdk-devel java-1.8.0-openjdk  <!--安装JDK-->
    [root@centos01 ~]# yum -y install jenkins   <!--安装Jenkins-->
    <!--网速慢的换需要等待很长时间-->
    <!--或者通过离线包安装Jenkins,访问清华大学源网站,下载相应的Jenkins版本包,上传到服务器进行安装-->
    <!--清华大学源网站:https://mirror.tuna.tsinghua.edu.cn/jenkins/-->
    [root@centos01 ~]# ls
    jenkins-2.238-1.1.noarch.rpm   <!--上传离线rmp包安装jenkins-->
    [root@centos01 ~]# rpm -ivh jenkins-2.238-1.1.noarch.rpm <!--通过离线包安装Jenkins-->
    [root@centos01 ~]# systemctl start jenkins;systemctl enable jenkins  
    <!--启动Jenkins服务,设置开机自动启动-->
    <!--或者-->
    [root@centos01 ~]# /etc/init.d/jenkins start  <!--启动jenkins-->
    [root@centos01 ~]# /etc/init.d/jenkins restart  <!--重新启动jenkins-->
    [root@centos01 ~]# netstat -anptu |grep 8080  <!--监听tomcat端口是否启动-->
    tcp6       0      0 :::8080                 :::*                    LISTEN      6504/java

    2、初始化Jenkins

    1)访问Jenkins的web管理页面http://192.168.100.10:8080

    安装Jenkins持续集成服务

    2)获取管理员密码,也可以查看jenkins日志获取密码

    [root@centos01 ~]# less /var/log/jenkins/jenkins.log

    安装Jenkins持续集成服务

    3)将jenkins默认推荐的插件装上

    安装Jenkins持续集成服务

    4)等待推荐插件安装完成

    安装Jenkins持续集成服务

    5)典型的各别插件安装失败,点击重试重新安装即可

    安装Jenkins持续集成服务

    6)新创建一个管理用户或者继续使用admin

    安装Jenkins持续集成服务

    7)访问Jenkins的URL

    安装Jenkins持续集成服务

    8)Jenkins插件安装完成

    安装Jenkins持续集成服务

    9)修改Jenkins主配置文件

    [root@centos01 ~]# vim /etc/sysconfig/jenkins
    10 JENKINS_HOME="/var/lib/jenkins"
    29 JENKINS_USER="jenkins"
    56 JENKINS_PORT="8080"
    65 JENKINS_LISTEN_ADDRESS="192.168.100.10"
    150 JENKINS_HANDLER_MAX="100"
    [root@centos01 ~]# systemctl restart jenkins  <!--重新启动Jenkins重新访问-->

    3、安装publish over ssh插件

    1)管理Jenkins插件

    安装Jenkins持续集成服务

    2)点击可选插件,搜索publish over ssh并直接安装

    安装Jenkins持续集成服务

    3)静静的等待他安装完成

    安装Jenkins持续集成服务

    4)下载完成自动重启Jenkins

    安装Jenkins持续集成服务

    5)重启完成后登录Jenkins,去已安装插件中验证publish over ssh是否安装成功

    安装Jenkins持续集成服务

    4、配置SSH

    <!--需要再开一台服务器(100.20)-->
    [root@centos01 ~]# ssh-keygen -t rsa  <!--Jenkins服务器生成ssh密钥-->
    [root@centos01 ~]# cat /etc/ssh/sshd_config | grep AuthorizedKeysFile  
        <!--查看Jenkins服务器自己公钥保存位置-->
    AuthorizedKeysFile      .ssh/authorized_keys
    [root@centos01 ~]# cat .ssh/id_rsa.pub >> .ssh/authorized_keys 
       <!--将Jenkins自己的公钥输入到公钥配置文件中保存-->
    [root@centos01 ~]# ssh-copy-id -i .ssh/id_rsa.pub root@192.168.100.20 
        <!--将Jenkins的ssh公钥拷贝到100.20服务器-->
    [root@centos01 ~]# ssh root@192.168.100.20 <!--Jenkins服务器测试免密远程100.20-->
    Last login: Mon Jun  1 16:10:06 2020 from 192.168.100.252
    [root@centos02 ~]# exit  <!---->

    5、配置Jenkins系统

    1)设置系统配置

    安装Jenkins持续集成服务

    2)Jenkins获取自动的私有并复制

    [root@centos01 ~]# cat .ssh/id_rsa

    3)添加Jenkins服务器的私钥

    安装Jenkins持续集成服务

    4)添加想要远程管理的客户端

    安装Jenkins持续集成服务

    5、Jenkins创建新任务

    1)Jenkins创建新任务

    安装Jenkins持续集成服务

    2)编辑任务名称

    安装Jenkins持续集成服务

    3)编辑通过什么源码下载pipework网络管理工具

    安装Jenkins持续集成服务

    4)配置构建后的操作步骤

    安装Jenkins持续集成服务

    5)将Jenkins服务器自己和100.20客户端都添加进来并进行配置

    安装Jenkins持续集成服务

    安装Jenkins持续集成服务

    6)查看是否构建成功

    安装Jenkins持续集成服务

    7)Jenkins服务器验证pipework网络管理工具是否下载成功

    [root@centos01 ~]# cd /tmp/
    [root@centos01 tmp]# ls
    accp
    akuma6688894331215680472jar
    hsperfdata_jenkins
    hsperfdata_root
    jetty-0_0_0_0-8080-war-_-any-4925329859175627632.dir
    jetty-0_0_0_0-8080-war-_-any-6066713579825404153.dir
    jna21252815367201186jar
    lua_SQXqZm
    systemd-private-9d09bb5b9f5b4ffd8c3a65fa0bb96fa5-chronyd.service-vFbZSP
    systemd-private-9d09bb5b9f5b4ffd8c3a65fa0bb96fa5-cups.service-AHVikS
    systemd-private-9d09bb5b9f5b4ffd8c3a65fa0bb96fa5-vgauthd.service-75jObR
    systemd-private-9d09bb5b9f5b4ffd8c3a65fa0bb96fa5-vmtoolsd.service-PBFEqQ
    tmp.W114IMXVc4
    winstone1052959205009407779.jar
    winstone4171593767117190229.jar
    [root@centos01 tmp]# ls accp/          <!--查看pipework工具是否下载成功-->
    docker-compose.yml  doctoc  LICENSE  pipework  pipework.spec  README.md

    8)100.20客户端查看pipework网络管理工具是否下载成功

    [root@centos02 ~]# cd /tmp/
    [root@centos02 tmp]# ls
    benet
    systemd-private-4156eeb648fe41a4bcd4092c5d684853-chronyd.service-YBc3RX
    systemd-private-4156eeb648fe41a4bcd4092c5d684853-cups.service-X7gmHo
    systemd-private-4156eeb648fe41a4bcd4092c5d684853-vgauthd.service-BesDwC
    systemd-private-4156eeb648fe41a4bcd4092c5d684853-vmtoolsd.service-tzaBYh
    [root@centos02 tmp]# ls benet/      <!--查看pipework工具是否下载成功-->
    docker-compose.yml  doctoc  LICENSE  pipework  pipework.spec  README.md

    9)可以将下载好的pipework网络管理工具打包下载到宿主机

    安装Jenkins持续集成服务

    10)删除pipework任务,以后不再自动更新下载pipework

    安装Jenkins持续集成服务

    ————————————本文到此结束,感谢观看——————————————

    展开全文
  • 从零开始学习搭建jenkins,到自动执行自动化测试。 作者是一个互联网行业的小测试,只为将自已学过的,工作中运用到的,及之前碰到的疑难问题且得到解决方面,和大家分享。作者将从UI自动化测试、接口自动化、简易...
  • 文章目录 1 git工具使用 1.1 git安装 1.2 git使用 1.3 远程仓库,将数据备份到云端 2.gitlab代码仓库 2.1 gitlab安装 2.2 gitlab使用 3.jenkins持续集成 4 开发人员Dockerfile->gitlab->触发jenkins->实现镜像转发 ...
  • jmeter+ant+jenkins持续集成

    千次阅读 2021-06-11 09:15:57
    windows(Jmeter+ant+Jenkins) 介绍 ...Jenkins是一款开源的CI/CD软件,因为功能齐全,插件丰富,支持各种运行方式,使用也很简单,是持续集成方面的领导者。 这样一个组合,就能让测试人员把j
  • 基于Kubernetes/K8S构建Jenkins持续集成平台Jenkins的Master-Slave分布式构建 Jenkins的Master-Slave分布式构建 什么是Master-Slave分布式构建 Jenkins的Master-Slave分布式构建,就是通过将构建过程分配到从属Slave...
  • Jenkins持续集成服务器

    2021-11-01 20:34:36
    一、Jenkins持续集成服务器 1、Jenkins安装 安装JDK yum install java-1.8.0-openjdk* -y 获取jenkins安装包 官网下载 把安装包上传到服务器,进行安装 rpm -ivh jenkins-2.190.3-1.1.noarch.rpm 修改Jenkins...
  • jenkins持续集成之java发布 1.将项目推送到gitlab 2.使用jenkins新建一个任务 流水线模式和freestyle都可 如上图,填入3个关键信息 3.脚本的修改 注意点 jenkins的工作空间为:/var/lib/jenkins/workspace 每当从...
  • 前面,小酋讲了“Pycharm+pytest+allure打造高逼格的测试报告”,但实际工作中,往往需要通过jenkins进行自动化测试用例的持续集成并自动生成测试报告。这样,我们的自动化测试环境才算完整了,下面来说说具体的安装...
  • Jenkins持续集成基础

    2021-10-19 19:39:30
    要理解持续集成,首先我们需要了解持续集成的整个生态系统。包括敏捷开发、持续集成、DevOps等相关概念。 一、敏捷开发 (一)敏捷的定义:敏捷是一个术语,用于描述强调增量交付,团队协作,持续计划和持续学习...
  • Jenkins附件: 链接:https://pan.baidu.com/s/13IziVsMbra4OZOVxy2G8YA 提取码:jenk 2、安装JDK 在 /etc/profile 配置Java环境 export JAVA_HOME=/home/jdk/jdk1.8.0_171 export PATH=$JAVA_HOME/bin:$...
  • 2)然后,jenkins作为代码持续集成工具,使用Git工具到Git仓库拉取代码到继承服务器,再配合JDK、Maven等软件完成代码编译、代码测试与审查、测试、打包等工作,在这个流程中每一步出错都会重新再执行一次整个流程 ...
  • 所以这两者结合起来,就可以实现开发者提交代码到GitLab,Jenkins以一定频率自动运行测试、构建和部署的任务,帮组开发团队更高效的集成和发布代码。下面是我最近安装GitLab+Jenkins环境的一个过程,记录下来,以备...
  • Jenkins 是基于Java开发的一种持续集成工具,所以,Jenkins需要Java环境。Jenkins版本是:JAVA版本是:Tomcat版本是:或者Jenkins版本是:2.10.2JAVA版本是:java 1.6.0Tomcat版本:tomcat1.6.0,tomcat7.0也是可以...
  • re+jenkins持续集成

    2021-11-03 21:43:00
    jenkins中生成RF的测试报告 下载插件groovy 在构建中选中Excute system Groovy script System.setProperty("hudson.model.DirectoryBrowserSupport.CSP", "") 在构建后选择Publish Robot Framework test resu
  • 在dos窗口输入命令执行 执行整个项目下的所有用例: pybot 项目路径 比如:pybot D:\install\python\robotframeworkwork\mashang\RF测试 RF+jenkins持续集成 1.在服务中启动Jenkins 2.在jenkins的插件中下载Robot ...
  • 本次记录针对java的接口自动化,涉及到(testng、allure、jenkins、git、maven)一、环境的准备1.JDK的安装与配置 ----自己百度;2.maven的安装与配置 ----自己百度;3.git(码云)的安装与配置----自己百度;4.准备一台...
  • Jenkins什么是持续集成持续集成到组成持续集成的好处JenkinsJenkins 安装和持续集成环境配置持续集成流程说明服务器列表Gitlab代码托管服务器安装GitLabGitLab 普通 安装GitLab Docker 安装Gitlab添加组、创建用户、...
  • 目录大纲1.... Jenkins构建项目失败 1. 错误:前言中不允许有内容 解决方法: 改jmeter.save.saveservice.output_format=csv 为jmeter.save.saveservice.output_format=xml,并去掉前面的注释符号# 2.
  • 三、使用jenkins,需要安装EmailExtention 构建触发器 #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2021/4/7 11:18 # @File : test_ecshop.py import time import unittest import HTMLTestRunner ...
  • RF+jenkins持续集成

    2021-11-03 21:29:34
    1.在服务器中启东jenkins通过tomcat,找到tomcat里面的startup.bat,然后再网页访问127.0.0.1:8080,看看我们的etomcat能否正常启动。 可以正常启动,我们再后面输入\jenkins,就会跳转到登陆页面,这时候输入账户和...
  • 这里写目录标题持续集成Jenkins介绍软件开发的生命周期软件开发的瀑布模型软件开发的敏捷开发模型什么是敏捷开发什么是持续集成持续集成的组成要素Jenkins介绍 持续集成Jenkins介绍 软件开发的生命周期 软件开发...
  • Jenkins是一个开源持续集成的工具,是由 JAVA 开发而成。 Jenkins 是一个调度平台,本身不处理任何事情,调用插件来完成所有的工作。 1.2 为什么需要Jenkins jenkins 能将各种开源的软件集成为一体,从而实现不同...
  • Jenkins持续集成步骤

    2021-01-29 14:58:54
    agent{label ‘jenkins-slave-XXX.XXX.XXX.XXX’} environment{ currentDay = getDay() } parameters{ choice(name: 'isRun', choices: ['True','False'], description: '请填写是否运行任务') choice(name
  • Jenkins持续集成小白入门教程(一) 持续集成及Jenkins介绍 Jenkins安装和持续集成环境配置 Jenkins构建Maven项目 Jenkins+Docker+SpringCloud微服务持续集成 基于Kubernetes/K8S构建Jenkins微服务持续集成平台 1、...
  • pybot 项目路径 比如:pybot D:\install\python\robotframeworkwork\mashang\RF测试 RF+jenkins持续集成 1:在服务中启动Jenkins 2:在jenkins的插件中下载Robot Framework 3:下载插件groovy 3:创建项目 1:在构建...
  • github+jenkins持续集成

    2021-12-13 10:24:01
    2.安装jenkins 添加依赖源 wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat-stable/jenkins.repo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key 安装jenkins yum ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,712
精华内容 15,484
关键字:

jekins持续集成

友情链接: Excel.zip