前端CI/CD实践

最新推荐文章于 2024-04-20 23:30:25 发布

sayid760

最新推荐文章于 2024-04-20 23:30:25 发布

阅读量4.6k

点赞数 5

本文链接：https://blog.csdn.net/qq_14993375/article/details/108267639

版权

看了几篇文章和视频，安装过程各有千秋，趟过了坑，于是整理了以下过程，安装了整套流程也挺顺利

传统开发过程的坑：

bug总是最后才发现
越到项目后期，加班越严重
交付无法保障
变更频繁导致效率低下
无效的等待，用户满足度低

核心概念

持续集成（Continus Integration，简称CI）
开发的结果每天多次提交，并且合并到主库的做法
把主库的代码进行克隆，克隆下来就进行发布，持续发布，持续堆主干的分支进行合并
开发人员提交新的代码之后，立即进行构建、单元测试，根据测试结果可以确定新代码和原有代码是否能够集成在一起，就能够很好避免了项目快到交互的时候，出现特别多的bug，能够在很前面的时间节点上去发现代码不稳定不确定的因素
持续交互（Continuous Delivery，简称CD）
完成了ci构建及单元测试和集成测试的自动化流程之后，持续交付将已验证的代码发布到存储库。就是把打出来的包放到存储空间，然后就可以手动发布应用

在持续交互中，每个阶段（从代码更改的合并，到生产就绪型构建版本的交互）都涉及测试自动化和代码发布自动化。在流程结束时，运维团队可以快速、轻松将应用部署到生产环境中

比如，完成单元测试后，可以把代码部署到连接数据库的staging环境中更多的测试。如果代码没问题，可以继续手动部署到生产环境中

持续部署（Continuous Deployment 简称CD）
可以自动将应用发布到生产环境中，这是和持续交付最大的区别。持续部署是在持续交付的基础上，把部署到生产环境的过程进行了自动化，去掉手动部署，项目进一步得到提升

总结：

持续集成：不断得提交代码，进行测试、合并（完成一个功能，立即提交代码到git仓库中，将项目重新构建并测试）
- 快速发现错误
- 防止代码偏离主分支
持续交付：在持续集成的基础上，把代码进行构建、打包、储存，发布则交由人工完成
持续部署：在持续交付的基础上，对代码进行自动化部署

Docker

为什么会出现docker?
为了解决运维和硬件成本问题

docker的主要目标就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用的App及其运行环境能够做到“一次封装，到处运行”

是在linux容器技术之前发展起来的，将应用运行在docker容器之上，docker在任何操作系统上都是一致的，就实现了跨平台，跨服务器，只需要一次配置好环境，换到别的机器就可以一键部署，大大简化操作

提供了编译打包测试的运行环境，是节约资源，稳定性比较好的容器技术

基本操作

没有服务器的，可以安装虚拟机测试虚拟机安装配置

安装docker

安装docker

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh  // 安装docker
docker  --version // 查看版本  

// curl -fsSL https:test.docker.com -o test-docker.sh
// sh test-docker.sh
// sh install.sh

配置docker镜像加速，使用阿里云容器加速服务

mkdir /etc/docker
vi /etc/docker/daemon.json
// 复制进去
{
	"registry-mirrors": ["https://09aom2i2.mirror.aliyuncs.com"]
}

// 重启docker daemon
systemctl daemon-reload
systemctl restart docker
docker run hello-world  // 测试，本地没有镜像，去拉取镜像

另一种安装方式

// 1. 下载关于docker的依赖环境
yum -y install yum-utils device-mapper-persistent-data lvm2

// 2. 设置下载docker的镜像源
 yum-config-manager --add-repo  http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

// 3. 安装docker
yum makacache fast
yum -y install docker-ce

// 4. 启动，并设置为开机自动启动，测试
systemctl start docker  // 启动docker服务
systemctl enable docker  // 设置开机自动启动
docker run hello-world  // 测试

拉去镜像并且运行镜像成为容器

docker官方的中央仓库，镜像最全，但是下载速度较慢 hub.docker.com
国内镜像网站：网易蜂巢，daoCloud（推荐使用）
在告诉内部会采用私服方式拉取镜像（添加配置）

镜像的操作（镜像就是docker运载的集装箱）

// 把镜像拉取到本地
docker pull 镜像名称[:tag]
docker pull daocloud.io/library/tomact:8.5.15-jre8

// 查看镜像
docker images

// 删除镜像  
docker rmi 镜像标识  // 查看镜像时的image id

// 镜像的导入导出
// 比如：可以把下载好的镜像打成一个包，通过其他方式拷贝过去，把镜像再加载到linux系统中
// 将本地的镜像导出
docker save -o 导出的路径 镜像id  // 比如 docker save -o ./tomcat.image b8
// 加载本地的镜像文件
docker load -i 镜像文件    // 比如 docker load -i tomcat.image

// 修改名字
docker tag  镜像id  新镜像名称:版本  //  docker tag b8  tomact:8.5

容器的操作（容器就是运行起来的镜像）

// 运行容器
docker run 镜像标识|镜像名称[:tag]

// 常用参数
docker run -d -p 宿主机端口:容器端口 --name 容器名称  镜像的标识|镜像名称[:tag]
// -d 代表后台运行容器
// -p 宿主机端口:容器端口:为了映射当前linux的端口和容器的端口
// --name 指定容器的名称

docker run -d -p 8081:8080 --name tomcat b8
// 8081:8080 linux端口|容器端口

// 查看正在运行的容器
docker ps [-qa]
// -a 查看全部的容器，包括没有运行的
// -q 只查看容器标识，不查看其他信息

// 查看容器日志
docker logs -f 容器id  // -f 可以滚动查看最后几行

// 进入到容器内部
docker exec -it 容器id bash  
// docker ps // 进入到容器内部，可以查看标识（容器id）
// docker exec -it 7 bash    // 不要在容器内部停止，不推荐在容器内部直接操作

// 删除容器（删除容器前，要先停止容器）
docker stop 容器id  // 停止指定容器
docker stop $(docker ps -qa)  // 停止全部容器
docker rm 容器id   // 删除指定
docker rm $(docker ps -qa) // 删除全部
exit // 退出容器

// 启动容器
docker start 容器id

数据卷

作用：就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷
参考

// 创建数据卷
docker volume create 数据卷名称 // 创建后，会默认存放在一个目录下 /var/lib/docker/volumes/数据卷名称/_data
// docker volume create tomcat
// cd /var/lib/docker/volumes // 查看

// 查看数据卷的详细信息
docker volume inspect 数据卷名称

// 查看全局数据卷
docker volume ls

// 删除数据卷
docker volume rm 数据卷名称

// 应用数据卷
// 当你映射数据卷时，如果数据卷不存在，docker会帮你自动创建。会将容器内部自带的文件存储在默认的存放路径中
docker run -v 数据卷名称:容器内部的路径 镜像id
/* docker volume create volume_ssm_tomcat  // 创建数据卷
 	docker run -d -p 8080:8080 --name ssm_tomact -v volume_ssm_tomact:/usr/local/tomact/webapps b8
 	映射到容器内部，操作了数据卷，本地目录也跟着操作
*/ 

// 直接指定一个路径作为数据卷的存放位置。这个路径下时空的，需要手动添加内容
docker run -v 路径:容器内部的路径 镜像id
/* docker run -d -p 8080:8080 --name ssm_tomact -v /opt/volume_ssm_tomact:/usr/local/tomact/webapps b8
// 指定了/opt/volume_ssm_tomact 路径
cd /opt/ 
ls // 里面多了volume_ssm_tomact，采用这种方式，不会把容器内部的文件带出来

自定义镜像

待整理…

docker-compose

yml文件以key:value方式来指定配置信息，不要使用制表符
多个配置信息以换行+缩进的方式来区分

安装

操作系统：Centos7.5
docker-compose版本：1.24.1
百度云提取码: k7a2

1. 去GitHub官网搜索docker-compose，下载1.24.1版本的docker-compose
https://github.com/docker/compose/releases/download/1.24.1/docker-compose-Linux-x86_64

2. 拖拽到/root/下
ls
mv docker-compose-Linux-x86_64  /usr/local // 剪切到/usr/local下
cd /usr/local

3. 将dockercompose文件的名称修改下，要基于dockercompose文件一个可执行的权限
mv docker-compose-Linux-x86_64 docker-compose // 修改名称
mv docker-compose bin // 拖到bin目录下
chmod +x /usr/local/bin/docker-compose // 给docker-compose执行权限和设置全局环境变量

cd ~ // 回到用户目录
docker-compose -v // 查看版本，测试是否安装成功
docker-compose // 测试是否安装成功

docker-compose.yml文件

// 让docker-compose关联mysql和tomcat容器
version: '3.1'
services:
	mysql:                      # 服务的名称
		restart: always         # 代表只要docker启动，那么这个容器就跟着一起启动
		image: daocloud.io/library/mysql:5.7.6   # 指定镜像路径，镜像搜索http://hub.daocloud.io/
		container_name: mysql   # 指定容器运行后的名称
		port:                   # 端口号映射（可以指定多个）
			- 3360:3360
		environment:  		            # 配置其他环境
			MYSQL_ROOT_PASSWORD: root    # 指定mysql的root用户登录密码
			TZ: Asia/Shanghai	         # 指定时区（TimeZone）
		voulmes:		                 # 把mysql数据映射到数据卷外面
			- /opt/docker_mysql_tomact/data: /var/lib/mysql		 # 把/var/lib/mysql数据卷映射到宿主机上
	tomcat:
		restart: always
		image: daocloud.io/library/tomcat:8.5.15-jre8
		container_name: tomcat
		port:          
			- 8080:8080
		environment:  		      
			TZ: Asia/Shanghai	      
		voulmes:		                
			- /opt/docker_mysql_tomact/tomcat_webapps: /usr/local/tomcat/webapps	   # 跟mysql在一个文件里docker_mysql_tomact
			- /opt/docker_mysql_tomact/tomcat_logs: /usr/local/tomcat/logs

命令

使用docker-compose的命令时，默认会在当前目录下找docker-compose.yml文件

mkdir docker_mysql_tomcat 
cd docker_mysql_tomcat 
vi docker-compose.yml // 创建，回车，把内容复制进去（set nu可以查看行号）

// 基于docker-compose.yml启动管理的容器
docker-compose up -d  // 启动

// 关闭并删除容器
docker-compose down

// 开启、关闭、重启已经存在的由docker-compose维护的容器
docker-compose start|stop|restart

// 查看由docker-compose管理的容器
docker-compose ps

// 查看日志
docker-compose logs -f
/* ls  //一般会去查看日志映射的位置
	cd tomcat_logs/
	cat catalina.2020-04-09.log  
*/

配置dockerfile使用（用docker去管理自定义镜像）

使用docker-compose.yml文件以及dockerfile文件在生成自定义镜像的同时启动当前镜像，并且由docker-compose去管理容器

// docker-compose.yml文件  部署ssm工程到tomcat容器内部工程文件
version: '3.1'
services:
	ssm:
		restart: always
		build:   # 构建自定义镜像
			context: ../    # 指定dockerfile的所在路径（把dockerfile放到yml的上一级）
			dockerfile: Dockerfile #指定dockerfile文件名称
		image: ssm:1.0.1 #不在是去拉去，而是自定义的名称
		container_name: ssm     # 指定容器名称
		port:
			- 8081:8080
		environment:  # 指定环境
			TZ: Asia/Shanghai

// Dockerfile
from daocloud.io/library/tomcat:8.5.15-jir8  // tomcat镜像
copy ssm.war /usr/local/tomcat/webapps         // 把ssm.war复制到tomcat镜像里

|--docker_ssm
	|--Dockerfile
	|--ssm.war
	|--docker-compose
		|-- docker-compose.yml

// 可以直接启动基于docker-compose.yml以及Dockerfile文件构建的自定义镜像
docker-compose up -d
// 如果自定义镜像不存在，上面的命令会帮助我们构建出自定义镜像，如果自定义镜像已经存在，会直接运行这个自定义镜像
//重新构建自定义镜像
docker-compose build
// 运行前重新构建
docker-compose up -d --build

使用Docker安装Jenkins

Jenkins 是一款开源持续集成工具，用于监控持续重复的工作，提供一个开放易用的软件平台，使软件的持续集成变成可能
能完全兼容ant、maven、gradle等多种第三方构建工具，同时跟svn、git能无缝集成，也支持github、bitbucket直接继承

版本选择

- [jenkins](https://hub.docker.com/r/jenkins/jenkins)
- [jenkins with Blue Ocean](https://hub.docker.com/r/jenkins/jenkins/blueocean) 包含：持续交付Pipeline的复杂可视化；Pipeline编辑器；个性化；在需要干预或出现问题时精确定位；本地集成分支和合并请求

两种安装方式

命令安装

docker run -tid -u root -p 8080:8080 -v /home/jenkins:/var/jenkins_home -v /var/run/docker.sock:/var/run/docker.sock  -v /home/:/home --name jenkins jenkinsci/blueocean
/* 把/home/jenkins映射到/var/jenkins_home
	--name //容器名字
	-p //端口映射（8081：宿主主机端口，8080：容器内部端口）
	-v //数据卷挂载映射（/data/jenkins_home：宿主主机目录，另外一个即是容器目录）
*/

// 查看管理员初始密码
docker logs 容器id/容器名称 // 获取jenkins初始化的账户密码
docker logs jenkins 
/*  /home/jenkins/secrets/initialAdminPassword 或者在这里找
	获取18ec18da892948f385090fbc0acf960e，
	把它输入http://192.168.239.130:8080/login?from=%2F里,
	点击：安装推荐的插件，安装完，创建用户，保存并完成
*/

// 其他操作
docker ps // 查看正在运行的cotainners
docker ps-a // 查看所有的containners
docker restart 容器id // 重启

注意：要关闭防火墙，防火墙关闭之后需要重启docker服务

使用docker-compose.yml（另一种安装方式）

// 下载

配置jenkins

配置jenkins插件加速

// jenkins插件清华大学镜像地址
https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

// 更换地址方法 
1. 进入jenkins系统管理 : Manage Jenkins > manage plugins 进入插件管理
2. 点击advance高级选择卡，把升级站点的地址改为清华大学镜像地址，点击提交
以后下载插件，都会从清华源拉取插件

环境配置

1. 全局环境配置地址：Manage Jenkins > Configure System（可以配置全局变量、github）
注意：jenkins url 配置

2. 常用全局工具配置：
Manage Jenkins > Global Tool Configuration
新增：JDK（自动安装、Java SE Development Kit 8u221）、Git（自动安装）、Docker（自动安装、最新版本）,保存

用户权限配置
Manage Jenkins > Configure Global Security（可以设置用户查看权限）

1.  勾选：Jenkins专有用户数据库（允许用户注册）、安全矩阵（把管理员添加进来，给他所有权限），保存
2. 添加Authorize Project插件，并且在系统管理中进行配置
	Access Control forBuilds，选择Project default Build Authorization，再选择 Run as USER who Triggered Build，保存

安全矩阵，没把管理员添加了，于是报错了解决Jenkins权限配置错误

与gitlab进行联接
- 设置一个SSH Key，方便jenkins去拉取Gitlab中的项目
- Gitlab项目中去配置SSH Key的Deploy权限 Settings > Repository > Deploy keys > Public Deploy Keys
- Jenkins添加SSH的私钥

任务的五个步骤

源码管理：从哪个仓库获取到仓库源代码；
构建触发器：告诉jenkins这个任务是在什么条件下出触发任务的；
- 轮询：jenkins主动按照定时任务去轮询gitlab上的代码有没有变化，比如*/1 **** 每分钟轮询一次（比较耗资源）
构建环境：比如nodejs第几个版本
构建：打包测试操作
构建后操作：可以完成单元测试、性能测试，或者发布到指定的docker容器

插件介绍

Publish over SSH
这是一个远程Shell工具，可以远程去执行一些shell命令
HTTP Requset Plugin
跨平台调用，在构建前后可以通过该插件以http形式调用各种api接口实现和内部系统的联动
Publish Over FTP
用于远程使用FTP发布，比较适合于静态资源的发布
Performance Plugin
可以读取和解析测试框架输出的报告，并在jenkins上绘制性能和稳定性相关的图片
Gitlab Merge Request Builder Plugin
可以方便的自动发起代码审查，它在创建pull request的时候，会自动带上关联任务的运行结果，以方便代码审查通过后自动合并该pull request内容
JIRA Plugin
可以让jenkins任务和JIRA集成起来，管理者可以通过JIRA了解项目进度，开发者也可以通过该该插件直接更改JIRA上的issue状态
Kubernetes Plugin
和最近大热的容器编排框架Kubernetes集成当前不能落下。另外，jenkins对执行机的管理一直比较弱，无法做到快速的扩容和缩容。Kubernetes Plugin通过引入Kubernetes的容器编排能力，让jenkins执行机运行在Kubernetes环境中
Build Pipeline Plugin
可以让项目管理员正对系统持续集成步骤设置一系列关联的任务，任务之间可以设置不同的触发条件，以确任何时需要人工介入。该插件可以让整个持续集成变得非常直观

快速搭建gitlab服务器

docker-compose.yml

// 1. 把docker-compose.yml的内容复制过来，修改
- GITLAB_HOST=192.168.239.130 (内网测试id)
- GITLAB_ROOT_PASSWORD=12345678（记住要8位数，账号:root，密码:12345678）
- GITLAB_ROOT_EMAIL= xxx@qq.com

// 2. 新建目录
 mkdir gitlab
 cd gitlab
 vi docker-compose.yml 

// 运行gitlab
docker-compose up -d (要进到gitlab里执行)

// 查看容器，可以查看到端口，可以直接打开页面192.168.239.130:端口
docker ps

切换中文：settings > perferences > 切换language

// 生成密钥：同时生成两个SSH密钥
// 生成单个密钥
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

// 生成指定邮箱公钥和私钥
ssh-keygen -t rsa -C "mail@163.com" -f ~/.ssh/id_rsa_github

// 将公钥添加到github/gitlab中（公钥id_rsa_github.pub，一个是私钥id_rsa_github）

gitlab ci

gitlab ci是gitlab8.0之后自带的一个持续集成系统，中心思想是当每一次push到gitlab的时候，都会触发一次脚本执行，然后脚本的内容包括了测试、编译、部署等一系列自定义的内容

gitlab ci的脚本执行，需要自定义安装对应gitlab-runner来执行，代码push之后，webhook监测到代码变化，就会触发gitlab ci，分配各个runner来运行相应的脚本script。这些脚本有的是测试项目用的，有的是部署用的

gitlab-runner是什么

gitlab runner是一个开源项目，用于运行作业并将结果发送回gitlab
与gitla ci结合使用，gitlab ci是gitlab随附的用于协调作业的开源持续集成服务
gitlab runner是用go编写的，可以在linux，macOS和window操作上运行

类型
- share共享类型：运行整个平台项目的作业（gitlab）
- group项目组类型：运行特定group下所有项目的作业（group）
- specific项目类型：运行指定的项目作业（project）
状态
- lock锁定：无法运行项目作业
- paused暂停：暂时不会接受新的作业

gitlab-runner安装

安装方式：二进制文件、rmp/deb软件包、docker、kubernetes

docker命令行安装

注意：gitlab-runner版本应与gitlab版本同步，避免不一致导致差异化

cd /data/devops/gitlab
mkdir gitlab-runner 
cd  gitlab-runner
pwd // 会输出目录，挂载的目录
mkdir config
docker run -itd -v /data/gitlab-runner/config:/etc/gitlab-runner  gitlab/gitlab-runner:v12.9.0
// 挂载到/etc/gitlab，后面的是镜像

docker ps | grep gitlab
docker exec -it 容器id bash  // 进入到容器里面
gitlab-runner -h

linux上安装

// 1. 在清华源下载runner rpm包/配置yum源安装，把包拉入root里安装
// https://mirror.tuna.tsinghua.edu.cn/gitlab-runner/yum/el7/gitlab-runner-13.3.1-1.x86_64.rpm

rmp -e gitlab-runner
rpm -qa | grep gitlab
docker pull gitlab/gitlab-runner:v12.9.0

ls 
rpm -ivh gitlab-runner-12.9.0-1.x86_64.rpm

systemctl start gitlab-runner
systemctl status gitlab-runner

参考
 runner安装视频

gitlab-runner注册

获取runner token（管理中心>runner），进行注册

linux上注册

docker exec -it 容器id bash // 进入容器里再去注册
gitlab-runner register
http://19.168.1.200:30088  // 服务器地址
token  // token，在gitlab上招shared类型的
buildtest // 输入描述
build // 标签
shell // 执行器

docker上的注册

docker run -itd --rm -v /data/devops/gitlab-runner/config: /esc/gitlab-runner gitlab/gitlab-runner:v12.9.0    
gitlab-runner register\
	--non-interactive \
	--executor "shell" \
	--url "http://19.168.1.200:30088" \
	--registration-token "xxxxx" \
	--description "devops-runner"\   # 描述信息
	-- tag-list "build,deploy" \
	--run-untagged="true"\
	--locked="false"\
	--access-level="not_protected"

注册相关命令

gitlab-runner register // 默认交互模式下使用，非交互模式添加 --non-interactive
gitlab-runner list // 此命令列出了保存在配置文件中的所有运行程序
gitlab-runner verify // 此命令检查注册的runner是否可以连接，但部验证gitlab服务是否正在使用runner-delete删除
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

清华源镜像站rpm

Jenkins与Gitlab集成

配置jenkins与gitlab进行联接

安装插件：
GitHub Integration、GitLab、SSH相关的四个插件（Publish Over SSH、SSH Agent、SSH Pipeline Steps、SSH），点击直接安装
在jenkins新建一个任务，选择“构建一个自由风格的软件项目”
1）勾选：Build when a change is pushed to GitLab. GitLab webhook URL: http://192.168.239.130:8080/project/jenkins-demo （要安装上面的插件才会有这个）
2）把url地址填写到gitlab的集成url里
3）点击高级，点击generate生成Secret tokenb0d05336b6a035386feeb25f70ac7567
4）增加构建步骤，选择执行shell，输入echo 'hello world' ,点击保存
在gitlab,创建一个项目
设置目录里有一个集成选项，有一个web hooks，当代码发生请求的时候会触发这个连接，请求这个连接去触发构建任务。
1）勾选 push events，取消ssl
2）把jenkins任务的urlhttp://192.168.239.130:8080/project/jenkins-demo填写进来
3）把上面生成的token填写进来，点击add webhook
4）报错（在同一服务器，但端口不一样）：进入管理中心>设置>网络（展开外发请求，勾选并保存）

把代码发布到分支上，gitlab通过webhook实现push代码触发jenkins自动构建

pipeline流水线和vue的实践，配置自动化任务

// 1. gitab中创建项目jenkins-demo，创建vue项目
vue create jenkins-demo -n -d
cd jenkins-demo
git init	// 初始化
git remote add origin http://192./root/jenkins-demo.git   // 添加远程仓库地址


// 2. vue项目中，创建Jenkinsfile (vscode可以安装插件)
pipeline{
	agent{
		docker {
			image  'node:10'
			args  '-p 20000:8080'   # 映射到宿主机20000端口上，用来查看部署页面
		}
	}
	stages{
		stage('Build'){     # 打包
			steps{
				sh 'yarn install'  # 安装前端依赖
			}
		}
		stage('Deploy'){     # 部署
			steps{
				sh 'ls -la'  
				sh 'echo "deploy stage"'
			}
		}
	}
}

// 3. 提交上去
git add .
git commit -m "first commit"
git push origin master

// 4. Jenkins系统，打开Blue Ocean创建流水线，选择git，输入git仓库地址（gitab中jenkins-demo的地址），点击创建流水线

// 5. vue项目中，创建scripts/deploy.sh和kill.sh脚本
// deploy.sh
set -x
npm run serve &       # 运行起来
sleep 1               # 睡眠1秒  
echo $! > .pidfile    # 把运行起来的输出到.pidfile文件中
set +x

echo 'Now...'
echo 'visit http://localhost:8080 to see your application in action'

// kill.sh
set -x
kill $(cat .pidfile)   # 杀死之前的文件进程


// 6. 修改Jenkinsfile，推送到远程分支
stage('Deploy'){     # 部署
	steps{
		sh 'chomd +x  ./scripts/*.sh'    # 给scripts中的脚本执行权限
		sh './scripts/deploy.sh'         # 执行命令
		input '是否使用web网站?(点击继续)'    # 交互终端，类似comfirm，是就杀死
		sh './scripts/kill.sh'   
	}
}

// 7. 进入Jenkins系统项目中，点击小齿轮，勾选Scan多分支流水线触发器，选择1分钟轮询一次，轮询到分支有变化的时候，就会自动构建

set是把它下面的命令打印到屏幕；set -x 开启；set +x关闭；set -o 查看；

jenkins自由风格和vue的实践

思路：使用jenkins自由风格去构建项目，使用docker去进行发布

需要的插件
- node：用于不同版本的node打包
  注意：使用jenkinsci/blueccean镜像的，需要重新运行新的容器，以便nodejs插件生效
- Publish Over SSH：用于构建完成之后，推送到远程的web服务器

// 停止jenkinsci/blueccean镜像，启动另一个jenkins镜像
docker stop jenkins  // 可以不用删除之前的容器，只需要停止之前的容器即可
docker run \
	-itd \
	-u root \
	-p 8080:8080 \
	-v /var/jenkins_home:/var/jenkins_home/ \      // 把宿主机的映射到容器里面去
	-v /var/run/docker.sock:/var/run/docker.sock \
	-v /usr/bin/docker:/usr/bin/docker \
	--name jenkins-master   // 给一个名称
	jenkins/jenkins

构建项目：

// 1. gitab中创建项目jenkins-demo，创建vue项目
vue create jenkins-demo -n -d
cd jenkins-demo
git init
git remote add origin http://192./root/jenkins-demo.git
git add .
git commit -m "first commit"
git push origin master


/* 
2. Jenkins系统中，
	2.1 安装nodejs插件；
	2.2 全局工具配置中，新增nodejs，别名node 10，勾选自动安装，选择10.16.0版本，
  		输入淘宝镜像：cnpm --registry=http://registry.npm.taobao.org，点击保存。
	2.3 新建自由风格的任务，
	  	源码管理：选择git，把gitlab的仓库地址复制进来，选择用户名密码，使用master分支进行构建
	  	构建触发器：勾选：`Build when a change is pushed to GitLab. GitLab webhook URL: http://192.168.239.130:8080/project/jenkins-demo`，和点击高级，点击generate生成Secret token`b0d05336b6a035386feeb25f70ac7567`，都复制到gitlab > 设置 > 集成的url里（顺便把ssh取消掉，点击保存）
	  	构建环境：勾选Provide Node & npm bin/folder to PATH，选择node10
	  	构建：添加构建步骤，选择执行shell，输入：
*/
// jenkins发布到nginx docker容器，就可以在2000端口看到部署上去的页面
# !bin/bash
node -v
cnpm install
npm run build
ls -la   // 查看构建后的文档/目录
if ["$(docker inspect -f '{{.State.Runing}}' nginx)" = "true"]; then
	docker stop nginx && docker rm nginx
fi

docker run -itd --name nginx -V `pwd`/dist:/usr/share/nginx/html -p 20000:80 nginx


// 3. 可以在jenkis的立即构建，或者回到gitlab > 设置 > 集成的测试test，push event来构建

扩展：如果宿主机上的jenkins目录发生改变？
1）先移到宿主机上的jenkins目录
2）后执行docker run命令来迁移

mkdir /var/jenkins_home
cp -rf /src/jenkins/  /var/jenkins_home/   // 复制后删除
docker run \
	-itd \
	-u root \
	-p 8080:8080 \
	-v /var/jenkins_home:/var/jenkins_home/ \      // 把宿主机的/var/jenkins_home映射到容器的/var/jenkins_home/目录
	-v /var/run/docker.sock:/var/run/docker.sock \
	-v /usr/bin/docker:/usr/bin/docker \
	--name jenkins-master   // 给一个名称
	jenkins/jenkins

总结：

使用一台单独的nginx服务器发布，使用publish over ssh插件上传
使用docker在本地发布或者远程发布
使用dockerfile进行镜像内的构建，使用docker镜像进行发布

待续…

参考：
docker视频
 Jenkins
GitLab配置ssh key

总结：要去理解原理，理解了之后，实现就是操作层面上的事情

sayid760

关注

5
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
前端CI/CD实践

核心概念持续集成Continus Integration，简称CI开发的结果每天多次提交，并且合并到主库的做法把主库的代码进行克隆，克隆下来就进行发布，持续发布，持续堆主干的分支进行合并开发人员提交新的代码之后，立即进行构建、单元测试，根据测试结果可以确定新代码和原有代码是否能够集成在一起，就能够很好避免了项目快到交互的时候，出现特别多的bug，能够在很前面的时间节点上去发现代码不稳定不确定的因素持续交互（Continuous Delivery，简称CD）完成了ci构建及单元测试和集成
复制链接

扫一扫