Docker使用jenkins部署java项目到远程linux（三）

实现功能：从本地提交代码到gogs上，本地的代码会被检测一遍 如果检测通过才能commit成功 然后可以继续执行push命令 。push后在gogs上使用web钩子自动推送到jenkins触发构建，jenkins构建成功会自动完成项目的部署。

（1）安装Docker容器（相当于一个linux服务器），在Docker容器里安装jenkins,gogs.tomcat,jdk

         远程linux中需要安装 jdk

（2）　使用eclipse创建maven项目，项目目录结构如下:  （java项目）

　　

ApplicationMain.java

package cn.demo.JavademoIn7.application;
/**
 * 测试java项目 in server 172.150.15.7
 * 本地使用git钩子检测 findbugs插件
 * gogs上自动推送
 * jenkins也检测然后自动部署到Docker容器中
 * @author Administrator
 *
 */
public class ApplicationMain {

    public static void main(String[] args) {
        System.out.println("*******************ApplicationMain()****************");
    }
    
    public void hello(){
        System.out.println("This method in demo.");
    }

}

ApplicationMainTest.java

package cn.demo.JavademoIn7.application;

import static org.junit.Assert.*;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
/**
 * ApplicationMain的测试类
 * @author Administrator
 *
 */
public class ApplicationMainTest {
　　
　　//测试之前执行的方法
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("---Before()---");
    }
　　
　　//测试执行执行的方法
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("---After()---");
    }

　　//测试ApplicationMain类中的hello方法
    @Test
    public void testHello() {
        System.out.println("executing.............");
        ApplicationMain amt = new ApplicationMain();
        amt.hello();
    }

}

script.sh  (这是执行该项目的脚本命令)

#!/bin/sh
cd  /usr/src/myapp  #进入jar包存放目录

#得到进程ID pid，kill该进程
pid=`cat  /usr/src/myapp/pid`  #得到该目录下 pid文件中的进程id
if [ -n "$pid" ]
then
    echo "kill -9 的pid:" $pid
    kill -9 $pid    #kill该进程
fi

#执行jar，并将进程挂起，保存进程ID到 pid文件
echo "Execute shell Finish"
#执行项目jar包，将进程挂起，然后将进程id写入当前目录下的pid文件中
BUILD_ID=dontKillMe nohup java -jar /usr/src/myapp/JavademoIn7.jar  & echo "$!" > pid  

script.xml (这是将脚本命令打包的描述文件)

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2
          http://maven.apache.org/xsd/assembly-1.1.2.xsd">

    <id>script</id>

    <formats><!--打包的文件格式 -->
        <format>zip</format>
    </formats>

    <fileSets>
        <fileSet>
            <directory>src/main/resources/script</directory><!--需要打包的目录 -->
            <outputDirectory>/</outputDirectory> <!-- 打包后输出的路径 输出子啊target目录下 -->
        </fileSet>
    </fileSets>

</assembly>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

    <groupId>cn.demo</groupId>
    <artifactId>JavademoIn7</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging> <!-- 打包成jar包 -->
    <name>JavademoIn7</name>
    <url>http://maven.apache.org</url>
  
    <build>
        <finalName>JavademoIn7</finalName>
        <plugins>
            <plugin>
                <inherited>true</inherited>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${compiler.source}</source>
                    <target>${compiler.target}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            
            <!-- 指定执行的主类（main方法所在的类）-->
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <version>2.6</version>  
                <configuration>  
                    <archive>  
                    <!-- 添加index则不从mainfest中读取classpath，而是从Index.list中读取 -->  
                    <!-- <index>true</index> -->  
                        <manifest>  
                            <mainClass>cn.demo.JavademoIn7.application.ApplicationMain</mainClass>  
                        </manifest>  
                       
                    </archive>  
                </configuration>  
            </plugin>  
            
            <!-- 将执行项目的脚本文件一起打包 -->
             <plugin>
               <groupId>org.apache.maven.plugins</groupId> 
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4.1</version>
                <executions>
                    <execution>
                        <id>${project.version}</id><!--名字任意 -->
                        <phase>package</phase>   <!-- 绑定到package生命周期阶段上 -->
                        <goals>
                            <goal>single</goal>   <!-- 只运行一次 -->   
                        </goals>
                        
                        <configuration>
                            <descriptors>   <!--描述文件路径--> 
                                <descriptor>src/main/resources/script.xml</descriptor>
                            </descriptors>
                            <!--这样配置后，mvn deploy不会把assembly打的zip包上传到nexus-->
                            <attach>false</attach>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            
        <!-- findbugs插件 ：静态检查代码的错误-->
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>findbugs-maven-plugin</artifactId>
            <version>3.0.4</version>
            <configuration>
                <!-- 设置分析工作的等级，可以为Min、Default和Max -->
                <effort>Low</effort>
                <!-- Low、Medium和High (Low最严格) -->
                <threshold>Medium</threshold>
                <failOnError>true</failOnError>
                <includeTests>true</includeTests>
                <!--findbugs需要忽略的错误的配置文件-->
               <!--  <excludeFilterFile>compile.bat</excludeFilterFile> -->
            </configuration> 
            <executions>
                <execution>
                    <id>run-findbugs</id>
                    <!-- 在install 阶段触发执行findbugs检查，比如执行 mvn clean package-->
                    <phase>install</phase>  
                    <goals>
                        <goal>check</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
            
    </plugins>
    </build>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <compiler.source>1.7</compiler.source>
        <compiler.target>1.7</compiler.target>
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
    
        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-clean-plugin</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>        
</project>

（3）关于git和gogs  代码存放在gogs管理的仓库中，本地通过git bash here 界面使用git命令提交代码

        将Eclipse上的项目复制到桌面，进入项目文件夹，目录如下：  （红色标记的是项目中没有的，需要使用命令生成或手动创建的）

.gitignore 文件的作用：忽略的文件，就是不需要被上传到gogs的文件  内容如下：

#忽略的文件
.settings
target
.classpath
.project
compile.bat
package.bat
package.sh

右击进入 git bash here 界面，使用 git init 命令，生成 .git文件夹

进入 .git -> hooks   目录如下(红色标记的文件是自己添加进去的)

pre-commit文件的作用：在执行 git commit -m "description" 这条命令之前，先执行pre-commit文件中的脚本命令。

这里执行mvn clean install,先清除项目信息，然后再install，前面在pom.xml中配置了 install中嵌套了 findbugs插件的 check命令

所以执行mvn install命令时，也会执行 findbugs:findbugs命令。当检测出有bug时，会build失败，commit也失败；反之则成功

pre-commit内容如下：

#!/bin/sh
#execute shell before commit,check the code
mvn clean install

#recieve the  execute result
result=$?
#output the result ,if the result less or equal 0 ,it proves this project has bugs,otherwise don't.
echo $result

if [ $result -ne 0 ]
then
    mvn findbugs:gui  #返回非0值表示构建失败，这里弹出findbugs的gui,里面会显示bug的详细信息。
    echo "REGRETFUL! BUILD FAILURE"
    exit 1   #这里返回非0值，使得commit失败。
else
    echo "CONGRATURATION! BUILD SUCCESS"
    exit 0
fi

本地操作命令：

git init    #初始化本地仓库

git add .  #将所有文件添加到临时存放区 （被忽略的文件除外）

git commit -m "test java program" #将添加到临时存放区的文件提交

git remote add origin  http://172.150.12.5:10080/test/JavademoIn7.git  #添加远程仓库的连接 这里需要将本机的ssh key 添加到gogs的SSHkey中，如果没有添加也可以用gogs的登录账号和密码去建立连接

git push origin master #将本地代码推送到gogs上

gogs中的仓库界面显示，（推送后）

点击仓库设置--》管理web钩子--》添加web钩子：  格式如下

http://172.150.15.52:8080/gogs-webhook/?job=JavademoIn7

172.150.15.52:8080 #是访问jenkins的链接

JavademoIn7 #是jenkins的项目名

添加web钩子的作用： 当下次本地执行 git push命令时，会自动触发jenkins项目执行构建。

（4）jenkins中的配置，jenkins主界面如下

进入 系统管理 --》 Global Tool Configuration  :

JDK勾中自动安装，maven选择合适的版本自动安装，其他的都保持不变，然后保存就行了

进入 系统管理 --》插件管理： 界面如下

选中 可选择插件，在红色标记的这里分别查询以下插件，并且选择直接安装 （安装jenkins的时候，选择的是默认安装方法，其中jenkins会自动下载有些插件）

Maven Intergration plugin， Checkstyle plugin ， Findbugs plugin ，Deploy to Container Plugin，Publish over SSH plugin，gogs plugin。

Maven Intergration plugin #用于构建maven项目的插件

Checkstyle plugin #检测代码的格式是否规范的插件

Findbugs plugin #对提交的代码静态检测，静态语法

Deploy to Container Plugin #将项目部署到Tomcat中需要用到的插件 （或者其他容器）

Publish over SSH plugin #需要部署项目到远程linux时需要到的插件

Gogs plugin #使用web钩子推送时，必须下载此插件，不然就会报403错误

插件下载完之后，再进入 系统管理 --》 系统设置 ：

前面的配置都不用管，使用默认的就行了。直接下拉到 Publish Over SSH

Passphrase ：这里配置的是你在docker容器中，使用  ssh-keygen -t rsa 命令生成秘钥对时的 passphrse,如果你直接按了回车，这里就不用填写了

Path to key ： 这里写 Docker容器里  ssh-keygen -t rsa生成 id_rsa 的路径

key ：这里写  ssh-keygen -t rsa生成的 id_rsa中的内容 

Path to  Key 和 Key二选一就行了，只要填其中一个就可以了。

附： 进入docker容器的命令 docker exec -it 容器ID bash

接下来配置需要部署项目的远程linux (SSH Servers)，如果需要部署在多台远程linux上，可以配置多个SSH Servers (下面有增加命令)

Name：这里你自己定义名字，只要非中文，不是非法字符都行

Hostname ： 这里可以写远程主机名或者是主机IP，建议写主机IP

Username ：用来执行的用户 一般为root

Remote Directory ：这里写远程目录名，/ 表示直接使用根目录

配置完这里后，记得单击下面的 高级  按钮，然后选择 Use password authentication ,or use a different key

在 Passphrase / password 这里填写你的  用户登录的密码，就是 root用户，登录的密码

其他的都空着，使用默认的就行，然后下面有个 testConfiguration ,点击一下，没问题的话 会出现 SUCCESS

jenkins的基本配置到此结束了，接下来使用jenkins构建项目

（5）新建 -- 填写项目名后 -- 构建maven风格的项目-- ok

　　然后开始进行项目的基本配置

　　1、General：自己写项目的基本介绍吧

　　

　　2、源码管理 ：这里选择Git 管理

　　Repository URL ：这里写你的gogs对应的仓库链接

　　Credentials：这里如果没有配置，点击右侧的Add ,然后填写 username 和 password  （分别填gogs的登录名和密码） 然后再选中就可以了

　　

　　3、构建触发器 ： 触发远程构建

　　身份验证令牌： 填当前jenkins构建的项目名

      

 　　4、Build ：maven项目的构建，命令执行；  Post Step ：直接选择Run only if build success 就行了  （中间的构建环境和 Pre Steps可以不用写，直接空着）

　　Root POM ：带路径写出pom.xml的位置，一般是在根目录下的

　　Goals and options :这里写执行的命令， 先clean ,再 install

　　findbugs:findbgus ：是执行jenkins中的findbugs插件命令。

　　checkstyle:checkstyle:是执行jenkins中的checkstyle插件命令。

　　　

　　　5、构建设置 ：勾中需要的插件。这里表示使用 checkstyle和findbugs插件

　　关于这两个插件的高级配置，查看以往的博客，里面有详细介绍。

　　

　　6、构建后操作：选中 Send build artifacts over SSH

　　Name：是你在系统配置--》 SSH server中配置的Name (那边配置了，这边下拉框才会有显示)

　　******Transger :指定是需要被传输的内容以及相关命令操作*******

　　Source Files ： 以项目的工作空间为根目录，需要传送到远程linux的文件直接带路径写上去就行，多个文件使用逗号分隔开

　　Remove Prefix：需要被移除的文件前缀

　　Remote Directory ：这里是被传送的目录，远程linux接收文件的目录

　　Exec command：这里写脚本命令，由于执行项目的脚本已经通过pom.xml打包好了，在target目录下的 JavademoIn7-script..zip目录下，所以这里就写脚本命令，解压缩该zip，然后运行里面的脚本文件。

　　

Exec command中的内容：

#!/bin/sh
cd /usr/src/myapp/   #进入远程目录

unzip -o  /usr/src/myapp/JavademoIn7-script.zip -d  /usr/src/myapp/ #将存放脚本文件的压缩包解压

cd JavademoIn7  #打开解压后的文件夹
sh script.sh #执行脚本文件

所有的配置就到这里结束了，保存 --》 执行构建  就行了。

也可以在本地做个小修改，然后重新提交，git add .      git commit -m "re commit to test "    git push origin master  完之后，项目会自动部署到远程linux。

直接可以在jenkins的 Console Output中查看构建结果。