1.服务器开放docker端口,默认2357

1. vim /usr/lib/systemd/system/docker.service
在ExecStart=/usr/bin/dockerd-current \ 后追加 -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock\
2.重新加载配置，重启docker服务
systemctl daemon-reload
systemctl start docker



2.IDEA新建springboot项目，配置docker-maven插件，mvn clean -DskipTests package或build触发docker 镜像构建

进入服务器docker images可看到镜像，谷歌！浏览器访问http://192.168.203.133:5001/v2/_catalog可见镜像已push到私有仓库

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jwolf</groupId>
    <artifactId>cicd</artifactId>
    <version>1.0</version>
    <name>cicd</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>

                <executions>
                    <execution>
                        <id>build-image</id>
                        <!--将插件绑定在package这个phase上。也就是说，用户只需执行mvn package ，就会自动执行mvn docker:build-->
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>

                <configuration>
                    <!--类似docker tag-->
                    <imageName>192.168.203.133:5001/${project.groupId}/${project.artifactId}:${project.version}</imageName>
                    <!-- 指定Dockerfile所在的路径 -->
                    <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
                    <!--连接docker-->
                    <dockerHost>http://192.168.203.133:2375</dockerHost>
                    <!--开启推送，推送到imageName对应的私有仓库-->
                    <pushImage>true</pushImage>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>


Dockerfile

FROM java:8
EXPOSE 8082
WORKDIR /home
ADD cicd-1.0.jar .
ENTRYPOINT ["java", "-jar", "cicd-1.0.jar"]


3.配置idea，创建容器并启动

idea docker插件配置docker连接（为安全可以考虑配置一下https通过证书连接）





启动



4.再优化!——基于jenkins构建镜像进行容器化部署

通过idea构建镜像至少存在几个问题：多人修改同一项目，可能出现代码覆盖；如果本地与服务器网络比较差，开发效率不会高，因为项目镜像是本地构建再上传到服务器；必须开发人员才能进行项目构建等问题，利用jenkins可以解决这些问题，且可以进行一些权限设置，镜像管理，多种构建触发器及自动化构建，邮件告警设置等多种功能

4.1 因为jenkins构建项目一般是在服务器上根据git代码仓库的项目的pom文件进行构建，所以需要安装一些其它东西

jdk:yum search java | grep jdk 搜索到jdk进行yum安装:yum install XXXX

maven:yum install maven     ； mvn -v

Git: yum install git 代码库创建参考

4.2 jenkins下载与启动

1.下载：
Jenkins: https://jenkins.io/download/  选择Generic Java package (.war) 下载
2.启动
java   -DJENKINS_HOME=/home/jenkins  -jar /home/jenkins.war --logfile=/home/jenkins/jenkins.log  --httpPort=8080
3.访问
访问192.168.203.133:8080  发现页面一直卡住jenkins 启动页面，需要在
vim /home/jenkins/hudson.model.UpdateCenter.xml 
修改url节点为清华镜像：https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json，然后再启动
4.如果docker部署jenkin参考(docker部署要注意：jenkins全局配置的JAVA_HOME,MAVEN_HOME,GIT仓库地址应是挂载到容器内的路径，不建议docker部署)
docker  run   --user root    --name jenkins  -p 5000:5000  -p 8080:8080  -v  /home/jenkins:/var/jenkins_home  -v   /usr/share/maven:/usr/local/maven  -v  /var/run/docker.sock:/var/run/docker.sock  -v /usr/bin/docker:/usr/bin/docker  jenkins/jenkins:lts ,（当前最新稳定版2.222.1版本）仍然需要修改清华镜像，修改后启动其实仍较慢，约1-2分钟
5.用户名admin，密码在启动时有显示，或vim /home/jenkins/secrets/initialAdminPassword




4.3插件安装

先安装推荐插件（选择推荐的），可能很慢，可以考虑官网下载.hpi到本地或其他地方找来.hpi进行离线安装（Manage Jenkins=>advanced=>upload plugin），主要用到的插件：Git plugin , Maven Integration plugin

4.4环境配置

主要配置 Manage Jenkins=>Global Tool Configuration ,主要设置JAVA_HOME,GIT可执行命令path（which git查看）,MAVEN_HOME ,可以设置一下maven configuration，如果用默认的settings.xml初次构建会很慢，自定义settings.xml设置一下maven仓库地址和阿里云仓库。其它可以在Manage Jenkins=>Configure System进行配置，如邮件。如果jdk,maven等之前已设置了环境变量，这里貌似也可不用再设置！！！



 



4.5 项目构建配置 New Item=>构建一个maven风格的项目

因为是多模块项目多分支项目：需要设置两个构建需要的自定义参数：模块名module_name，分支名：branch





配置代码库，如jenkins，git不在同一个服务器，可以使用绝对路径如：git@192.168.203.133:/home/gitrepo/test2.git



触发器配置，如果项目列表页手动触发，可以不配置触发器，这里可以配置定时触发，远程URL触发，如

http://test.jenkins.construn.cn/buildByToken/buildWithParameters?job=vehicle_2.0-test&token=11d5653da4cb251f125b34f422cc81cda5&module_name=payment&branch=master

指定要构建的module_name,branch,token(token 生成操作如下)，访问此链接即可触发。



构建命令配置，即maven 命令，-pl指定模块名 -am表示同时要构建所选模块所依赖的其他模块如common模块，

因为该pom.xml有使用docker-maven插件，固构建即生成镜像，并push到私有仓库，其它服务器即可从仓库拉取镜像启动项目



构建后执行的shell脚本，这里只需要启动容器即可，最后还可以配置一下构建邮件通知，自动化定时构建时可能有用



4.6手动触发构建

不配置触发器，就只能手动触发构建，指定上面自定义的两个参数module_name,branch即可build



4.7如果pom.xml不使用docker-maven插件，可以通过shell自己build镜像并启动容器最后push到仓库

#!/bin/bash
cd $module_name
registry_prefix='192.168.203.133:5001/com.jwolf/'
echo 当前目录：$PWD
#进入Dockerfile的目录
cd $PWD/target/docker
#构建镜像
docker build -t $registry_prefix$module_name  . 
#删除已有的老容器
if docker ps -a | grep $module_name; then
  docker rm -f $module_name
fi
#启动新容器
docker run  -d --restart=always --name $module_name  -v /home/logs:/home/logs --net host $registry_prefix$module_name
#push镜像到仓库
docker push $registry_prefix$module_name
#删除<none>悬空镜像
docker image prune -f


5.其它参考

 https://www.cnblogs.com/hsz-csy/p/9488469.html

https://blog.csdn.net/artaganan8/article/details/93386196?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522158687964319726869045737%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=158687964319726869045737&biz_id=0&utm_source=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v25-15

 

终于到了Jenkins的发布了，对于 Jenkins 的搭建，前两天写了一篇【Jenkins】安装 + 升级 踩坑记 ，今天晚上寻思着抽点时间写一下 Jenkins + Java 的编译及发布过程

系统：centos 7
Jenkins: 2.222
Jdk：1.8
Mavne: 3.6.3

与Jenkins环境的搭建，本地新增环境 Maven, 用于编译Java项目

在开始之前，我们要选择几个插件，这里先说明下插件的安装

Jenkins -> Plugin Manager 插件管理路径



在这里可以选择自己需要的插件进行安装，如遇到不起效插件，安装后重启 Jeninks 服务



这里推荐一个中文插件：搜索 Localization: Chinese (Simplified)  安装即可

Jenkins CICD 重要环节

1，服务器配置，用于登陆服务器
2，Jdk 配置，及 Maven 配置，用于项目打包
3，Svn 凭证配置(用于访问 Svn 并拉取代码)

1，服务器设置,主要作用是将程序发布到对应服务器上

插件的选择

Subversion Plug-in Svn 代码服务插件(Svn 服务器，需要配置钩子程序，才可以进行代码拉取)

Publish Over SSH 这个插件即可解决我们远程连接服务器的配置插件，安装后进行如下操作





配置好后进行 TestConfiguration ,查看是否可以成功访问

这里不仅可以使用服务器账号密码方式，同样可以使用 Key 进行访问登录

 

2，Jdk 与 Maven 配置

Jenkins -> Global Tool Configuration 全局配置路径



Maven 全局配置路径，maven 的 setting.xml 文件地址配置上去



Jdk 全局配置路径，配置 Jdk 的安装目录



在这里对凭证进行管理,添加凭证，只需要选择范围，然后填入用户名，密码





上图为我已经配置好的 Svn 凭证

由于个人使用的是 Svn，所以这里已经配置好了

以上为搭建 Maven 项目打包及发布的基础配置，共有，Svn凭证，服务器配置，Maven及Jdk配置

 

下面，我们步入正题，这里我只说明下我发布的目标及思路：

目标：定时完成自动拉取代码，打包并发布

思路：1，从代码服务器拉取代码（会判断是否存在更新）

           2，打包

           3，发布项目到服务器后，关闭原有正在运行的服务，然后替换新包后进行服务启动

 

具体配置内容：

           1，简单做下项目描述



        2，源码管理



        3，构建触发器



       4，构建触发器，这里好几种，Poll Scm 为定时设定（定时配置内容，需要根据实际情况而定）



       5，不需要构建环境配置

       6，构建



说明：maven 命令是  mvn  ,这里采用maven打包，则不需要将 mvn 作为执行命令的前缀，因为 命令执行时， 系统会自动将选择的 Maven 进行命令填充，如，目标为 clean,实际执行未 mvn clean

        7, 构建后的操作(发布)



这是配置的最后一个环节

        8，Exec command，执行脚本命令,该脚本存放到对应服务器目录下，配置如上图 /usr/local/application/sh/xxxxx.sh,配置到固定地址

#!/bin/bash
echo '开始执行脚本'

# 按端口kill掉当前运行的程序
kill -9 `lsof -t -i:8083`

# 移动代码到指定运行目录下
mv xxxxxxxxxx.jar /usr/local/application/

# 睡3秒
sleep 3s

#启动服务，并且将日志记录到了文件
nohup java -jar xxxxxxxxxx.jar --server.port=8083 --spring.profiles.active=test >/usr/local/application/log 2>&1&

echo '执行完了构建'


 

配配置结束后，再看看是否可以运行





待打包及发布过程在代码中的时候，控制台输出: Finished: SUCCESS ，发布成功

 

文章目录
Docker(三) docker通过gitlab部署CICD
一、 部署gitlab
1.1 拉取gitlab镜像
1.2 运行gitlab镜像
1.3 配置
1.4 若发生502报错
二、 CI
2.1 Runner 搭建
2.2 注册Runner
2.3 样例测试
2.3.1 新建maven-tomcat项目
2.3.2 创建.gitlab-ci.yml
2.3.3 编写Dockerfile文件
2.3.4 编写docker-compose.yml文件
三、 CD
3.1 安装Jenkins
3.2 配置目标服务器及Gitlab免密码登录
3.2.1  Jenkins连接目标服务器
3.2.2 配置Gitlab免密码登录
3.2.3 配置JDK和Maven
3.2.3 手动拉取Gitlab项目
3.2.4 创建Maven任务
3.3 实现持续交付持续部署
四、 简单的SpringBoot项目实践
4.1 新建一个项目
4.2 Jenkins里新建任务
4.3 **构建触发器**
4.3.1 Build periodically (**定时构建**)
4.3.2 Poll SCM
4.3.3 远程仓库接收到push事件时构建

Docker(三) docker通过gitlab部署CICD
一、 部署gitlab
1.1 拉取gitlab镜像
# gitlab-ce为稳定版本，后面不填写版本则默认pull最新latest版本
# 注意需要配置镜像加速器，不然会非常慢
docker pull gitlab/gitlab-ce

1.2 运行gitlab镜像
docker run -d -p 443:443 -p 80:80 -p 222:22 --name gitlab --restart always -v /opt/gitlab/config:/etc/gitlab -v /opt/gitlab/log:/var/log/gitlab -v /opt/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce

# -d：后台运行
# -p：将容器内部端口向外映射
# --name：命名容器名称
# -v：将容器内数据文件夹或者日志、配置等文件夹挂载到宿主机指定目录

1.3 配置
# gitlab.rb文件内容默认全是注释
vim /opt/gitlab/config/gitlab.rb

# 配置内容如下：

# 配置http协议所使用的访问地址,不加端口号默认为80
external_url 'http://192.168.6.21'

# 配置ssh协议所使用的访问地址和端口
gitlab_rails['gitlab_ssh_host'] = '192.168.6.21'
gitlab_rails['gitlab_shell_ssh_port'] = 222 # 此端口是run时22端口映射的222端口

# 重启gitlab容器
docker restart gitlab

1.4 若发生502报错
docker exec -it gitlab bash # 进入容器内部
gitlab-ctl restart sidekiq
gitlab-ctl hup unicorn

二、 CI

GitLab-CI/CD是GitLab的一套内置的工具，主要实现了对程序开发的持续化集成、连续发布、自动化部署等功能。
以下引用官方文档进行介绍：

持续集成的工作原理是将小的代码块推送到Git存储库中托管的应用程序代码库中，并且每次推送时，都要运行脚本管道来构建，测试和验证代码更改，然后再将其合并到主分支中。
持续交付和部署包括进一步的CI，可在每次推送到存储库默认分支时将应用程序部署到生产环境。
这些方法使您可以在开发周期的早期发现错误和错误，从而确保部署到生产环境的所有代码均符合为应用程序建立的代码标准。


CI（continuous intergration）持续集成

持续集成：编写代码时，完成了一个功能后，立即提交代码到Git仓库中，将项目重新的构建并且测试。
1.快速发现错误。

2.防止代码偏离主分支。


2.1 Runner 搭建

Runner是CI/CD中必不可少一个组件，它是我们持续化集成的实际操作者，当我们通过GitLab Service端发起操作时，实际都是分配到各个Runner服务器进行执行，Runner可以在任意服务器中部署然后再Service端中进行注册。

#1.为了方便操作，请先进入到root权限
sudo su

#2.下载安装包文件
curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

#3.添加权限
chmod +x /usr/local/bin/gitlab-runner

#4.新建一个操作用户
useradd --comment 'gitlab-runner' --create-home gitlab-runner --shell /bin/bash

#5.安装
#注意： --working-directory 是runner实际执行目录，所有从service端发起的请求命令，都会到该目录下进行执行。
gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner

#6.启动
gitlab-runner start



常用命令
gitlab-runner stop 停止服务
gitlab-runner start 启动服务
gitlab-runner restart 重启服务

gitlab-runner list #查看各个 Runner 的状态
gitlab-runner verify    #此命令检查注册的runner是否可以连接，但不验证GitLab服务是否正在使用runner。 --delete 删除
gitlab-runner register  #默认交互模式下使用，非交互模式添加 --non-interactive

gitlab-runner unregister   #该命令使用GitLab取消已注册的runner。
	#使用令牌注销
	gitlab-runner unregister --url http://gitlab.example.com/ --token t0k3n

	#使用名称注销（同名删除第一个）
	gitlab-runner unregister --name test-runner

	#注销所有
	gitlab-runner unregister --all-runners




因为gitlab-runner可能会用到maven，docker，git，所以需要提前安装好这些东西

yum install java-1.8.0-openjdk* -y

yum install git

# 安装docker略
usermod -aG docker gitlab-runner  # 保证可以使用docker
sudo -u gitlab-runner -H docker info # 验证是否有效

# 安装docker-compose  略

# 安装maven
yum -y install maven 
mvn -v  #查看maven版本

# 配置aliyun镜像
vim /etc/maven/settings.xml
# mirrors节点下添加（注意不能有tab键）
    <mirrors>
        <mirror>
            <id>alimaven</id>
            <mirrorOf>central</mirrorOf>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
        </mirror>

        <mirror>
            <id>repo1</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo1.maven.org/maven2/</url>
        </mirror>

        <mirror>
            <id>repo2</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo2.maven.org/maven2/</url>
        </mirror>
    </mirrors>

2.2 注册Runner
gitlab-runner register


会要求输入gitlab的url和Token.

查找过程如下：

进入仓库->settings->CI/CD，找到Runner Settings这一项，点击Expend,即可在Setup a specific Runner manually这项中找到。




2.3 样例测试
2.3.1 新建maven-tomcat项目

下方为pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>cicd.test</groupId>
    <artifactId>cicd_test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>cicd-test</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.3.2 创建.gitlab-ci.yml
stages:
  - test

test_job:
  stage: test
  script:
    - echo hello hi
    - mvn clean
    - mvn package
    - cp target/cicd-test.war docker/cicd-test.war
    - docker-compose down
    - docker-compose up -d --build
    - docker rmi $(docker images -qf "dangling=true")
  tags:
    - cicd-test
  only:
    - master

2.3.3 编写Dockerfile文件

在根目录下新建docker文件夹，在docker文件夹下创建Dockerfile

FROM daocloud.io/library/tomcat:8.5.15-jre8
COPY cicd-test.war /usr/local/tomcat/webapps

2.3.4 编写docker-compose.yml文件

在根目录下创建

version: "3.1"
services:
  testci:
    build: docker
    restart: always
    container_name: testci
    ports:
     - 8080:8080

三、 CD

CD(持续交付，持续部署)
持续交付：将代码交给专业的测试团队去测试
持续部署：将测试通过的代码，发布到生产环境


3.1 安装Jenkins

官网https://www.jenkins.io/


docker-compose.yml

version: "3.1"
services:
  jenkins:
    image: jenkins/jenkins:lts
    restart: always
    container_name: jenkins
    ports:
      - 8888:8080
      - 50000:50000
    volumes:
      - /opt/jenkins/data:/var/jenkins_home
      - /opt/jenkins/etc:/etc

docker run -d -p 8888:8080 -p 50000:50000 -v /opt/jenkins/data:/var/jenkins_home -v /opt/jenkins/etc:/etc --name jenkins --restart always jenkins/jenkins:lts


第一次运行时，因为data目录没有权限，会导致启动失败

chmod 777 data


查看运行日志

docker-compose logs -f


找到管理员密码



配置国内源，以获得更快的插件下载速度


安装两个插件



3.2 配置目标服务器及Gitlab免密码登录

Gitlab  ->  Jenkins  ->  目标服务器

3.2.1  Jenkins连接目标服务器

系统管理 -> 系统配置 -> Publish over SSH -> 新增


3.2.2 配置Gitlab免密码登录

1、 进入Jenkins容器内部

docker exec -it jenkins bash


2、 生成SSH密钥

ssh-keygen -t rsa -C "1809227959@qq.com"
# Your public key has been saved in /var/jenkins_home/.ssh/id_rsa.pub.


3、 复制到Gitlab的密钥中


3.2.3 配置JDK和Maven

3.2.3 手动拉取Gitlab项目

主要是为了完成第一次的拉取，输入yes，之后可以删掉这个


3.2.4 创建Maven任务

1、在idea新建一个简单的maven项目（cd_test） ， 并将其推送到gitlab上


2、 在Jenkins的监控页面新建maven任务







3、 执行任务



4、 最终效果： 在**/var/jenkins_home/worksplace**下成功编译成功，得到war包

3.3 实现持续交付持续部署

1、安装Git Parameter，Persistent Parameter插件


2、 重新指定构建项目的方式



echo $Tag
cd /var/jenkins_home/workspace/cd_test
git checkout $Tag
git pull origin $Tag
/var/jenkins_home/maven/apache-maven-3.6.3/bin/mvn clean package


3、 构建项目成功后，需要将内容发布到目标服务器中


cd /home/cd_test
cp target/cd-test.war docker
docker-compose down
docker-compose up -d --build
docker image prune -f


4、修改程序代码，提交到gitlab仓库



docker/Dockerfile
FROM daocloud.io/library/tomcat:8.5.15-jre8
COPY cd-test.war /usr/local/tomcat/webapps



docker-compose.yml
version: "3.1"
services:
  cd-test:
    build: docker
    restart: always
    container_name: testci
    ports:
      - 8081:8080




5、 测试


给当前代码添加一个标签


到Jenkins中查看




四、 简单的SpringBoot项目实践
4.1 新建一个项目
4.2 Jenkins里新建任务



4.3 构建触发器

构建触发器的设置经常使用的有三种：定时构建（不管有没有代码有没有变化）、定时轮询构建（定时轮询代码仓库，有改动才会构建）、远程仓库接收到push事件时构建（也就是有人向远程仓库成功的push了代码）。这里主要讲这三种触发方式。

4.3.1 Build periodically (定时构建)

此时的定时构建是时间到达日程表所设置的时间后，就开始构建。此时不管前面源码管理处设置的分支是上的内容是否有变化都会开始构建。例如：在日程表的白框里填写H/30 * * * *，表示每隔30分钟构建一次。具体的定时语法写法课点击旁边的蓝色?图标查看。


4.3.2 Poll SCM

这个也是定时构建，但不同的是在达到所设置的时间后，系统会去轮询设置的远程仓库是否有变化，有变化才构建。例如：在日程表的白框里填写H/30 * * * *，表示每隔30分钟就检测一下远程仓库是否有变化，有变化就开始构建，没有变化则不构建。


4.3.3 远程仓库接收到push事件时构建

当有人成功的向仓库push代码时，触发构建。


选择Build when a change is pushed to GitLab这个选项。打开”高级”按钮，如下图红圈1标识部分：


1）在上图红圈2部分设置需要跟踪变化的分支，根据上面的选项配置，可以是允许全部分支的变化触发构建，也可以设置只是具体的某些分支触发，这里示例是允许master分支上的变化触发构建。
2）要想Gitlab上仓库有push事件发生时触发构建，还需要进一步的设置。在Gitlab上找到要构建的项目，在侧栏找到点击设置图标，找到webhook,点击进入。




URL部分复制上述步骤“当有人成功的向仓库push代码时，触发构建”中的图片上红圈1部分的http地址；


Secret token则填写的是红圈3部分（要先点击generate生成）；


然后再Tigger中勾选push events，表示当有代码push到该仓库时触发，最后点击末尾Add Webhook保存。



之后在Jenkins的item设置中设置好构建环境、构建步骤、以及构建后操作。当Gitlab上我们添加了webhook的的项目有代码push的时候，便可以自动触发Jenkins的构建。


若出现以下情况，进入 Admin area => Settings => Network ，然后点击 Outbound requests 右边 的“expand”按钮

报错内容 

Failed to connect to repository : Command "git ls-remote -h -- /home/{$username}/CICD/javaDemo/simple-java-maven-app HEAD" returned status code 128:
stdout:
stderr: fatal: '/home/{$username}/CICD/javaDemo/simple-java-maven-app' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.



问题排查：

1. 检查jenkins容器是否有SSH Key

1) /home/.ssh是否有id_rsa、id_rsa.pub文件

2）GitHub账户是否有SSH Key



 2) 检查Repository URL是否正确

Repository URL：填写的是jenkins容器内的仓库路径（前提：在运行容器时，主机上的用户账户home目录映射到Jenkins容器的 /home 目录，代码也是存放在/home下的）