学习Jenkins（一）

一、什么是持续集成？

jenkins介绍

Jenkins官网：https://jenkins.io/

Jenkins只是一个平台，真正运作的都是插件。这就是jenkins流行的原因，因为jenkins什么插件都有

部署代码上线流程：

1、代码获取（直接了拉取）
2、编译 （可选）
3、配置文件放进去
4、打包
5、scp到目标服务器
6、将目标服务器移除集群
7、解压并放置到Webroot
8、Scp 差异文件
9、重启 （可选）
10、测试
11、加入集群

二、jenkins部署

（1）安装JDK 
# yum instsall -y java-1.8.0-openjdk java-1.8.0-openjdk-devel
 
（2）下载jenkins的rpm包
# wget https://mirrors.tuna.tsinghua.edu.cn/jenkins/redhat-stable/jenkins-2.32.3-1.1.noarch.rpm
 
（3）安装jenkins
# rpm -ivh jenkins-2.32.3-1.1.noarch.rpm 
    
（4）启动jenkins
# service jenkins start

（5）检查端口 
# netstat -tulnp|grep 8080浏览器访问：192.168.56.12:8080：

#登陆界面有提示输入密码，初始密码文件为/var/lib/jenkins/secrets/initialAdminPassword

安装所有插件：

安装插件完成，设置用户名:jenkins，密码:jenkins

三、jenkins的插件以及配置

Jenkins系统管理比较重要的就是插件管理了，因为jenkins的工作全部是由插件来完成。

在插件管理中，有可更新、可选插件、已安装，日常的插件安装都是在这个界面上完成的。比如为了和gitlab协同，我们需要安装gitlab的插件。

在高级选项中，我们可以在jenkins官网下载插件，然后上传插件，如图：

插件目录路径= /var/lib/jenkins/plugins/

这个目录下是我们安装所有的插件

jenkins的目录介绍：

# rpm -ql jenkins
/etc/init.d/jenkins                #jenkins的启动文件
/etc/logrotate.d/jenkins
/etc/sysconfig/jenkins             #jenkins的配置文件
/usr/lib/jenkins                   
/usr/lib/jenkins/jenkins.war       #jenkins的程序war包
/usr/sbin/rcjenkins                #jenkins的为二进制文件
/var/cache/jenkins                 #jenkins的程序文件，运行程序解压出来的
/var/lib/jenkins                   #jenkins的主目录
/var/log/jenkins                   #jenkins的日志文件
 
jenkins的升级，只需要将war包解压到/var/lib/jenkins目录下，重启jenkins即可。
 
备份：
tar zcvf jenkins.tar.gz /var/lib/jenkins

系统管理-->系统配置

执行者数量：配置并发数量，一般设置为5，不超过10

用法：如果是主server，可以不选，如果是从级别必须选择“尽可能的使用这个节点”

生成前等待时间：配置该时间，避免错误操作，有时间返回

三、jenkins升级

（1）查看war包所在的目录
# rpm -ql jenkins
/etc/init.d/jenkins
/etc/logrotate.d/jenkins
/etc/sysconfig/jenkins
/usr/lib/jenkins
/usr/lib/jenkins/jenkins.war
/usr/sbin/rcjenkins
/var/cache/jenkins
/var/lib/jenkins
/var/log/jenkins
 
（2）下载最新稳定版的war包
# wget https://mirrors.tuna.tsinghua.edu.cn/jenkins/war/2.46/jenkins.war

当前jenkins版本为2.32.2

（3）停止jenkins服务
# service jenkins stop
 
（4）备份原来的war包，并拷贝最新版本war包到/usr/lib/jenkins目录下
# cd /usr/lib/jenkins/# mv jenkins.war jenkins-2.32.2.war.bak
# mv /root/jenkins.war .
# service jenkins start

四、jenkins备份

在jenkins界面创建一些项目，这里使用rsync，主要是为了保持备份的属性，如果使用scp或cp有时会导致文件属性的改变而导致jenkins异常。

（1）创建备份目录
# mkdir /data/backup/jenkins -p
 
（2）备份/var/lib/jenkins目录
# rsync -raz --delete --progress /var/lib/jenkins /data/backup/jenkins/
 
（3）删除/var/lib/jenkins/# rm -rf /var/lib/jenkins/# service jenkins restart
# service jenkins status
 
（4）恢复备份
# rsync -raz --delete /data/backup/jenkins/jenkins /var/lib/# service jenkins restart

使用git+jenkins实现持续集成

Step1：构建一个自由风格的php-deploy

Step2：Gernal配置，丢弃旧的构建，防止jenkins构建较多之后变臃肿

Step3：源码管理：这里使用git插件，也可以使用svn插件

将git路径存在这里还需要权限认证，否则会出现error 。
jenkins服务器上生成SSH-Key

# yum install -y git
# ssh-keygen# cat .ssh/id_rsa.pub

命令行测试添加ssh-key后能否正常拉取
# git clone git@192.168.56.11:java/app1.git

然后保存，立即构建一次，会拉取master的代码库

点开可以看到控制台的输出，如图：

/var/lib/jenkins/workspace/php-deploy目录用于存放代码信息

这里我们拉取的代码需要推送到远程代码目录，需要如下操作：
架设linux-node1为web服务，目录为/data/www/php-deploy

# mkdir /data/www/php-deploy -p
添加node2的免秘钥登陆
# vim .ssh/authorized_keys
# chmod 600 .ssh/authorized_keys 
# ssh 192.168.56.11

修改项目设置，配置构建：Execute shell，相当于将代码自动发布到linux-node1的代码目录中。

接下来，我们重新构建一次，并查看控制台输出：

在node1上查看目录，也会有相应的代码信息

一、什么是Maven

maven是一个项目管理和综合工具。Maven提供给开发人员构建一个完整的生命周期框架。
开发团队可以自动完成该项目的基础设施建设，Maven使用标准的目录结构和默认构建生命周期
maven是属于Apache的开源项目
maven主要服务于java平台的构建、依赖管理、项目管理

二、手动安装MAVEN

（1）下载maven
# wget http://mirrors.hust.edu.cn/apache/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz

（2）解压
# tar -zxvf apache-maven-3.5.2-bin.tar.gz 
# mv apache-maven-3.5.2 /data/

（3）配置环境变量
# export PATH=$PATH:/data/apache-maven-3.5.2/bin
# vim /etc/profile
  export PATH=$PATH:/data/apache-maven-3.5.2/bin

（4）测试
# mvn -v

三、POM文件解析

POM是研发给出的
Project Object Model，项目对象模型
通过xml格式保存的pom.xml文件
作用类似ant的build.xml文件，功能更强大
该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。

四、配置系统MAVEN

系统管理-->Global Tool Configuration

新增maven

取消自动安装

填写maven实际安装路径/data/apache-maven-3.5.2

五、新建maven项目

（1）新建maven项目
（2）指定源码文职（git或svn）
（3）指定build选项
clean install
clean install -Dmaven.test.skip=true
（4）指定execute shell
java -jar target/testweb-0.0.1-SNAPSHOT.jar

配置maven：

settings.xml是maven的主要配置文件
位置$home/.m2是maven下载的插件的存储位置

（1）新建maven项目
新建一个项目，选择构建一个maven项目。如果此处没有“构建一个maven项目”的选项，需要安装插件：Maven Integration Plugin

（2）指定源码位置（git或svn）

（3）指定build选项
clean install
clean install -Dmaven.test.skip=true

（4）指定execute shell
java -jar target/testweb-0.0.1-SNAPSHOT.jar

（5）立即构建
这里在构建的过程中，可能会出现插件下载失败，需要更改maven的插件源，编辑/data/apache-maven-3.5.2/conf/settings.xml

立即构建完成，可以在/var/lib/jenkins/workspace/Java/下可以看到拉取的代码，我们找到整个项目的的jar包并执行，可以看到hello world

# java -jar testweb-0.0.1-SNAPSHOT.jar 
Hello World! i am guo2

六、将java的代码发布到linux-node1上

（1）修改项目的Execte shell设置，再重新构建

rsync -raz --delete --progress target/testweb-0.0.1-SNAPSHOT.jar 192.168.56.11:/opt/
ssh root@192.168.56.11 "java -jar /opt/testweb-0.0.1-SNAPSHOT.jar"

# ls /opt/gitlab   testweb-0.0.1-SNAPSHOT.jar

# java -jar /opt/testweb-0.0.1-SNAPSHOT.jar 
Hello World! i am guo2

到此一个maven项目就完成了！

七、maven项目按版本发布

（1）安装git parameter plugin插件
（2）任务配置中勾选<参数化构建>
（3）选择git parameter
（4）创建变量名 release（自定义）
（5）选择发布类型：
   tag：按标签发布
   branch：按分支发布
   Revison：按修订发布

（1）安装git parameter plugin插件

修改pom.xml中的版本改为v1.0

# vim pom.xml 
  <version>v1.0</version>
# git status
# git add .
# git commit -m "v1.0"
# git push -u origin master

给Java项目中的版本修改后打上标签

此时我们再修改

# vim src/main/java/com/ghz/testweb/App.java 
package com.ghz.testweb;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World! i am guo2 v1.0" );
    }
}
# git add .
# git commit -m "featrue1"
# git push -u origin master

此时进行构建，由于版本修改了，会报错：

但是我们每次进行版本的修改后如果都去修改excute shell就显得太麻烦

（2）任务配置中勾选<参数化构建>

（3）选择git parameter

（4）创建变量名 release（自定义）

修改源码管理

（5）选择发布类型：
tag：按标签发布

（6）对代码进行多次修改，并提交

然后再代码库中对提交进行tag标记

再在jenkins中查看，即可按照不同的版本进行构建，如图：

一、Jenkins的远程管理

Jenkins的远程管理方式包含：

Shell ssh

SSH Plugin

ansible、saltstack

（1）Shell ssh
在项目构建时，jenkins使用了Execute Shell直接对远程主机操作，同步了代码到主机192.168.56.11上，并且可以增加对远程机器进行操作。例如执行某个脚本：ssh root@192.168.53.11 "/bin/sh /data/scripts/****.sh "
如图：

（2）SSH plugin
除了以上方法之外，还可以使用SSH 的插件--SSH plugin
系统管理-->系统配置-->SSH remote hosts，配置好远程主机

在项目中配置，如图：

这样就完成了对远程主机的管理
此外，还可以使用自动化工具，如ansible，saltstack，模式一致，只是用的是ansible或者是saltstack的命令行工具的不同。

二、Jenkins集群

当业务量变大时，单台的jenkins进行自动化构建部署，就显得没那么灵活，下面介绍jenkins的集群功能。
jenkins的集群并非像web服务器，mysql集群，jenkins的集群无需在额外的主机安装jenkins，但是用于java项目来说，要使用集群功能，额外的主机就必须要安装maven。

（1）在jenkins的web界面：系统管理-->Configure Global Security-->TCP port for JNLP agent配置端口30000

（2）系统管理-->管理节点-->新建节点

（3）分配任务到节点
在项目中配置：
General-->Restrict where this project can be run-->Label Expression:node-01

此时，在对项目进行构建，将会分配到node-01节点上进行构建，如图：

一、Jenkins按角色授权

当一个公司的开发分为多个组别，或者是多个项目等等。用于公司内部测试，让开发人员自行构建测试，此时不可能让所有的开发都在公用一个构建，这样变得很混乱，为了解决这一问题，jenkins也提供了角色授权的机制。每个开发有着对应的账号和权限，可以自行新建，构建，测试，发布等。角色授权需要安装的插件：Role-based Authorization Strategy

（1）系统配置
系统管理-->Configure Global Security-->访问控制-->授权策略-->Role-Base Strategy

（2）新建用户
系统管理-->管理用户-->新建用户
这里创建一个java用户和php用户，用于区分php和java项目的构建

（3）用户关联自己相关job，无法查看其他的job

建立项目角色，并对该用户进行项目的授权（包括Job的构建，取消，配置，创建，删除等等）
注意此处的添加，一个是Role是随意填写，最好规范点。Pattern是正则匹配，比如此处匹配的是所有包含Java开头的项目和php开头的项目

系统管理-->Manage and Assign Roles --> Manage Roles-->Project roles

配置好项目的权限，使用java用户或php用户登录是没有新建项目的权限，如需新增这样的权限，需要在Global roles中进行配置，新增一个角色（比如新增一个可以创建新项目的权限角色：new job，可登录查看的角色read）：

然后系统管理-->Manage and Assign Roles -->Assign Roles进行添加对应的权限

使用php登录查看，可以看到php用户可以看到对应php开头的项目，但是没有新建项目的权限：

二、Jenkins的Pipeline（代码流水线管理）

Pipeline（代码流水线管理）

Pipeline名词顾名思义就是流水线的意思，因为公司可能会有很多项目。如果使用jenkins构建完成后，开发构建项目需要一项一项点击，比较麻烦。所以出现pipeline名词。

（1）下载pipeline。这样只需要构建一个项目，就会帮我们完成所有相关项目

搜索插件pipeline

（2）新建一个pipeline的项目

配置pipeline项目，使用Pipeline script脚本：

node {
    stage 'build php-deploy'
    build 'php-deploy'
    stage 'build java'
    build 'java'
}

为了解决各个项目的依赖关系关系，使用pipeline的脚本进行控制。
第一步构建php项目，第二步构建java项目。Pipeline的脚本语法在Pipeline Syntax中有展示

Pipeline Syntax的使用，如图：

立即构建p1的项目，如图：

思路图：

一、下载gitlab plugin

jenkins-->系统管理-->管理插件-->下载并安装gitlab plugin

二、配置gitlab认证

路径：Jenkins-->Credentials-->System-->Global credentials(unrestricted)-->Add Credentials

1、Kind选择Gitlab API token

2、其中API token填写gitlab中有库权限的账号

3、ID填写用户账号

gitlab生成Api token，将生成的token填入上面的证书内。

三、选择连接

路径：系统管理-->系统设置

1、填写连接名

2、填写gitlab访问URL

3、选择gitlab认证

3、测试连接

四、配置任务在job配置中选择gitlab connection：gitlab

五、任务配置

在job配置界面

1、勾选 Build when a change is pushed to GitLab. GitLab CI Service URL: http://192.168.56.12:8080/project/php-deploy

2、选择push events 时间触发构建

3、选择分支过滤（此处可以根据不同的需求来使用过滤功能）

4、secret token需要填入gitlab项目中的webhook

在gitlab中找到项目-->setting-->Integrations配置

填写在上图生成的链接：

URL：http://192.168.56.12:8080/project/php-deploy

Secret Token：3f199086a22c54957579966e34ad120a

点击Add webhook

测试是否生效：点击test-->选择push event会跳转到Hook excuted successfully：HTTP 200

六、构建发布PHP项目

在linux-node1上安装nginx，初始同步了线上代码，写入一个index.html。如图：

# ls /data/www/php-deploy/  index.html# cat /data/www/php-deploy/index.html 
<h1>welcome to beijing</h1>

模拟程序员在linux-node2上进行修改代码，并提交到gitlab的master分支上

# pwd
 /root/php/app1
# echo "Welcome to use Jenkins and Gitlab" > index.html 
# git status# git add .
# git commit -m "jenkins + gitlab"# git push origin master

到此，自动触发和发布就完成了！这只是一个简单的构建发布，作为内部测试使用还是可以的！生产使用，有待优化！

1、什么是Nexus？

在前面进行maven项目的构建中，可以看到在构建的过程中需要安装maven的依赖插件，如图：image.png
而在maven的默认配置中是在官网的中央仓库和第三方的maven仓库进行下载，速度偏慢。这里提供阿里云的maven插件库（http://maven.aliyun.com/nexus/#view-repositories），可以在/data/apache-maven-3.5.2/conf/settings.xml 配置文件中进行修改。
在日常的开发构建中，我们也可以自己搭建一个私有的nexus。那么什么是nexus呢？
Nexus是maven的私有仓库；
如果没有nexus，项目的打包都需要在公网下载，不利于包的管理和共用；
如果没有私有仓库，我们所需要的所有构件都需要通过maven的中央仓库和第三方的maven仓库下载到本地，而一个团队的所有人都需要重复地从maven仓库中下载构件。

2、Nexus的安装

（1）下载Nexus
# wget https://sonatype-download.global.ssl.fastly.net/nexus/oss/nexus-2.14.5-02-bundle.tar.gz
                                                                                                                                          ] 4,375,805   76.4KB/s  eta 12m 59s 
（2）解压Nexus
# tar -zxvf nexus-2.14.5-02-bundle.tar.gz
# mv nexus-2.14.5-02 sonatype-work /data/ 
 
（3）启动Nexus
# cd /data/nexus-2.14.5-02# ls
  bin  conf  lib  LICENSE.txt  logs  nexus  NOTICE.txt  tmp# ./bin/nexus  start
# export RUN_AS_USER=root
# ./bin/nexus start
# netstat -tulnp |grep 8081
（4）浏览器访问仓库
浏览器访问：http://192.168.56.12:8081/nexus

点击右上角"login" 默认用户名密码：admin ，admin123
在仓库中，默认会在本地去查找插件，当未发现有插件时，会通过第三方仓库查到，这些仓库的类型都是hosts类型，也就是在本机进行查询。
当本地内未能查找到相应的插件，会通过代理（proxy）类型进行下载插件，配置就在Central——>Remote Storage    Location（回源地址），这里我们填写阿里云的maven远程仓库进行下载

http://maven.aliyun.com/nexus/content/groups/public/

配置完成nexus后，在修改maven的settings配置

# vim /data/apache-maven-3.5.2/conf/settings.xml 
将其中的仓库链接地址修改为：
http://192.168.56.12:8081/nexus/content/groups/public/

这样在构建时，首次会从阿里云的maven仓库中下载插件，后面再次重新下载插件时会从本地进行下载

一、新建一台虚拟机安装tomcat

（1）安装JDK
# wget https://www.oracle.com/webapps/redirect/signon?nexturl=https://download.oracle.com/otn/java/jdk/8u151-b12/e758a0de34e24606bca991d704f6dcbf/jdk-8u151-linux-x64.tar.gz
# tar -zxvf jdk-8u151-linux-x64.tar.gz
# mv jdk1.8.0_151 /usr/local/jdk1.8# vim /etc/profile
  JAVA_HOME=/usr/local/jdk1.8/
  JAVA_BIN=/usr/local/jdk1.8/bin
  JRE_HOME=/usr/local/jdk1.8/jre
  PATH=$PATH:/usr/local/jdk1.8/bin:/usr/local/jdk1.8/jre/bin
  CLASSPATH=/usr/local/jdk1.8/jre/lib:/usr/local/jdk1.8/lib:/usr/local/jdk1.8/jre/lib/charsets.jar
# source /etc/profile
# java -version
 
（2）安装tomcat
# wget http://apache.fayea.com/tomcat/tomcat-8/v8.5.20/bin/apache-tomcat-8.5.20.tar.gz
# tar -zxvf apache-tomcat-8.5.24.tar.gz 
# mv apache-tomcat-8.5.24 /usr/local/tomcat
# /usr/local/tomcat/bin/startup.sh# netstat -tulnp |grep 8080 
（3）配置tomcat
# vim /usr/local/tomcat/conf/tomcat-users.xml 
  <tomcat-users>
  <role rolename="admin"/>
  <role rolename="admin-gui"/>
  <role rolename="admin-script"/>
  <role rolename="manager"/>
  <role rolename="manager-gui"/>
  <role rolename="manager-script"/> 
  <role rolename="manager-jmx"/>
  <role rolename="manager-status"/>
  <user name="admin" password="admin123456" roles="admin,manager,admin-gui,admin-script,manager-gui,manager-script,manager-jmx,manager-status" />
  </tomcat-users># /usr/local/tomcat/bin/shutdown.sh# /usr/local/tomcat/bin/startup.sh

会跳转到以下界面，说明用户名密码无误，如图：

二、下载zrlog的java代码push到gitlab上

（1）下载zrlog的代码
# wget https://codeload.github.com/94fzb/zrlog/zip/master
 
（2）解压
# yum install -y unzip# unzip master
 
（3）初始化仓库，并将zrlog的代码push到gitlab
# mkdir Java
# mv zrlog-master/* Java/
# git remote add orgin git@192.168.56.11:java/zrlog.git
# git add .
# git commit -m "add origin"
# git push origin master

三、新建一个maven项目zr_blog

（1）新建项目

登录jenkins，点击“新建”，任务名称自定义（zr_blog）

选择“构建一个maven项目”

点击“确定”

（2）配置项目

源码管理

选择 “git”, Repository URL填写你的git地址，并配置对应的key，大家最好事前先在jenkins这台机器上能够直接远程git操作私有仓库

构建触发器、构建环境、Pre Steps保持默认

Build

“Root POM”为pom.xml, Goals and options 填写 clean install -D maven.test.skip=true

Post Steps、构建设置保持默认

构建后操作

点击“增加构建后操作步骤”选择“Deploy war/ear to a container”,“WAR/EAR files”填写“**/*.war”,Contex path留空，Containers选择Tomcat 8.x，Tomcat URL填写要把war包发布到的那台机器的url，如http://192.168.56.13:8080

Credentials这里需要点击右侧的Add，添加用户名和密码

点击"立即构建"查看控制台信息，如图：

（3）查看发布结果

查看linux-node3的webapps目录，会有相对应的war包，并已经进行解压，使用浏览器访问

# ls /usr/local/tomcat/webapps/ docs examples host-manager manager ROOT zrlog-1.8.0 zrlog-1.8.0.war

一、环境说明和准备

1、环境说明

主机名	IP地址	角色	系统
deploy-server	192.168.56.12	发布	Centos 7.4
web	192.168.56.13	web服务器，nfs服务器	Centos 7.4

2、服务器准备工作

（1）发布机前期准备

a.增加普通用户并配置密码

# useradd www
# id www
  uid=1000(www) gid=1000(www) groups=1000(www)
# passwd www
# yum install -y git tree

# mkdir -pv /deploy/{code/{www,jxs,wap,gys,glzx,yyzx},config,tar,tmp}
# chown -R www.www /deploy
$ tree /deploy
/deploy
├── code
│   ├── glzx
│   ├── gys
│   ├── jxs
│   ├── wap
│   ├── www
│   └── yyzx
├── config
├── tar
└── tmp
$ cd /deploy/code/www && git init

c.创建配置文件config.php

$ vim /deploy/config/config.php 
this is config.php
$ tree /deploy
/deploy
├── code
│   ├── glzx
│   ├── gys
│   ├── jxs
│   ├── wap
│   ├── www
│   └── yyzx
├── config
│   └── config.php
├── tar
└── tmp

d.配置发布机和目标机的ssh通信

$ cat /home/www/.ssh/id_rsa.pub 
$ ssh-copy-id www@192.168.56.13
$ ssh 192.168.56.13

e.将ssh公钥复制到github或gitlab

（2）web服务器准备

a.部署NFS服务器

# yum install -y nfs-utils rpcbind
# vim /etc/exports
  /nas/www 192.168.56.0/24(rw,sync,no_root_squash)
  /nas/jxs 192.168.56.0/24(rw,sync,no_root_squash)
  /nas/wap 192.168.56.0/24(rw,sync,no_root_squash)
  /nas/glzx 192.168.56.0/24(rw,sync,no_root_squash)
  /nas/yyzx 192.168.56.0/24(rw,sync,no_root_squash)
  /nas/gys 192.168.56.0/24(rw,sync,no_root_squash)
# systemctl start rpcbind
# systemctl start nfs
# showmount -e

b.挂载共享目录

# mkdir /webroot/{www,jxs,wap,gys,glzx,yyzx}
# chown -R www.www /webroot
# mount -f nfs 192.168.56.13:/nas/www /webroot/www
# df -h

c.部署nginx+php

# useradd www
# passwd www
# yum install -y nginx php php-fpm
# vim /etc/nginx/nginx.conf
  user www;
  worker_processes auto;
  error_log /var/log/nginx/error.log;
  pid /run/nginx.pid;
  include /usr/share/nginx/modules/*.conf;
    events {
      worker_connections 1024;
  }
    http {
      log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                        '$status $body_bytes_sent "$http_referer" '
                        '"$http_user_agent" "$http_x_forwarded_for"';
      access_log  /var/log/nginx/access.log  main;
  
      sendfile            on;
      tcp_nopush          on;
      tcp_nodelay         on;
      keepalive_timeout   65;
      types_hash_max_size 2048;
  
      include             /etc/nginx/mime.types;
      default_type        application/octet-stream;
  
      include /etc/nginx/conf.d/*.conf;
  }
# mkdir /data/web -pv && chown -R www.www /data
# vim /etc/nginx/www.conf
  server {
          listen 80;
          server_name  localhost;
  
          root /data/web/www;
          index index.php index.htm index.html;
          client_max_body_size 20m;
          location / {
                  proxy_read_timeout 150;
                  try_files $uri $uri/ /index.php;
          }
  
          location ~* .*\.php$ {
                  #try_files     $uri =404;
                  include fastcgi_params;
                  fastcgi_pass 127.0.0.1:9000;
                  fastcgi_split_path_info       ^(.+\.php)(/.+)$;
                  fastcgi_param PATH_INFO       $fastcgi_path_info;
                  fastcgi_index index.php;
                  fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
          }
  }
# nginx -t
# systemctl start nginx
# vim /etc/php-fpm.d/www.conf 
  user www
  group www
....
# php-fpm -t
# systemctl start php-fpm
# curl localhost -I

二、发布脚本编写

1、自动化部署流程设计

 1 发布机获取代码（直接拉取），从svn或git仓库进行拉取
 2 发布机编译代码（可选，java语言需要编译，PHP无需编译）
 3 将配置文件拷贝到代码文件（由于配置文件有数据库等机密信息，需要独立处理）
 4 代码打包（将代码进行压缩打包）
 5 SCP到目标服务器目录
 6 将目标服务器移除集群
 7 在目标服务器上进行解压传过来的代码
 8 解压后，对代码根目录进行软链接到刚才的目录文件，实现版本链接
 9 重启（可选，tomcat需要重启）
10 测试
11 加入集群

2、自动化部署脚本编写

#!/bin/bash

#deploy-server create dir as root
#[ -d /deploy ] && mkdir -pv /deploy/{code/web-demo,config,tar,tmp} && chown -R www.www /deploy

#node-server create dir as root
#[ -d /data ] && mkdir -pv /data/web && chown -R www.www /data
#nfs dir /nas/www mount to /webroot

#Node List
NODE="192.168.56.13"

#Shell ENV
SHELL_NAME="deploy.sh"
SHELL_DIR="/home/www"
SHELL_LOG="${SHELL_DIR}/${SHELL_NAME}.log"

#Code ENV
PRO_NAME="www"
CODE_DIR="/deploy/code/www"
CONFIG_DIR="/deploy/config"
TMP_DIR="/deploy/tmp"
TAR_DIR="deploy/tar"
LOCK_FILE="/tmp/deploy.lock"

#Date/Time ENV
LOG_DATE='date "+%Y-%m-%d"'
LOG_TIME='date "+%H-%M-%S"'

CDATE=$(date "+%Y-%m-%d")
CTIME=$(date "+%H-%M-%S")

useage(){
    echo $"Useage: $0 { deploy |rollback [ list | version ] }"
}

url_test(){
    URL=$1
    curl -s --head $URL |grep '200 OK'
    if [ $? -ne 0 ];then
        shell_unlock;
        writelog "test error" && exit;
    fi
}

writelog(){
    LOGINFO=$1
    echo "${CDATE} ${CTIME}: ${SHELL_NAME} : ${LOGINFO} " >> ${SHELL_LOG}
}

code_get(){
    writelog "code_get";
    cd ${CODE_DIR} && git pull git@github.com:kin08200/learngit.git
    cp -r ${CODE_DIR} ${TMP_DIR}
    API_VERL=$(git show |grep commit |cut -d ' ' -f2 )
        API_VER=$(echo ${API_VERL:0:6})
    echo $API_VER
}

code_config(){
    writelog "code_config"
    /bin/cp -r ${CONFIG_DIR}/* ${TMP_DIR}/${PRO_NAME}
        PKG_NAME=${PRO_NAME}_"${API_VER}"_"${CDATE}-${CTIME}"
        cd ${TMP_DIR} && mv ${PRO_NAME} ${PKG_NAME}
}

code_tar(){
    writelog "code_tar"
    cd ${TMP_DIR} && tar -czf ${PKG_NAME}.tar.gz ${PKG_NAME}
        writelog "${PKG_NAME}.tar.gz"
}

code_scp(){
    writelog "code_scp"
    scp ${TMP_DIR}/${PKG_NAME}.tar.gz $NODE:/webroot/www
}

code_deploy(){
    writelog "code_deploy"
    ssh $NODE "cd /webroot/www && tar -zxf ${PKG_NAME}.tar.gz"
    ssh $NODE "rm -rf /data/web/www && ln -s /webroot/www/${PKG_NAME} /data/web/www"
}

code_test(){
    url_test "http://192.168.56.13"
}

rollback_fun(){
    ssh $NODE "rm -rf /data/web/www && ln -s /webroot/www/$1 /data/web/www"   
}

rollback(){
    if [ -z $1 ];then
        shell_unlock;
        echo "Please input rollback version." && exit;
        fi
        case $1 in 
            list)
            ls -l /deploy/tmp/*.tar.gz
            ;;
            *)
            rollback_fun $1
            ;;
        esac
}


shell_lock(){
    touch ${LOCK_FILE}
}

shell_unlock(){
    rm -f ${LOCK_FILE}
}

main(){
    if [ -f ${LOCK_FILE} ];then
        echo "Deploy is running" && exit
    fi
    DEPLOY_METHOD=$1
    ROLLBACK_VER=$2
    case $DEPLOY_METHOD in
        deploy)
            shell_lock;
        code_get;
        code_config;
        code_tar;
            code_scp;
        code_deploy;
        code_test;
        shell_unlock;
        ;;
    rollback)
        shell_lock;
        rollback $ROLLBACK_VER;
        shell_unlock;
        ;;
    *)
        useage;
        ;;
    esac
}

main $1 $2

三、发布测试

1、开发机和github添加ssh信任

$ cat .ssh/id_rsa.pub

2、克隆项目到开发机进行开发测试

$ mkdir dev && cd dev
$ git clone git@github.com:kin08200/learngit.git
$ ls
  learngit
$ cd learngit

3、修改index.html文件

$ cd learngit
$ ls 
  index.html
$ echo "<h1> welcome to Beijing </h1>" > index.html

4、提交代码

$ git add .
$ git commit -m "modify index.html"
$ git push origin master

5、发布代码

$ ./deploy.sh deploy

6、测试访问

$ curl 192.168.56.13
  <h1>
    welcome to Beijing!!!!
  </h1>

7、回滚测试

# ll /data/web/  
www -> /webroot/www/www_683a44_2018-11-03-10-06-56

测试访问如下

查看版本列表，并选择回滚到www_9a781b_2018-11-03-09-59-44版本

$ ./deploy.sh rollback list
 /deploy/tmp/www_683a44_2018-11-03-10-06-56.tar.gz
 /deploy/tmp/www_683a44_2018-11-03-10-43-55.tar.gz
 /deploy/tmp/www_9a781b_2018-11-03-09-48-36.tar.gz
 /deploy/tmp/www_9a781b_2018-11-03-09-52-32.tar.gz
 /deploy/tmp/www_9a781b_2018-11-03-09-58-15.tar.gz
 /deploy/tmp/www_9a781b_2018-11-03-09-59-44.tar.gz

$ ./deploy.sh  rollback www_9a781b_2018-11-03-09-59-44# ll /data/web/ www -> /webroot/www/www_9a781b_2018-11-03-09-59-44

再访问测试：

posted on 2019-04-11 17:09 五光十色阅读(717) 评论(0) 编辑收藏举报

刷新页面返回顶部