Jenkins

一、安装

1、安装Jdk和Jenkins

# rpm -ivh jdk-8u181-linux-x64.rpm 
# rpm -ivh jenkins-2.99-1.1.noarch.rpm

2、配置并启动

# vim /etc/sysconfig/jenkins                   修改执行任务的用户（默认jenkins）
JENKINS_USER="root"
# systemctl start jenkins                      启动服务# netstat -lntp | grep 8080

 

 

 修改密码

插件安装

# tar xf plugins.tar.gz
# mv plugins/*  /var/lib/jenkins/
# systemctl restart jenkins.service

主要的目录

/usr/lib/jenkins/                       #安装目录，WAR包
/etc/sysconfig/jenkins                  #配置文件/var/lib/jenkins/                       #默认的Jenkins_home
/var/log/jenkins/                       #日志文件

二、Jenkins使用

1、创建项目

 

 

 

 

 

2、配置jenkins+gitlab（拉取gitlab上的代码，然后推送到nginx站点目录）

1、环境
# yum install -y nginx  
# systemctl start nginx

2、下载码云代码
# git clone https://gitee.com/xianzi/html5.git
# rm -rf .git
# cp -av * /data/dzp

创建新的项目

# cd /data/dzp
# git init
# git remote add origin http://192.168.4.11/test/dzp.git
# git add .
# git commit -m "Initial commit"
# git push -u origin master

Jenkins操作（填写项目地址，只下载代码的用户）

 

 

 

 查看代码

 3、Jenkins代码推送到Web

通过脚本把代码从jenkins目录scp到web的站点目录

#!/bin/sh
CODE_DIR="/var/lib/jenkins/workspace/freestyle-job"
WEB_DIR="/usr/share/nginx"
IP=192.168.4.12
TIME=$(date +%F-%H-%M-%S)

cd $CODE_DIR && tar -zcf /tmp/web-${TIME}.tar.gz ./*
scp /tmp/web-${TIME}.tar.gz root@$IP:$WEB_DIR
ssh root@$IP "cd $WEB_DIR && mkdir web-$TIME"
ssh root@$IP "cd $WEB_DIR && tar xf web-${TIME}.tar.gz -C web-$TIME && rm -rf web-${TIME}.tar.gz"
ssh root@$IP "cd $WEB_DIR && rm -rf html && ln -s web-$TIME html"

1、提前做好秘钥认证，才能执行脚本
2、Jenkins执行的脚本用户默认是Jenkins，要修改成对应的用户才能执行脚本

4、配置自动触发构建

Jenkins操作（配置构建触发器，生成url和token，监听触发条件）

 

 Gitlab操作（配置项目的事件触发器，填写Jenkins的url和token）

 

 

测试是否自动触发

# vim index.html 
# git commit -am "modify index"

 5、自动触发构建完成后，返回状态给gitlab

gitlab操作（开启api访问并生成token）

 

 

 Jenkins操作

 

 

 

 

 检查结果

 

 三、创建Maven项目

 1、安装

1、下载包
官网：http://maven.apache.org/download.cgi
清华镜像：https://mirrors.tuna.tsinghua.edu.cn/apache/maven/
# wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz

2、安装
# rpm -ivh jdk-8u121-linux-x64.rpm                                 #安装Java环境
# tar xf apache-maven-3.3.9-bin.tar.gz
# mv apache-maven-3.3.9   /usr/local/
# ln -s /usr/local/apache-maven-3.3.9/  /usr/local/maven
# echo "export PATH=/usr/local/maven/bin/:$PATH" >>/etc/profile   #设置环境变量
# source /etc/profile
# mvn -v                                                          #查看版本、Java、系统信息等

3、安装目录结构
bin                            #maven命令
boot                           #有一个jar包，类加载器框架
conf                           #配置文件
Lib　　　　　　　　　　　　　　　　　#运行时需要的Java 类库

2、常用命令

validate（验证）                #验证项目正确，并且所有必要信息可用。
compile（编译）                 #编译项目源码
test（测试）                    #使用合适的单元测试框架测试编译后的源码。
package（打包）                 #源码编译之后，使用合适的格式（例如JAR格式）对编译后的源码进行打包。
integration‐test（集成测试）     #如果有需要，把包处理并部署到可以运行集成测试的环境中去。
verify（验证）                  #进行各种测试来验证包是否有效并且符合质量标准。
install（安装）                 #把包安装到本地仓库，使该包可以作为其他本地项目的依赖。
deploy（部署）                  #在集成或发布环境中完成，将最终软件包复制到远程存储库，以与其他开发人员和项目共享。
mvn clean (清除)               #清除上次编译的结果

3、Maven 仓库

Maven 仓库分为两类：
本地仓库和远程仓库。

远程仓库大致分为三类：
中央仓库：Maven 核心自带的远程仓库，它包含了绝大部分开源的构件；
私服：特殊的远程仓库，局域网内架设一个私有仓库服务器（如nexus），代理所有外部的远程仓库，内部的项目可以部署到私服上供其他项目使用； 
其他公开的远程仓库：常见的有Java.net Maven 库、JBoss Maven 库等。

默认情况下，Maven首先查看本地仓库，若本地仓库有，则直接使用，否则会去远程仓库查找。

4、本地仓库

maven的本地仓库，安装后不会创建，当第一次执行命令的时才创建。
本地仓库的默认位置：~/.m2/repository/(用户的目录下)，通过修改settings.xml配置本地仓库路径
<settings>
<localRepository>/opt/maven_repository</localRepository>
</settings>
也可以在用户.m2/目录生成setting.xml文件（默认没有），修改只针对用户生效（推荐）

5、远程仓库

1、中央仓库是默认的远程仓库，中央仓库包含了绝大多数流行的开源 Java 构件，以及源码、作者信息、SCM、信息、许可证信息等。简单的Java 项目依赖的构件都可以在这里下载到。
 <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
 </repositories>

2、私服是一种特殊的远程仓库，局域网内的仓库服务，供局域网内的 Maven 用户使用。
Maven 私服的特性：
1)节省自己的外网带宽
2.加速Maven 构件
3.部署第三方构件
4.提高稳定性，增强控制
5.降低中央仓库的负荷

6、配置使用远程仓库

方法一：在maven文件夹下的settings.xml中添加（对所有的项目都有效）
  <mirror>
           <id>alimaven</id>
           <name>aliyun maven</name>
           <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
           <mirrorOf>central</mirrorOf>
  </mirror>

方法二：在maven项目的pom.xml中添加（对当前项目有效）
   <!-- 使用aliyun镜像 -->
     <repositories>
           <repository>
                <id>aliyun</id>
                <name>aliyun</name>
                <url>http://maven.aliyun.com/nexus/content/groups/public</url>
           </repository>
     </repositories>

7、编译测试

1、上传项目（hello‐world.tar.gz）的源码包
2、修改远程仓库（阿里云）
# vim /usr/local/maven/conf/settings.xml(全局配置)
  <mirror>
      <id>nexus-aliyun</id>
      <name>nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>*</mirrorOf>        
  </mirror>
3、解压并编译打包
# tar xf hello-world.tar.gz 
# cd hello-world/               #必须包含pem.xml文件
# mvn test
# mvn clean  package 

8、创建maven私服nexus

安装

1、上传JDK和nexus安装包
私服nexus下载：https://www.sonatype.com/download-oss-sonatype
# wget https://sonatype-download.global.ssl.fastly.net/repository/downloads-prod-group/3/nexus-3.13.0-01-unix.tar.gz
# wget https://www.zhinengx.cn/store/thumbs/2018/0726/nexus-3.13.0-01-unix.tar.gz

2、安装jdk
# rpm ‐ivh jdk‐8u121‐linux‐x64.rpm

3、安装
# tar xf nexus-3.13.0-01-unix.tar.gz
# mv nexus-3.13.0-01 /usr/local/
# ln -s /usr/local/nexus-3.13.0-01 /usr/local/nexus 

4、启动nexus
# /usr/local/nexus/bin/nexus start
# vim /usr/local/nexus/bin/nexus.rc                    (启动会警告用root启动，nexus.rc文件)
  run_as_user="root"

5、查看端口（8081）
# netstat -lntp 

默认账户admin 密码 admin123

 配置proxy代理，改成阿里云https://maven.aliyun.com/nexus/content/groups/public/

 

maven-central：代理仓库，该仓库代理Maven中央仓库，策略为release，因此只会下载和缓存中央仓库中的发布版本的构件。
maven-releases： 宿主仓库，策略为release，用来部署组织内部的发布版本的构件。
maven-snapshots：宿主仓库，策略为snapshots，用来部署组织内部的快照版本的构件。
maven-public：仓库组，包含了以上3个仓库

 

 

 

 

 

 

 

 配置Maven使用私服（nexus安装配置完，修改maven的settings.xml文件）

1、找到<servers>标签，添加nexus认证信息
<servers>
  <server>
    <id>my-nexus-releases</id>
    <username>admin</username>
    <password>admin123</password>
  </server>
  <server>
    <id>my-nexus-snapshots</id>
    <username>admin</username>
    <password>admin123</password>
  </server>
<servers>

2、找到<mirrors>标签，添加镜像地址
<mirrors>
  <mirror>
    <id>nexus</id>
    <mirrorOf>*</mirrorOf>
    <url>http://192.168.4.12:8081/repository/maven-public/</url>
  </mirror>
</mirrors>

3、找到<profiles>标签，添加仓库信息
<profiles>
  <profile>
    <id>nexus</id>
    <!-- 私有库地址-->
    <repositories>
      <repository>
        <id>central</id>
        <url>http://192.168.4.12:8081/repository/maven-public/</url>
        <releases>
          <enabled>true</enabled>
        </releases>
        <snapshots>
          <enabled>true</enabled>
        </snapshots>
      </repository>
    </repositories>
    <!--插件库地址-->
    <pluginRepositories>
      <pluginRepository>
        <id>central</id>
        <url>http://192.168.4.12:8081/repository/maven-public/</url>
        <releases>
          <enabled>true</enabled>
        </releases>
        <snapshots>
          <enabled>true</enabled>
        </snapshots>
      </pluginRepository>
    </pluginRepositories>
  </profile>
</profiles>

4、找到<activeProfiles>标签，激活仓库
<activeProfiles>
    <activeProfile>nexus</activeProfile>
</activeProfiles>

5、配置完成后，重启nexus服务
# /usr/local/nexus/bin/nexus  restart
# mvn clean package 

Java代码上线

 1、上传项目并解压

# rz jeesns.tar.gz
# tar xf jeesns.tar.gz

2、gitlab创建一个新的项目

 3、上传代码到gitlab上

# cd jeesns
# rm -fr .git*
# git init
# git remote add origin http://192.168.4.11/test/maven.git
# git add .
# git commit -m "Initial commit"
# git push -u origin master

4、Jenkins拉取maven代码，利用mvn打包

 

 

 

 

 

 

 

 

 

 5、部署tomcat及数据库

部署tomcat

1、上传包
# rz apache-tomcat-8.0.27.tar.gz
# rz jdk-8u181-linux-x64.rpm

2、安装
# rpm -ivh jdk-8u181-linux-x64.rpm 
# mkdir /application
# tar xf apache-tomcat-8.0.27.tar.gz -C /application
# ln -s /application/apache-tomcat-8.0.27 /application/tomcat

3、加速tomcat启动
# vim /usr/java/jdk1.8.0_181-amd64/jre/lib/security/java.security 
117 securerandom.source=file:/dev/urandom 

4、启动tomcat
# /application/tomcat/bin/startup.sh 

5、查看端口并访问
# netstat -lntp
浏览器访问http://192.168.4.12:8090/

部署数据库

1、安装并启动
# yum install mariadb-server -y
# systemctl start mariadb.service 

2、修改数据库密码
# mysqladmin password 'root'

3、创建jeesns库
# mysql -uroot -proot -e "create database jeesns;"

4、#导入数据
# mysql -uroot -proot jeesns < jeesns/jeesns-web/database/jeesns.sql 
# mysql -uroot -proot -e "use jeesns; show tables"

6、利用Jenkins远程推送war包

ssh root@192.168.4.12 "mv /application/tomcat/webapps/* /opt"
scp /var/lib/jenkins/workspace/maven-job/jeesns-web/target/jeesns-web.war root@192.168.4.12:/application/tomcat/webapps/ROOT.war

刷新网页

 四、Pipeline项目

 1、概念

CI：持续集成，编译，发布，自动化测试
CD：持续部署，构建、测试和部署
pipeline 是帮助Jenkins实现CI到CD转变，定义 CD 流水线模式，包含构建、测试和发布

2、Jenkinsfile 语法

1、基本组成
Node：一个或多个节点或机器
Stage：阶段，如：构建阶段、测试阶段、部署阶段
Step：每个阶段具体的任务

2、语法分类
Pipeline 两种语法：
声明式：限制用户使用严格的预选定义的结构
脚本式：限制比较少

3、Jenkinsfile (声明式)
# 声明式格式结构：最外层pipeline{}，紧接着是 agent、stages 和steps
pipeline {
    agent any
    stages {
    stage('Build') {
        steps {
          echo 'Building..'
              }
        }

    stage('Test') {
        steps {
          echo 'Testing..'
              }
        }

    stage('Deploy') {
        steps {
            echo 'Deploying.    '
              }
        }
    }
}

4、Jenkinsfile (脚本式)
# 脚本式格式结构：可以有多个node，紧接着是stage和steps，结构简单
node {  
stage('Build') {
//
}
stage('Test') {
//
}
stage('Deploy') {
//
}
}

3、创建pipeline项目

 

 

 

pipeline{ 
    agent any 
stages{ 
    stage("get code"){ 
        steps{ 
            echo "get code from scm" 
        } 
    } 
    stage("package"){ 
        steps{ 
        echo "packge code" 
        } 
    } 
    stage("deploy"){ 
        steps{ 
            echo "deploy packge to node1" 
        } 
    } 
    } 
} 

 

 

 4、写到gitlab仓库中，直接调用（Jenkinsfile）

 

 

 

 

 

 

 

 

 

 

 

 5、使用 pipeline 实现 代码的发布

pipeline{ 
    agent any 
stages{ 
    stage("get code"){ 
        steps{ 
            echo "get code" 
        } 
    } 
    stage("unit test"){ 
        steps{ 
        echo "unit test" 
        } 
    } 
    stage("package"){ 
        steps{ 
    sh 'tar zcf /opt/web-${BUILD_ID}.tar.gz ./* --exclude=./.git --exclude=Jenkinsfile' 
        } 
    } 
    stage("deploy"){ 
        steps{ 
            sh 'ssh 192.168.4.12 "mkdir /usr/share/nginx/web-${BUILD_ID}"' 
            sh 'scp /opt/web-${BUILD_ID}.tar.gz 192.168.4.12:/usr/share/nginx/web-${BUILD_ID}' 
            sh 'ssh 192.168.4.12 "cd /usr/share/nginx/web-${BUILD_ID} && tar xf web-${BUILD_ID}.tar.gz && rm -f web-${BUILD_ID}.tar.gz"'
            sh 'ssh 192.168.4.12 "cd /usr/share/nginx/ && rm -rf html && ln -s web-${BUILD_ID} html"'
    }
        } 
    } 
} 
####BUILD_ID：构建生成的ID，不会重复#####

 

 

 6、Pipeline 语法生成器