jenkins实现CICD+项目实战
·
1、jenkins
运维发布和业务的生产经验
jenkins安装部署
官网链接：Jenkins
如何实现，cicd，持续集成，持续部署的流水线
git , gitlab ==== 10.0.0.99
jenkins机器先准备，用与部署jenkins ======== 10.0.0.100
1.安装，第三方源，或者本地导入
1.去清华源下载，找的就是jenkins.rpm
https://mirrors.tuna.tsinghua.edu.cn/jenkins/redhat/
2.下载好如下系列软件包即可
jenkins是java开发，需要有jdk，java环境
二是导入jenkins的rpm包安装
[root@jenkins-100 /opt]#ls
jdk-8u181-linux-x64.rpm jenkins-2.190.1-1.1.noarch.rpm jenkins_plugins.tar.gz
3.先装jdk 再装jenkins
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#yum localinstall jdk-8u181-linux-x64.rpm -y
java -version
[root@jenkins-100 /opt]#yum localinstall jenkins-2.190.1-1.1.noarch.rpm -y
4.验证jenkins版本
[root@jenkins-100 /opt]#rpm -qa jenkins
jenkins-2.190.1-1.1.noarch
5.启动jenkins，默认该jenkins.rpm给你创建好了启动脚本，
/etc/rc.d/init.d/jenkins
可以直接用systemctl去调用
systemctl start jenkins
看懂1111
6.检查jenkins端口
[root@jenkins-100 /opt]#netstat -tunlp|grep 8080
tcp6 0 0 :::8080 :::* LISTEN 2007/java
7. 查看jenkins脚本，运行的进程，
执行的什么命令，运行的jenkins进程
修改jenkins主配置文件（这里先别改了，后续安装完毕后再改）
先别去访问，还得修改jenkisn的配置文件，再去访问
找到jenkins的主配置文件
[root@jenkins-100 /opt]#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
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#systemctl restart jenkins
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#grep -E '^[a-Z]' /etc/sysconfig/jenkins
JENKINS_HOME="/var/lib/jenkins"
JENKINS_JAVA_CMD=""
JENKINS_USER="root"
JENKINS_JAVA_OPTIONS="-Djava.awt.headless=true"
JENKINS_PORT="8080"
JENKINS_LISTEN_ADDRESS=""
JENKINS_HTTPS_PORT=""
JENKINS_HTTPS_KEYSTORE=""
JENKINS_HTTPS_KEYSTORE_PASSWORD=""
JENKINS_HTTPS_LISTEN_ADDRESS=""
JENKINS_HTTP2_PORT=""
JENKINS_HTTP2_LISTEN_ADDRESS=""
JENKINS_DEBUG_LEVEL="5"
JENKINS_ENABLE_ACCESS_LOG="no"
JENKINS_HANDLER_MAX="100"
JENKINS_HANDLER_IDLE="20"
JENKINS_EXTRA_LIB_FOLDER=""
JENKINS_ARGS=""
访问 10.0.0.100:8080
/var/lib/jenkins/secrets/initialAdminPassword
JENKINS_ARGS=""
[root@jenkins-100 /opt]#cat /var/lib/jenkins/secrets/initialAdminPassword
a2859c22d1344057a1ce3e3dfdbe481d
[root@jenkins-100 /opt]#
直接叉掉，不做任何插件安装
1.默认是国外的jenkins 插件源，太慢，下载不了
2. 直接开始使用
重新开了个无痕浏览器http://10.0.0.100:8080/
如果忘记jenkins账户密码，可以按如下操作重置jenkins密码
刚才踩坑在，没有账户密码，登录不进去。
[root@jenkins-100 /opt]#vim /var/lib/jenkins/config.xml
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#
[root@jenkins-100 /opt]#systemctl restart jenkins
[root@jenkins-100 /opt]#
重置密码的步骤
下一步，即可登录jenkins
admin
linux0224
登录jenkins，保存用户的设置
http://10.0.0.100:8080/
jenkins插件导入
目前没有插件，导入插件
直接移动所有的插件文件，到jenkins的插件目录下，重启即可
[root@jenkins-100 /opt/plugins]#ls |wc -l
263
[root@jenkins-100 /opt/plugins]#pwd
/opt/plugins
[root@jenkins-100 /opt/plugins]#
[root@jenkins-100 /opt/plugins]#
[root@jenkins-100 /opt/plugins]##mv * /var/lib/jenkins/plugins/
[root@jenkins-100 /var/lib/jenkins/plugins]#systemctl restart jenkins
jenkins自由风格任务创建
第一个玩法，创建简单任务
简单的， free-style-job 自由风格任务，执行简单linux命令
第一个任务的名，job名，
linux0224-hellojob任务的描述
这是第一个简单的自由风格的job，用于学习，jenkins的工作区的概念
查看jenkins的job，
是在哪执行的，以及jenkins是在哪，执行的linux命令
这个逻辑很重要
jenkins，添加构建shell动作
# jenkins再这执行命令了
echo "当前主机名：$(hostname)"
echo "jenkins是在哪执行的命令？：$(pwd)"
echo "jenkins执行文件创建：$(touch 奥利给.log)"
echo "搜索该文件，看看在哪：$(find / -name '奥利给.log')"
# shell嵌入jenkins的内置变量，还是很方便的
echo "查看jenskins如下内置变量"
echo -e "JOB_NAME -------------- ${JOB_NAME}
BUILD_ID -------------- ${BUILD_ID}
WORKSPACE ----------${WORKSPACE}
JENKINS_HOME -------- ${JENKINS_HOME}
"
/var/lib/jenkins/workspace/job名/该job创建的数据
# 看懂jenkins，执行shell，帮你执行命令，帮你部署程序
# 而且这里知识，嵌入jenkins变量的玩法回到jenkins首页
立即构建
linux上查看jenkins的任务数据文件
job的绝对路径
/var/lib/jenkins/workspace/
多次执行job，查看结果
jenkins的job会用在哪？
例如运维可以使用jenkins的job功能，给其他不懂linux命令的同事，通过一键点击，就能够执行linux命令
例如服务重启等
可以有效的防止不懂linux的技术人员，在服务器上做奇怪的操作。
再创建一个job练习远程执行命令
简单的，试试，远程执行命令的job
远程，远程检查web7机器的nginx运行状态
想远程执行命令，先配置远程，免密登录
[root@jenkins-100 ~]#ssh-copy-id root@10.0.0.7
再试试任务执行构建jenkins结合gitlab，实现ci，cd流水线（python篇）
开发 > gitlab > 运维 > 目标服务器
实现flask代码，一键部署到web7机器
创建远程项目，gitlab
完全的空仓库
master用管理员角色，生成些初始的数据，master分支
思路，用管理员账户，推送数据，生成master分支
开发写代码，推送到目标远程仓库
wenjie得用分支去推
gitlab仓库，默认master分支保护，文杰属于开发者权限
wenjie账户，去推送代码， 到项目中
先创建开发者分支
# 先克隆远程仓库，成为本地仓库，提交版本
git clone git@10.0.0.99:linux0224/linux0224_python.git
git checkout -b wenjie
[root@db-51 ~/linux0224_python]#cat my_flask.py
cat > my_flask.py <<'EOF'
# coding:utf-8
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return '<h1> 测试jenkins 结合 gitlab 做python项目的更新，发版 -----v1 </h1>'
if __name__ == '__main__':
app.run(host="0.0.0.0")
EOF
# 本地提交版本到 wenjie分支
git add .
git commit -m 'wenjie my_flask.py v1'
# 推送到远程仓库
[root@db-51 ~/linux0224_python]#git remote -v
origin git@10.0.0.99:linux0224/linux0224_python.git (fetch)
origin git@10.0.0.99:linux0224/linux0224_python.git (push)
[root@db-51 ~/linux0224_python]#
[root@db-51 ~/linux0224_python]##
git push -u origin wenjie
注意细节，用wenjie账户的浏览器，去访问，merge请求
确认用管理员，合并代码
再次查看源码master分支的
开发你可以去休息了
运维上场，设置jenkins，去下载gitlab的代码
1. 创建自由风格的job
linux0224_python
2. 配置job
先看gitlab用账户密码的认证方式
# bug 1，jenkins机器，没git
#
给jenkins创建读取gitlab的凭证
应该用运维的账户，去获取master代码
试试账户密码的形式，能把代码拉去下来吗
直接保存，点击构建，查看工作区的内容
再看gitlab用ssh-key的方式，代码下载
jenkins 机器
配置公钥，添加到gitlab平台上
[root@jenkins-100 /var/lib/jenkins/workspace/linux0224_python]#cat ~/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDDfLc7zlNc8XHrQopNbw5zV6UIJXHxjGc731bpkK8kzJ2ZoMX5K/2sGKCpOukowQ22I+M3hpm0rx8hyVi1F+aM6UhPfqzmDgMhnW6WHzfl6CuRCmjeje906Iwe892M6Idyh+pjpTpZP953cweufbPWWREDxj4bXyw0Wl65TqqgiV6INpGU87Lt9gnMa9HsR8KyMzXsfxqJgxHhnDS4pPHWBodUPEjfgBK9AV9eX5YRKYGObdVZ1d/Su3k8AmA2Fx5xzsg8QT1ZedQRgjSERrBAWEg88Qrmlxj28HbKj1lOEnSVdyu68Qe4zlV/DzE1kKFunJo8oBkWmUGtdSvhkXOt root@jenkins-100
免密下载gitlab代码
1. 添加jenkins的公钥到 gitlab平台上
2. 去jenkins的job中，添加密钥的认证方式
【ssh username with private key 】
ssh的用户名，私钥
测试好使吗
[root@jenkins-100 /var/lib/jenkins/workspace/linux0224_python]#ll
total 8
-rw-r--r-- 1 root root 242 Jul 20 00:09 my_flask.py
-rw-r--r-- 1 root root 42 Jul 20 00:09 README.md小结
开发的v1代码上传了
jenkins实现了gitlab代码下载
发布到目标机器上，运行（web7）测试运行
jenkins
1. git拉去代码
2. 自由风格的 执行shell功能
# 先发送源代码到目标机器
# 严谨的代码
# 工作区，打个包，发到目标机器
tar -zcf all_linux0224_python.tgz ./*
scp all_linux0224_python.tgz root@10.0.0.7:/opt/
# 远程执行目标机器的发布脚本
scp /my_shell/run_python_web7.sh root@10.0.0.7:/opt/
ssh root@10.0.0.7 "bash /opt/run_python_web7.sh"
# 解压缩，运行
1. 检查jenkins机器是否有压缩包
查看发布结果
优化脚本，实现更新功能
目前先完成简单的部署操作即可，先一切从简，完成发布即可
jenkins上的构建shell配置
# 1.进入job工作区，代码发过去
# 远程创建一个源码目录
ssh root@10.0.0.7 "mkdir -p /opt/linux0224_python"
# 进入job的工作区，把当前所有源码，发到目标机器的目录下
cd ${WORKSPACE} && scp ./* root@10.0.0.7:/opt/linux0224_python/
# 将部署脚本，发到远程机器上
scp /my_shell/run_python_web7.sh root@10.0.0.7:/opt/
# 远程执行命令，再web7机器，部署flask项目
ssh root@10.0.0.7 "bash /opt/run_python_web7.sh"
# 2.部署操作写成脚本，发给目标机器
#!/bin/bash
cd /opt/linux0224_python/
yum install python3-devel python3 python3-pip -y > /dev/null
pip3 install flask
# 重启逻辑
kill -9 $(ps -ef|grep my_flask.py|grep -v grep | awk '{print $2}')
nohup python3 my_flask.py >nohup.log 2>&1 &
# 查看进程id
echo "当前python进程是：$(ps -ef|grep my_flask.py|grep -v grep | awk '{print $2}')"jenkins实现更新代码的流程结果
1. 模拟开发，改代码
2. 点击立即构建2.1 看看反复更新，好使吗
3.看结果
2、自动化发布静态页面
部署流水线
git + gitlab + jenkins + (发布动作，部署 shell脚本)
操作较多的机器
批量管理git + gitlab + jenkins + ansible + (发布动作，部署 shell脚本)
流水线脚手架
git + gitla（代码仓库） + jenkins （创建任务，鼠标点这里）
1. 下载gitlab代码
2. 根据jenkins设置的 构建shell（填入的部署的命令）
3. 根据构建shell的设置，执行发布部署动作
一键发布静态网站
先准备一个代码仓库
1.新建项目，导入项目url
https://gitee.com/lvyeyou/DaShuJuZhiDaPingZhanShi.git
配置jenkins构建任务
修改构建shell
#!/bin/bash
#author: www.yuchaoit.cn
# 1.进入代码目录，打包传输
DATE=$(date +%Y-%m-%d-%H-%M-%S)
web_server_list="10.0.0.7 10.0.0.8"
get_code(){
cd ${WORKSPACE} && \
tar czf /opt/web-${DATE}.tar.gz ./*
}
# 2.代码发送给web集群组
# 基于软连接，指向具体的文件目录，实现发版
scp_web_server(){
for hosts in $web_server_list
do
scp /opt/web-${DATE}.tar.gz root@$hosts:/opt/
ssh root@$hosts "mkdir -p /code/web-${DATE} && \
tar -zxf /opt/web-${DATE}.tar.gz -C /code/web-${DATE}
rm -rf /code/web && \
ln -s /code/web-${DATE} /code/web"
done
}
deploy(){
get_code
scp_web_server
}
# 执行入口
deploy
排除构建失败
Host key verification failed.
lost connection
Host key verification failed.
jenkins机器，和7 8 俩机器，免密有问题
配置目标机器，web7，web8
目标机器，连nginx都没有，jenkins加上部署nginx操作
自己灵活点，技术再手里，想怎么用，随你便
只要把活搞定
# nginx，找到具体的html，展示即可
cat > /etc/nginx/conf.d/monitor.conf <<'EOF'
server{
listen 80;
server_name _;
location / {
# nginx会去这个目录下，找代码，index.html
root /code/web/智慧城市/智慧工地;
index index.html;
}
}
EOF
# 重启
pkill -9 nginx
systemctl restart nginx捋一捋
先看看nginx两台机器上的opt目录
1. gitlab有代码了
2. jenkins的 job，脚本页都正确执行，发送代码了
3. web 7 web8 的nginx页ok了4. 访问试试
出现问题了403，nginx发给你的5. 修改了nginx的root网页根目录，找到了前端文件
确保7 8 俩机器都可以访问
目前完成了，手工构建，第一版的web7 web8的静态网页
第二版，静态代码更新，再次构建，查看部署更新逻辑结果
1. 开发
- 下载代码
- 更新代码
-推送代码2. 运维
- 手工更新
1. git clone 下载最新代码
2. 放入nginx的网页根目录，路径匹配上就OK
- 自动化部署
开发使用git的常见问题
本地和远程同步
$ git pull origin master
remote: Enumerating objects: 9, done.
remote: Counting objects: 100% (9/9), done.
remote: Compressing objects: 100% (5/5), done.
remote: Total 5 (delta 4), reused 0 (delta 0)
Unpacking objects: 100% (5/5), 472 bytes | 18.00 KiB/s, done.
From 10.0.0.99:chaoge/linux0224_html
* branch master -> FETCH_HEAD
c561a5a..395bff5 master -> origin/master
Auto-merging 智慧城市/智慧工地/index.html
CONFLICT (content): Merge conflict in 智慧城市/智慧工地/index.html
Automatic merge failed; fix conflicts and then commit the result.
多个版本，都修改了同一行远程代码。。。。
手工删除无用代码，保留你想要的就行
此时最新的代码仓库内容
<div class="caption-title">
<i class="fl"><img src="images/title-left.png" ></i>
<span class="biaoti fl">我是文杰，接手了这个项目</span>
<i class="fr"><img src="images/title-right.png" ></i>
</div>
运维jenkins鼠标一点，轻松搞定
运维发布，分几个阶段，几个级别
1. 纯手工发布，shell脚本
2. jenkins手工构建，实现
3. 自动化构建
遇见的业务，很多，很杂，
webhook自动化触发构建事件
jenkins的设置
jenkins这里，保留着俩信息
026d350aa43472fc154195111d45b916
http://10.0.0.100:8080/project/linux0224_htmlgitlab的设置
1. 找到具体的项目url，仓库url
gitlab功能 设置，允许本地网络请求
点击测试，确认看到 http 200即可
模拟cicd环节中，ci环节
master去练习
3、jenkins发布Java项目
java项目是什么(springboot)
主流的，最新的java开发技术栈，采用springboot框架去写代码，写项目(开发操心要学的东西)
这个框架，内置了tomcat服务器，因此能实现
========================================================================
运维只需要关心这个1. 是否要部署tomcat程序去（你们的开发，给你一个war包，需要安装tomcat去发布java项目）
最终，都会将java项目运行再 10.0.0.8:8080
2. 开发直接丢给你一个jar包，无需部署tomcat，直接 java -jar *.jar即可启动项目（内置tomcat程序）
最终，都会将java项目运行再 10.0.0.8:8080
由java语言开发的后端，就是java项目
- wordpress---php项目部署，提供LNMP，交给php-fpm进程去解释执行该源码
- jumpserver的core后端---python项目，提供python3环境，即可运行
- golang程序，需要安装golan编译器，编译二进制命令行，即可运行。
java项目，提供java开发环境，且进行编译后，方可运行。简单理解java的源代码，好比一堆零散的零件（文件），通过编译，打包之后，成为一个整体小汽车（java代码包），然后就可以基于这个代码包运行java进程了。
springboot是java开发中的一个框架，用于写后端接口，用于写web后端的。本文将带你玩转基于java后端的高级devops流水线项目，真刀真枪玩转项目
java项目的部署方式
目前市场上，部署java web的方式，主要有俩方案：
1. 开发交付给运维的是一个（*.war） zip类型的压缩包，这个压缩包里包含了网站的thml，配置文件，以及java代码，运维只需要提供应用容器（tomcat）即可发布这个java网站。（集团型的中大型公司，用该方案）
2. 目前互联网公司以devops开发模式，快速迭代模型，并且java后端诞生spring Boot框架，最终开发交付的产物是（*.jar）也是zip类型的压缩包，且springboot该框架内置了应用容器（tomcat），最终运维只需要（jar -jar *.jar）即可运行java网站
war和jar部署区别
tomcat章节再去讲war包部署
先学习jar包的部署
--------回忆多种语言的部署方式
- php部署，启动php-fpm，以及准备好*.php源码即可
- python3部署，需要安装python3，pip3 install安装依赖，python3 启动进程
java项目部署，准备好jar压缩包，jar -jar *.jar启动即可
- - 如sprintboot框架的hello-world的编译 与运行
- - 如halo博客的部署
更多maven命令
就看你以后维护的方向是什么，再做更多的深入学习，完成工作即可
常用 Maven 命令介绍-腾讯云开发者社区-腾讯云
体验jar包的玩法一
# 运维，通过搭建java项目的构建流水线
# 1. gitlab 拉去java项目源码
# 2. jenkens环节，进行源码编译，打包生成 jar包
# 3. jenkins把这些jar包发到目标服务器上（web7，web8两台机器）
# 4. 分别再2机器，运行jar包就完事
下载 java源码，进行maven打包，模拟开发，生成jar包，再去运行
#学习maven的部署玩法
# java的springboot项目，需要用maven这个工具去编译
# 1.安装maven工具
yum install maven -y
[root@db-51 /opt/springboot-test]#mvn -version
Apache Maven 3.0.5 (Red Hat 3.0.5-17)
Maven home: /usr/share/maven
Java version: 1.8.0_332, vendor: Red Hat, Inc.
Java home: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.332.b09-1.el7_9.x86_64/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-862.el7.x86_64", arch: "amd64", family: "unix"
[root@db-51 /opt/springboot-test]#
# 2. 下载java源码
git clone https://gitee.com/yuco/springboot-test.git
#3. 进入源码目录，打包即可
[root@db-51 /opt/springboot-test]#ll
total 28
-rw-r--r-- 1 root root 9114 Feb 25 09:33 mvnw
-rw-r--r-- 1 root root 5811 Feb 25 09:33 mvnw.cmd
-rw-r--r-- 1 root root 2134 Feb 25 09:33 pom.xml
drwxr-xr-x 4 root root 30 Feb 25 09:33 src
-rw-r--r-- 1 root root 643 Feb 25 09:33 项目说明.text
[root@db-51 /opt/springboot-test]#
[root@db-51 /opt/springboot-test]#
# 再不懂配置文件语法请看下，别改了
# 修改pom.xml配置文件，修改最终生成jar包的名字
# 7 <artifactId>java-test-linux02224</artifactId>
# 8 <version>6.0</version>
还得修改maven的下载源，改为阿里云的，否则下载忒慢了
# yum 配置阿里源 pip3 也要配置豆瓣源
# maven也得配置阿里源
# 找到maven的配置文件目录，yum安装的，默认都在etc目录下
/etc/maven/settings.xml
修改如下
<mirror>
<id>alimaven</id>
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
</mirror>
# 4.启动
先打包，生成jar包，maven自动下载项目的依赖
[root@db-51 /opt/springboot-test]#mvn clean package
期望结果如下
[INFO] Replacing main artifact with repackaged archive
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1:14.183s
[INFO] Finished at: Fri Feb 25 09:47:31 CST 2022
[INFO] Final Memory: 32M/203M
[INFO] ------------------------------------------------------------------------
#查看 当前源码目录下的 target目录下的jar包
[root@db-51 /opt/springboot-test]#ll target/
total 18948
drwxr-xr-x 3 root root 40 Feb 25 09:47 classes
drwxr-xr-x 3 root root 25 Feb 25 09:47 generated-sources
drwxr-xr-x 3 root root 30 Feb 25 09:47 generated-test-sources
drwxr-xr-x 2 root root 28 Feb 25 09:47 maven-archiver
drwxr-xr-x 3 root root 35 Feb 25 09:47 maven-status
-rw-r--r-- 1 root root 19388017 Feb 25 09:47 springboot-helloword-1.jar
-rw-r--r-- 1 root root 8656 Feb 25 09:47 springboot-helloword-1.jar.original
drwxr-xr-x 2 root root 135 Feb 25 09:47 surefire-reports
drwxr-xr-x 3 root root 17 Feb 25 09:47 test-classes
# 启动，运行打包的jar包，查看进程
java -jar springboot-helloword-1.jar
# 客户端访问，具体的url，要开发给你写好文档，否则你不一定知道访问啥
# 该测试代码，提供的访问路径是
http://10.0.0.51:8080/say
# 查看如果修改了源码，如何更新的逻辑？
# 运维要理解，源码编译为jar包，后续的源码更新，要再次打包
[root@db-51 /opt/springboot-test]#cat src/main/java/com/cn/mical/springboot/controller/HelloController.java
package com.cn.mical.springboot.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @program: helloword
* @Date: 2022年6月22日22:34:02
* @Author: linxin
* @Description:
*/
@RestController
public class HelloController {
@RequestMapping("/say")
public String say(){
return "Hello Word 不要当咸鱼，要当煤老板";
}
}
# 重新打包
体验jar包的玩法二
1. 开发，直接发给你了一个 *.jar包
2. 运维要干啥啊？
安装java
运行jar包就完事
随便找个机器先作为测试练习
# 这是最新版本
$ wget https://dl.halo.run/release/halo-1.5.4.jar
# 试试1.1.0版本
https://github.com/halo-dev/halo/releases?page=6
# 去官网下载jdk.rpm 或者直接yum安装
# yum install java -y 快速部署java开发环境
# 开发，他是基于什么版本的java环境，写的代码，都会交付环境文档给运维
# 运维去线上服务器，部署相应的版本，java版本和代码依赖的版本要一致，否则也会报错。
[root@db-51 /opt]#java -version
openjdk version "1.8.0_332"
OpenJDK Runtime Environment (build 1.8.0_332-b09)
OpenJDK 64-Bit Server VM (build 25.332-b09, mixed mode)
# 访问低版本的效果
[root@db-51 /opt]#java -jar halo-1.1.0.jar
__ __ __
/ / / /___ _/ /___
/ /_/ / __ `/ / __ \
/ __ / /_/ / / /_/ /
/_/ /_/\__,_/_/\____/
::: Spring-Boot 2.1.7.RELEASE ::: Halo (version: (v1.1.0))
Halo started at http://10.0.0.51:8090
Halo admin started at http://10.0.0.51:8090/admin
# 测试访问
linux0224
linux0224@qq.com
123123123
halo博客使用的是内嵌数据库(h2)
也就是不依赖于mysql，单独一个java的内置进程，管理了博客数据库
https://docs.halo.run/getting-started/config
https://www.baeldung.com/spring-boot-h2-database
项目架构
构建服务器环境检查
10.0.0.100 jenkins-100
maven环境，也装这个jenkins 100机器上
必须得有jdk环境
java环境
[root@jenkins-100 ~]#java -version
java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)maven环境
以下作为博客，看看了解即可，java开发的知识
[root@jenkins-100 ~]#mvn -version
-bash: mvn: command not found
准备好的maven rpm包安装
#准备好安装包，解压缩，配置PATH变量
[root@jenkins-100 /opt/maven339/apache-maven-3.3.9/bin]#ll /opt/maven339/apache-maven-3.3.9-bin.tar.gz
-rw-r--r-- 1 root root 8491533 Jul 14 12:01 /opt/maven339/apache-maven-3.3.9-bin.tar.gz
[root@jenkins-100 /opt/maven339/apache-maven-3.3.9/bin]#tail -2 /etc/profile
export PATH=$PATH:/opt/mysql5.7.28/bin/:/opt/sonarqube-all/sonar-scanner-4.0.0.1744-linux/bin:/opt/maven339/apache-maven-3.3.9/bin:/opt/node/bin
# 查看mvn命令的环境
[root@jenkins-100 ~]#mvn -version
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: /opt/maven339/apache-maven-3.3.9
Java version: 1.8.0_181, vendor: Oracle Corporation
Java home: /usr/java/jdk1.8.0_181-amd64/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-862.el7.x86_64", arch: "amd64", family: "unix"
Maven项目结构
一个使用Maven管理的普通的Java项目，它的目录结构默认如下：
部署maven
修改maven打包工具的 依赖源地址，改为阿里云的
# 注意如何找maven的家目录
[root@jenkins-100 ~]#mvn -version
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: /opt/maven339/apache-maven-3.3.9
Java version: 1.8.0_181, vendor: Oracle Corporation
Java home: /usr/java/jdk1.8.0_181-amd64/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "3.10.0-862.el7.x86_64", arch: "amd64", family: "unix"
# 找到maven工具的家目录，配置文件
ls /opt/maven339/apache-maven-3.3.9
146 <mirrors>
147 <!-- mirror
148 | Specifies a repository mirror site to use instead of a given repository. The repository that
149 | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
150 | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
151 |
152 <mirror>
153 <id>mirrorId</id>
154 <mirrorOf>repositoryId</mirrorOf>
155 <name>Human Readable Name for this Mirror.</name>
156 <url>http://my.repository.com/repo/path</url>
157 </mirror>
158 -->
159 <!-- 阿里云仓库 -->
160 <mirror>
161 <id>alimaven</id>
162 <mirrorOf>central</mirrorOf>
163 <name>aliyun maven</name>
164 <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
165 </mirror>
166 </mirrors>
167 
至此mvn的打包环境就ok了
配置源码仓库，和jenkins了
jenkins检查
确保你的jenkins装好了maven插件
安装jenkins时，以及导入了
配置jenkins支持maven
配置jdk
配置具体的jenkins，设置maven命令，家目录
至此，jenkins就可以正确使用mvn这个命令去打包了
配置ssh（ssh-server）
下一步就是要确保架构中的，jenkins机器，和目标机器实现ssh免密操作。
需要jenkins额外安装 publish over ssh
远程ssh免密登录的插件选择jenkiins在线的，配置jenkins插件源，如更换清华的去装
手动下载插件，导入
systemctl restart jenkins
重启后，配置ssh的免密登录
jenkins机器，发布jar包到web7 web8机器
先免密登录
[root@jenkins-100 ~]#ssh-copy-id root@10.0.0.7
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: WARNING: All keys were skipped because they already exist on the remote system.
(if you think this is a mistake, you may want to use -f option)
[root@jenkins-100 ~]#
[root@jenkins-100 ~]#ssh-copy-id root@10.0.0.8
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: WARNING: All keys were skipped because they already exist on the remote system.
(if you think this is a mistake, you may want to use -f option)
[root@jenkins-100 ~]#
[root@jenkins-100 ~]#
[root@jenkins-100 ~]#ssh root@10.0.0.7 "hostname"
web-7
[root@jenkins-100 ~]#ssh root@10.0.0.8 "hostname"
web-8
# 拿着jenkisn的私钥做验证
# 设置文件发到目标机器的，/opt/jenkins-sh/目录，得先创建
#先jenkins机器，进行远程检查
给jenkins配置 ssh插件的私钥即可
至此，可以实现
jenkins发文件目标机器 web7 web8的/opt/jenkins-sh/文件夹了
创建Jenkins任务
该job用于，编译java项目以及，远程发布
新建任务
首页>新建>输入一个任务名称>构建一个maven项目
勾选丢弃旧的构建
git源码管理
新建gitlab仓库
1.这里模拟java开发角色，上传代码到gitlab
导入该码云的仓库即可
https://gitee.com/yuco/springboot-test.git
还得配置jenkins，能正常下载这个源码
git gitlab jenkins + mvn + 钉钉
gitlab 哦了
jenkisn + mvn 哦了
jenkins 获取 gitlab java源码 哦了
构建触发器webhook设置
gitlab代码仓库更新，jenkins任务自动执行
71def90efe52f31ac2d142600243eff1
http://10.0.0.100:8080/project/linux0224-java
需要交给gitlab找到gitlab的代码仓库，集成jenkins的push事件
构建环境设置
最后一步动作，给jenkins的job，添加mvn的构建参数
Maven project linux0224-java
实现java源码拉去
执行mvn命令
具体对源码的编译参数，还未设置
填入mvn的构建参数
clean install -Dmaven.test.skip=true都是在当前job工作去下的 target目录中，得到jar包
手工执行mvn，结合jenkins
手工测一测 jenkins能否下载代码
mvn能否打包，jar包
以及能否运行
检查jar包是否可用就可以了
然后再发给web7 web8 实现更新发布脚本就哦了
配置job，把生成的jar发给web7 web8
这里的配置是jenkins 远程执行，远程机器上的一个脚本
最后
去
web7 web8 ，设置运行java程序的脚本
/opt/jenkins-sh/deploy-java.sh
钉钉设置
构建结果，写入到钉钉，发个通知，实际运用的效果
1. 生成钉钉机器人
# 这个url，就对应了这个钉钉群聊
https://oapi.dingtalk.com/robot/send?access_token=b647b8999781885a19d40c34da457ed6fc586fafb1b8004cca3dd13da60c6a32
到这 jenkins，构建结果，只有是 success的时候，才会发送钉钉群聊
部署脚本开发
再web7 和 web8机器准备
mkdir -p /opt/jenkins-sh/
cat > /opt/jenkins-sh/deploy-java.sh << 'EOF'
#!/bin/bash
#格式化时间，年月日
DATE=$(date +%Y%m%d)
#设置程序目录，设置一个java项目的备份目录，因为会多次构建
# 希望保留之前的旧的版本，而不是直接覆盖
# 这个 web7 ，web8的用于，保存jar包的目录
DIR=/usr/local/app
#设置Jar名称，也就是jenkins构建maven build后的产物
# 填入你的java程序，打包后的文件名
JARFILE=springboot-helloword-1.jar
#判断是否存在backp目录，如果不存储就创建
# 如果备份目录不存在，则创建
# 再代码目录下，创建一个backup文件夹
# 旧的jar包，会放入 /usr/local/app/backup目录
if [ ! -d $DIR/backup ];then
mkdir -p $DIR/backup
fi
# 进入到web7，或 web8的 jar包，发布目录
cd $DIR
#杀掉当前运行的旧程序
# 干掉旧的java程序
ps -ef | grep $JARFILE | grep -v grep | awk '{print $2}' | xargs -i kill -9 {}
#备份旧程序
# 移动当前的jar文件 到 backup目录下，且加上时间
mv $JARFILE $DIR/backup/$JARFILE$DATE
#部署新程序
# 将jenkins发来的jar包，放入 当前的 jar包发布目录 /usr/local/app
mv -f /opt/jenkins-sh/target/$JARFILE .
# 至此就实现了，旧的jar包，放入了 /usr/local/app/bakcup/
# 新的jar包，/usr/local/app
# 然后可以启动新程序了
echo "The service will be starting"
#后台启动程序并设置Jvm参数、开启JMX、打印GC日志
# java -jar springboot-helloword-1.jar
# 到这，等于实现，发布脚本，实现了更新进程，备份旧得jar包
# 启动 新的进程
# 听懂111111，课下自己手写，这个代码
# 给大家模拟 一个生产环境下，会有很多的优化参数
java -server -Xms1024M -Xmx1024M -XX:PermSize=256M \
-XX:MaxPermSize=256M -XX:+HeapDumpOnOutOfMemoryError -XX:+PrintGCDetails \
-Xloggc:./gc.log \
-Dcom.sun.management.jmxremote -Djava.rmi.server.hostname=127.0.0.1 \
-Dcom.sun.management.jmxremote.port=10086 -Dcom.sun.management.jmxremote.ssl=false \
-Dcom.sun.management.jmxremote.authenticate=false \
-Dserver.address=0.0.0.0 -Dserver.port=18888 \
-jar $JARFILE --spring.profiles.active=dev > /nohup 2>&1>out.log &
# 如果上述java启动jar包命令，正确的话，等待30秒，查看运行日志
if [ $? = 0 ];then
sleep 30
tail -n 50 out.log
fi
# 进入备份目录，删除旧数据
# 此时再 /usr/local/app/
cd backup/
# 清理旧的jar包，保留有5个旧版本的备份
# 基于 ls -lt的参数，基于时间对文件排序
# 备份的jar文件超过5个了，删除最旧的那个文件
# 可以多次构建，查看脚本的执行结果
ls -lt|awk 'NR>5{print $NF}'|xargs rm -rf
echo "starting success!!!"
EOF
给脚本加上执行权限
chmod +x /opt/jenkins-sh/deploy-java.sh点击立即构建
测试触发push钩子
模拟开发，更新代码
讲道理，最后回车下去，web7 web8 应该是能看到 10.0.0.xx:18888的页面的
理解它背后会发生什么 66666
讲道理，钉钉出现结果才是对的
$ git push -u origin master
排bug 拍地雷
地雷1，jenkins的ssh远程执行脚本参数错误
错误在于，jenkins想远程执行脚本，发现脚本路径找不到，相对路径
地雷2，远程机器，执行脚本，缺少java环境
web7
和
web8
都要运行脚本，启动java项目
只需要能正确执行
java -jar *.jar就行
只要要装个java环境把老铁
部署脚本里面，多考虑一层，加上java的安装
yum install java -y思路
1. 再次模拟开发，更新代码，push 代码，触发gitlab的 webhook
2. gitlab会去调用jenkins 的job执行3. jenkins 拉取最新源码，mvn打包，生成最新的jar包
4. jenkins 会发送最新的jar包到 web7 web8，切远程执行目标机器的脚本
5. 实现web7 web8 的java项目发布，以及 多次构建的历史备份，/usr/local/app/backup/
6. 最后一个环节，检查，web7 web8 的 18888是否可以访问
7. 钉钉是否收到了消息
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
9
0- 0
已为社区贡献14条内容
所有评论(0)