《Jenkins持续集成入门到精通-进阶篇》

《Jenkins持续集成入门到精通-进阶篇》

提示: 本材料只做个人学习参考,不作为系统的学习流程,请注意识别!!!


《Jenkins持续集成入门到精通-进阶篇》


4. Jenkins+Docker+SpringCloud微服务持续集成(上)

4.1 Jenkins+Docker+SpringCloud持续集成流程说明

在这里插入图片描述
大致流程说明:

1)开发人员每天把代码提交到Gitlab代码仓库
2)Jenkins从Gitlab中拉取项目源码,编译并打成jar包,然后构建成Docker镜像,将镜像上传到Harbor私有仓库。
3)Jenkins发送SSH远程命令,让生产部署服务器到Harbor私有仓库拉取镜像到本地,然后创建容器。
4)最后,用户可以访问到容器

服务列表(红色的软件为需要安装的软件,黑色代表已经安装)

服务器名称IP地址安装的软件
代码托管服务器192.168.66.100Gitlab
持续集成服务器192.168.66.101Jenkins,Maven,Docker18.06.1-ce
Docker仓库服务器192.168.66.102Docker18.06.1-ce,Harbor1.9.2
生产部署服务器192.168.66.103Docker18.06.1-ce

4.2 SpringCloud微服务源码概述

项目架构: 前后端分离

后端技术栈: SpringBoot+SpringCloud+SpringDataJpa(Spring全家桶)

微服务项目结构:
在这里插入图片描述

  • tensquare_parent:父工程,存放基础配置
  • tensquare_common:通用工程,存放工具类
  • tensquare_eureka_server:SpringCloud的Eureka注册中心
  • tensquare_zuul:SpringCloud的网关服务
  • tensquare_admin_service:基础权限认证中心,负责用户认证(使用JWT认证)
  • tensquare_gathering:一个简单的业务模块,活动微服务相关逻辑

数据库结构:
在这里插入图片描述

  • tensquare_user:用户认证数据库,存放用户账户数据。对应tensquare_admin_service微服务
  • tensquare_gathering:活动微服务数据库。对应tensquare_gathering微服务

微服务配置分析:

  • tensquare_eureka
  • tensquare_zuul
  • tensquare_admin_service
  • tensquare_gathering

4.3 本地部署

4.3.1 本地部署(1)-SpringCloud微服务部署

本地运行微服务

1)逐一启动微服务
2)使用postman测试功能是否可用

本地部署微服务

1)SpringBoot微服务项目打包

必须导入该插件

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

打包后在target下产生jar包

2)本地运行微服务的jar包

java -jar xxx.jar

3)查看效果

4.3.2 本地部署(1)-前端静态web网站

前端技术栈: NodeJS+VueJS+ElementUI

使用Visual Studio Code打开源码
1)本地运行

npm run dev 

2)打包静态web网站

npm run build

打包后,产生dist目录的静态文件

3)部署到nginx服务器
把dist目录的静态文件拷贝到nginx的html目录,启动nginx

4)启动nginx,并访问
http://localhost:82

4.4 环境准备

4.4.1 环境准备(1)-Docker快速入门

Docker简介
在这里插入图片描述
Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。

容器是完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app),更重要的是容器性能开销极低。

Docker容器技术 vs 传统虚拟机技术
在这里插入图片描述

虚拟机容器
占用磁盘空间非常大,GB级小,MB甚至KB级
启动速度慢,分钟级快,秒级
运行形态运行于Hypervisor上直接运行在宿主机内核上
并发性一台宿主机上十几个,最多几十个上百个,甚至数百上千个
性能逊于宿主机接近宿主机本地进程
资源利用率

简单一句话总结:Docker技术就是让我们更加高效轻松地将任何应用在Linux服务器部署和使用。

Docker安装
1)卸载旧版本

yum list installed | grep docker 列出当前所有docker的包
yum -y remove docker的包名称 卸载docker包
rm -rf /var/lib/docker 删除docker的所有镜像和容器

2)安装必要的软件包

sudo yum install -y yum-utils \ device-mapper-persistent-data \ lvm2

3)设置下载的镜像仓库

sudo yum-config-manager \ --add-repo \ https://download.docker.com/linux/centos/dockerce.repo

4)列出需要安装的版本列表

yum list docker-ce --showduplicates | sort -r

docker-ce.x86_64 3:18.09.1-3.el7 docker-ce-stable 
docker-ce.x86_64 3:18.09.0-3.el7 docker-ce-stable 
docker-ce.x86_64 18.06.1.ce-3.el7 docker-ce-stable 
docker-ce.x86_64 18.06.0.ce-3.el7 docker-ce-stable 
......

5)安装指定版本(这里使用18.0.1版本)

sudo yum install docker-ce-18.06.1.ce

6)查看版本

docker -v

7)启动Docker

sudo systemctl start docker 启动
sudo systemctl enable docker 设置开机启动

8)添加阿里云镜像下载地址

vi /etc/docker/daemon.json

内容如下:

{
	"registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"]
}

9)重启Docker

sudo systemctl restart docker

Docker基本命令快速入门
1)镜像命令
镜像:相当于应用的安装包,在Docker部署的任何应用都需要先构建成为镜像

docker search 镜像名称 搜索镜像
docker pull 镜像名称 拉取镜像
docker images 查看本地所有镜像
docker rmi -f 镜像名称 删除镜像
docker pull openjdk:8-jdk-alpine

2)容器命令
容器:容器是由镜像创建而来。容器是Docker运行应用的载体,每个应用都分别运行在Docker的每个容器中。

docker run -i 镜像名称:标签 运行容器(默认是前台运行)
docker ps 查看运行的容器
docker ps -a 查询所有容器

常用的参数:

-i:运行容器
-d:后台守方式运行(守护式)
–name:给容器添加名称
-p:公开容器端口给当前宿主机
-v:挂载目录

docker exec -it 容器ID/容器名称 /bin/bash 进入容器内部
docker start/stop/restart 容器名称/ID 启动/停止/重启容器
docker rm -f 容器名称/ID 删除容器

4.4.2 环境准备(2)-Dockerfile镜像脚本快速入门

Dockerfile简介

Dockerfile其实就是我们用来构建Docker镜像的源码,当然这不是所谓的编程源码,而是一些命令的组合,只要理解它的逻辑和语法格式,就可以编写Dockerfile了。

简单点说,Dockerfile的作用:它可以让用户个性化定制Docker镜像。因为工作环境中的需求各式各样,网络上的镜像很难满足实际的需求。

Dockerfile常见命令

命令作用
FROM image_name:tag
MAINTAINER user_name声明镜像的作者
ENV key value设置环境变量 (可以写多条)
RUN command编译镜像时运行的脚本(可以写多条)
CMD设置容器的启动命令
ENTRYPOINT设置容器的入口程序
ADD source_dir/file dest_dir/file将宿主机的文件复制到容器内,如果是一个压缩文件,将会在复制后自动解压
COPY source_dir/file dest_dir/file和ADD相似,但是如果有压缩文件并不能解压
WORKDIR path_dir设置工作目录
ARG设置编译镜像时加入的参数
VOLUMN设置容器的挂载卷

镜像构建示意图:
在这里插入图片描述
可以看到,新镜像是从基础镜像一层一层叠加生成的。每安装一个软件,就在现有镜像的基础上增加一层

RUN、CMD、ENTRYPOINT的区别?

  • RUN:用于指定 docker build 过程中要运行的命令,即是创建 Docker 镜像(image)的步骤
  • CMD:设置容器的启动命令, Dockerfile 中只能有一条 CMD 命令,如果写了多条则最后一条生效,CMD不支持接收docker run的参数。
  • ENTRYPOINT:入口程序是容器启动时执行的程序, docker run 中最后的命令将作为参数传递给入口程序 ,ENTRYPOINY类似于 CMD 指令,但可以接收docker run的参数 。

以下是mysql官方镜像的Dockerfile示例:

FROM oraclelinux: 7 - slim 

ARG MYSQL_SERVER_PACKAGE = mysql - community - server - minimal - 5.7.28 
ARG MYSQL_SHELL_PACKAGE = mysql - shell - 8.0.18

# Install server 
RUN yum install -y https://repo.mysql.com/mysql-community-minimal-release- el7.rpm \ 
https://repo.mysql.com/mysql-community-release-el7.rpm \ 
	&& yum-config-manager --enable mysql57-server-minimal \ 
	&& yum install -y \ 
		$MYSQL_SERVER_PACKAGE \ 
		$MYSQL_SHELL_PACKAGE \ 
		libpwquality \ 
	&& yum clean all \ 
	&& mkdir /docker-entrypoint-initdb.d 

VOLUME /var/lib/mysql COPY docker-entrypoint.sh /entrypoint.sh 
COPY healthcheck.sh /healthcheck.sh 
ENTRYPOINT ["/entrypoint.sh"] 
HEALTHCHECK CMD /healthcheck.sh 
EXPOSE 3306 33060 
CMD ["mysqld"]

使用Dockerfile制作微服务镜像

我们利用Dockerfile制作一个Eureka注册中心的镜像

1)上传Eureka的微服务jar包到linux

2)编写Dockerfile

FROM openjdk:8-jdk-alpine 
ARG JAR_FILE 
COPY ${JAR_FILE} app.jar 
EXPOSE 10086 
ENTRYPOINT ["java","-jar","/app.jar"]

3)构建镜像

docker build --build-arg JAR_FILE=tensquare_eureka_server-1.0-SNAPSHOT.jar -t eureka:v1 .

4)查看镜像是否创建成功

docker images

5)创建容器

docker run -i --name=eureka -p 10086:10086 eureka:v1

6)访问容器

http://192.168.66.101:10086

4.4.3 环境准备(3)-Harbor镜像仓库安装及使用

Harbor简介
在这里插入图片描述
Harbor(港口,港湾)是一个用于存储和分发Docker镜像的企业级Registry服务器。
除了Harbor这个私有镜像仓库之外,还有Docker官方提供的Registry。相对Registry,Harbor具有很多优势:

  1. 提供分层传输机制,优化网络传输 Docker镜像是是分层的,而如果每次传输都使用全量文件(所以用FTP的方式并不适合),显然不经济。必须提供识别分层传输的机制,以层的UUID为标识,确定传输的对象。
  2. 提供WEB界面,优化用户体验 只用镜像的名字来进行上传下载显然很不方便,需要有一个用户界面可以支持登陆、搜索功能,包括区分公有、私有镜像。
  3. 支持水平扩展集群 当有用户对镜像的上传下载操作集中在某服务器,需要对相应的访问压力作分解。
  4. 良好的安全机制 企业中的开发团队有很多不同的职位,对于不同的职位人员,分配不同的权限,具有更好的安全性。

Harbor安装

Harbor需要安装在192.168.66.102上面

1)先安装Docker并启动Docker(已完成)
参考之前的安装过程

2)先安装docker-compose

sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker- compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose sudo chmod +x /usr/local/bin/docker-compose

3)给docker-compose添加执行权限

sudo chmod +x /usr/local/bin/docker-compose

4)查看docker-compose是否安装成功

docker-compose -version

5)下载Harbor的压缩包(本课程版本为:v1.9.2)

https://github.com/goharbor/harbor/releases

6)上传压缩包到linux,并解压

tar -xzf harbor-offline-installer-v1.9.2.tgz
mkdir /opt/harbor
mv harbor/* /opt/harbor
cd /opt/harbor

7)修改Harbor的配置

vi harbor.yml

修改hostname和port

hostname: 192.168.66.102
port: 85

8)安装Harbor

./prepare
./install.sh

9)启动Harbor

docker-compose up -d 启动
docker-compose stop 停止
docker-compose restart 重新启动

10)访问Harbor

http://192.168.66.102:85

默认账户密码:admin/Harbor12345
在这里插入图片描述
在Harbor创建用户和项目

1)创建项目

Harbor的项目分为公开和私有的:

公开项目:所有用户都可以访问,通常存放公共的镜像,默认有一个library公开项目。
私有项目:只有授权用户才可以访问,通常存放项目本身的镜像。

我们可以为微服务项目创建一个新的项目:
在这里插入图片描述
在这里插入图片描述
2)创建用户
在这里插入图片描述
在这里插入图片描述
创建的用户为: itcast/Itcast123

3)给私有项目分配用户

进入tensquare项目->成员
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

角色权限说明
访客对于指定项目拥有只读权限
开发人员对于指定项目拥有读写权限
维护人员对于指定项目拥有读写权限,创建 Webhooks
项目管理员除了读写权限,同时拥有用户管理/镜像扫描等管理权限

4)以新用户登录Harbor
在这里插入图片描述
把镜像上传到Harbor

1)给镜像打上标签

docker tag eureka:v1 192.168.66.102:85/tensquare/eureka:v1

2)推送镜像

docker push 192.168.66.102:85/tensquare/eureka:v1

The push refers to repository [192.168.66.102:85/tensquare/eureka] 
Get https://192.168.66.102:85/v2/: http: server gave HTTP response to HTTPS client

这时会出现以上报错,是因为Docker没有把Harbor加入信任列表中

3)把Harbor地址加入到Docker信任列表

vi /etc/docker/daemon.json

{
	"registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"], 
	"insecure-registries": ["192.168.66.102:85"] 
}

需要重启Docker

4)再次执行推送命令,会提示权限不足

denied: requested access to the resource is denied

需要先登录Harbor,再推送镜像

5)登录Harbor

docker login -u 用户名 -p 密码 192.168.66.102:85

WARNING! Using --password via the CLI is insecure. Use --password-stdin. 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json. 
Configure a credential helper to remove this warning. See 
https://docs.docker.com/engine/reference/commandline/login/#credentials-store 
Login Succeeded

在这里插入图片描述
从Harbor下载镜像

需求:在192.168.66.103服务器完成从Harbor下载镜像

1)安装Docker,并启动Docker(已经完成)

2)修改Docker配置

vi /etc/docker/daemon.json

{
	"registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"], 
	"insecure-registries": ["192.168.66.102:85"] 
}

重启docker

3)先登录,再从Harbor下载镜像

docker login -u 用户名 -p 密码 192.168.66.102:85
docker pull 192.168.66.102:85/tensquare/eureka:v1

4.5 微服务持续集成

4.5.1 微服务持续集成(1)-项目代码上传到Gitlab

在IDEA操作即可,参考之前的步骤。包括后台微服务和前端web网站代码
在这里插入图片描述

4.5.2 微服务持续集成(2)-从Gitlab拉取项目源码

1)创建Jenkinsfile文件
在这里插入图片描述

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"

node {
	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_back.git']]])
	}
}

2)拉取Jenkinsfile文件
在这里插入图片描述

4.5.3 微服务持续集成(3)-提交到SonarQube代码审查

1)创建项目,并设置参数

创建tensquare_back项目,添加两个参数
在这里插入图片描述
2)每个项目的根目录下添加sonar-project.properties

# must be unique in a given SonarQube instance 
sonar.projectKey=tensquare_zuul
# this is the name and version displayed in the SonarQube UI. Was mandatory prior to SonarQube 6.1. 
sonar.projectName=tensquare_zuul 
sonar.projectVersion=1.0

# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows. # This property is optional if sonar.modules is set.
sonar.sources=. 
sonar.exclusions=**/test/**,**/target/** 
sonar.java.binaries=. 

sonar.java.source=1.8 
sonar.java.target=1.8 
sonar.java.libraries=**/target/classes/**
# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8

注意:修改sonar.projectKey和sonar.projectName

3)修改Jenkinsfile构建脚本

//gitlab的凭证 def 
git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称 
def tag = "latest"node {
	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_back.git']]])
	}
	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner'withSonarQubeEnv('sonarqube6.7.4') {
			sh """ cd ${project_name} ${scannerHome}/bin/sonar-scanner """
		}
	}
}

4.5.4 微服务持续集成(4)-使用Dockerfile编译、生成镜像

利用dockerfile-maven-plugin插件构建Docker镜像

1)在每个微服务项目的pom.xml加入dockerfile-maven-plugin插件

<plugin> 
	<groupId>com.spotify</groupId> 
	<artifactId>dockerfile-maven-plugin</artifactId> 
	<version>1.3.6</version> 
	<configuration> 
		<repository>${project.artifactId}</repository> 
		<buildArgs> 
			<JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE> 
		</buildArgs> 
	</configuration> 
</plugin>

2)在每个微服务项目根目录下建立Dockerfile文件

#FROM java:8 
FROM openjdk:8-jdk-alpine 
ARG JAR_FILE 
COPY ${JAR_FILE} app.jar 
EXPOSE 10086 
ENTRYPOINT ["java","-jar","/app.jar"]

注意:每个项目公开的端口不一样

3)修改Jenkinsfile构建脚本

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称 
def tag = "latest"
//Harbor私服地址 
def harbor_url = "192.168.66.102:85/tensquare/"

node {
	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_back.git']]])
	}
	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner'withSonarQubeEnv('sonarqube6.7.4') {
			sh """ cd ${project_name} ${scannerHome}/bin/sonar-scanner """
		}
	}
	stage('编译,构建镜像') {
		//定义镜像名称 
		def imageName = "${project_name}:${tag}"
		//编译,安装公共工程
		sh "mvn -f tensquare_common clean install"
		//编译,构建本地镜像 
		sh "mvn -f ${project_name} clean package dockerfile:build"
	}
}

注意:如果出现找不到父工程依赖,需要手动把父工程的依赖上传到仓库中

4.5.5 微服务持续集成(5)-上传到Harbor镜像仓库

1)修改Jenkinsfile构建脚本

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8" 
//构建版本的名称 
def tag = "latest" 
//Harbor私服地址 
def harbor_url = "192.168.66.102:85" 
//Harbor的项目名称 
def harbor_project_name = "tensquare" 
//Harbor的凭证 
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"

node {

	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_back.git']]])
	}
	
	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner'
         withSonarQubeEnv('sonarqube6.7.4') {
			sh """ cd ${project_name} ${scannerHome}/bin/sonar-scanner """
		}
	}
	
	stage('编译,构建镜像') {
		//定义镜像名称 
		def imageName = "${project_name}:${tag}"
		//编译,安装公共工程 
		sh "mvn -f tensquare_common clean install"
		//编译,构建本地镜像 
		sh "mvn -f ${project_name} clean package dockerfile:build"
		//给镜像打标签 
		sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
		//登录Harbor,并上传镜像 
		withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
			//登录 
			sh "docker login -u ${username} -p ${password} ${harbor_url}"
			//上传镜像 
			sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
		}
		//删除本地镜像 
		sh "docker rmi -f ${imageName}"
		sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
	}
}

2)使用凭证管理Harbor私服账户和密码

先在凭证建立Harbor的凭证,在生成凭证脚本代码
在这里插入图片描述

5.5.6 微服务持续集成(6)-拉取镜像和发布应用

在这里插入图片描述
注意:192.168.66.103服务已经安装Docker并启动

安装 Publish Over SSH 插件

安装以下插件,可以实现远程发送Shell命令
在这里插入图片描述
配置远程部署服务器

1)拷贝公钥到远程服务器
ssh-copy-id 192.168.66.103

2)系统配置->添加远程服务器
在这里插入图片描述
修改Jenkinsfile构建脚本

生成远程调用模板代码
在这里插入图片描述添加一个port参数
在这里插入图片描述

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8" 
//构建版本的名称 
def tag = "latest" 
//Harbor私服地址 
def harbor_url = "192.168.66.102:85" 
//Harbor的项目名称 
def harbor_project_name = "tensquare" 
//Harbor的凭证 
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"

node {

	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_back.git']]])
	}
	
	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner'
         withSonarQubeEnv('sonarqube6.7.4') {
			sh """ cd ${project_name} ${scannerHome}/bin/sonar-scanner """
		}
	}
	
	stage('编译,构建镜像,部署服务') {
		//定义镜像名称 
		def imageName = "${project_name}:${tag}"
		//编译,安装公共工程 
		sh "mvn -f tensquare_common clean install"
		//编译,构建本地镜像 
		sh "mvn -f ${project_name} clean package dockerfile:build"
		//给镜像打标签 
		sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
		//登录Harbor,并上传镜像 
		withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
			//登录 
			sh "docker login -u ${username} -p ${password} ${harbor_url}"
			//上传镜像 
			sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
		}
		//删除本地镜像 
		sh "docker rmi -f ${imageName}"
		sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
		//=====以下为远程调用进行项目部署========
		sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', 
		transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deploy.sh $harbor_url $harbor_project_name $project_name $tag $port", 
		execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', 
		remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
	}
}

编写deploy.sh部署脚本

# ! /bin/sh
#接收外部参数
harbor_url = $1 
harbor_project_name = $2 
project_name = $3 
tag = $4 
port = $5 

imageName = $harbor_url / $harbor_project_name / $project_name: $tag 

echo "$imageName"

#查询容器是否存在,存在则删除
containerId = `docker ps - a | grep - w $ {project_name}: $ {tag} | awk'{print $1}'`
if ["$containerId" != ""]; then
	#停掉容器
	docker stop $containerId
	#删除容器
	docker rm $containerId 
	echo "成功删除容器"
fi

#查询镜像是否存在,存在则删除
imageId = `docker images | grep - w $project_name | awk '{print $3}'`
if ["$imageId" != ""]; then
	#删除镜像
	docker rmi - f $imageId 
	echo "成功删除镜像"
fi

#登录Harbor私服
docker login - u itcast - p Itcast123 $harbor_url
#下载镜像
docker pull $imageName
#启动容器
docker run - di - p $port: $port $imageName 
echo "容器启动成功"

上传deploy.sh文件到/opt/jenkins_shell目录下,且文件至少有执行权限!

chmod +x deploy.sh 添加执行权限

导入数据,测试微服务
在这里插入图片描述

5.5.7 微服务持续集成(7)-部署前端静态web网站

在这里插入图片描述安装Nginx服务器

yum install epel-release
yum -y install nginx 安装

修改nginx的端口,默认80,改为9090:

vi /etc/nginx/nginx.conf

server {
	listen 9090 default_server; 
	listen [::]:9090 default_server; 
	server_name _; 
	root /usr/share/nginx/html;

还需要关闭selinux,将SELINUX=disabled

setenforce 0 先临时关闭
vi /etc/selinux/config 编辑文件,永久关闭 SELINUX=disabled

启动Nginx

echo “容器启动成功” server {listen 9090 default_server; listen [::]:9090 default_server; > > server_name _; root /usr/share/nginx/html;
systemctl enable nginx 设置开机启动
systemctl start nginx 启动
systemctl stop nginx 停止
systemctl restart nginx 重启

访问:http://192.168.66.103:9090/
在这里插入图片描述
安装NodeJS插件

在这里插入图片描述
Jenkins配置Nginx服务器

Manage Jenkins->Global Tool Configuration
在这里插入图片描述
创建前端流水线项目
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
建立Jenkinsfile构建脚本

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"

node {

	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], 
		userRemoteConfigs: [[credentialsId: "${git_auth}", url: 'git@192.168.66.100:itheima_group/tensquare_front.git']]])
	}
	
	stage('打包,部署网站') {
		//使用NodeJS的npm进行打包
		nodejs('nodejs12') {
			sh '''
				npm install npm run build 
				'''
		}
		//=====以下为远程调用进行项目部署========
		sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', 
		execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '/usr/share/nginx/html', remoteDirectorySDF: false, removePrefix: 'dist', sourceFiles: 'dist/**')], 
		usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
	}
}

完成后,访问:http://192.168.66.103:9090 进行测试。

5.Jenkins+Docker+SpringCloud微服务持续集成(下)

5.1 Jenkins+Docker+SpringCloud部署方案优化

上面部署方案存在的问题:
1)一次只能选择一个微服务部署
2)只有一台生产者部署服务器
3)每个微服务只有一个实例,容错率低

优化方案:
1)在一个Jenkins工程中可以选择多个微服务同时发布
2)在一个Jenkins工程中可以选择多台生产服务器同时部署
3)每个微服务都是以集群高可用形式部署

5.2 Jenkins+Docker+SpringCloud集群部署流程说明

在这里插入图片描述

5.3 修改所有微服务配置

注册中心配置(*)
在这里插入图片描述
在这里插入图片描述
在启动微服务的时候,加入参数: spring.profiles.active 来读取对应的配置

其他微服务配置

除了Eureka注册中心以外,其他微服务配置都需要加入所有Eureka服务
在这里插入图片描述把代码提交到Gitlab中

5.4 设计Jenkins集群项目的构建参数

1)安装Extended Choice Parameter插件

支持多选框
在这里插入图片描述
2)创建流水线项目
在这里插入图片描述
3)添加参数

字符串参数:分支名称
在这里插入图片描述
多选框:项目名称
在这里插入图片描述
在这里插入图片描述

tensquare_eureka_server@10086,tensquare_zuul@10020,tensquare_admin_service@9001, tensquare_gathering@9002

在这里插入图片描述
在这里插入图片描述最后效果:
在这里插入图片描述

5.5 完成微服务构建镜像,上传私服

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称 
def tag = "latest"
//Harbor私服地址 
def harbor_url = "192.168.66.102:85"
//Harbor的项目名称 
def harbor_project_name = "tensquare"
//Harbor的凭证 
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"

node {
	//把选择的项目信息转为数组 
	def selectedProjects = "${project_name}".split(',')

	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: '${git_auth}', url: 'git@192.168.66.100:itheima_group/tensquare_back_cluster.git']]])
	}

	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner'withSonarQubeEnv('sonarqube6.7.4') {
			for (int i = 0; i < selectedProjects.size(); i++) {
				//取出每个项目的名称和端口 
				def currentProject = selectedProjects[i];
				//项目名称
				def currentProjectName = currentProject.split('@')[0]
				//项目启动端口 
				def currentProjectPort = currentProject.split('@')[1] sh """
cd ${currentProjectName} ${scannerHome}/bin/sonar-scanner 
"""echo "${currentProjectName}完成代码审查"
			}
		}
	}

	stage('编译,构建镜像,部署服务') {
		//编译并安装公共工程
		sh "mvn -f tensquare_common clean install"

		for (int i = 0; i < selectedProjects.size(); i++) {
			//取出每个项目的名称和端口
			def currentProject = selectedProjects[i];
			//项目名称 
			def currentProjectName = currentProject.split('@')[0]
			//项目启动端口
			def currentProjectPort = currentProject.split('@')[1]
			//定义镜像名称 
			def imageName = "${currentProjectName}:${tag}"
			//编译,构建本地镜像
			sh "mvn -f ${currentProjectName} clean package dockerfile:build"
			//给镜像打标签
			sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
			//登录Harbor,并上传镜像 
			withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
				//登录 
				sh "docker login -u ${username} -p ${password} ${harbor_url}"
				//上传镜像
				sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
			}
			//删除本地镜像
			sh "docker rmi -f ${imageName}"
			sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
			//=====以下为远程调用进行项目部署========
			//sshPublisher(publishers: [sshPublisherDesc(configName: 'master_server', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deployCluster.sh $harbor_url $harbor_project_name $currentProjectName $tag $currentProjectPort", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)]) 
			echo "${currentProjectName}完成编译,构建镜像"
		}
	}
}

5.6 完成微服务多服务器远程发布

1)配置远程部署服务器

  • 拷贝公钥到远程服务器

ssh-copy-id 192.168.66.104

  • 系统配置->添加远程服务器
    在这里插入图片描述
    2)修改Docker配置信任Harbor私服地址
{
"registry-mirrors": ["https://zydiol88.mirror.aliyuncs.com"], 
"insecure-registries": ["192.168.66.102:85"] 
}

重启Docker

3)添加参数

多选框:部署服务器
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
最终效果:
在这里插入图片描述
4)修改Jenkinsfile构建脚本

//gitlab的凭证 
def git_auth = "68f2087f-a034-4d39-a9ff-1f776dd3dfa8"
//构建版本的名称 
def tag = "latest"
//Harbor私服地址 
def harbor_url = "192.168.66.102:85"
//Harbor的项目名称 
def harbor_project_name = "tensquare"
//Harbor的凭证 
def harbor_auth = "ef499f29-f138-44dd-975e-ff1ca1d8c933"

node {
	//把选择的项目信息转为数组 
	def selectedProjects = "${project_name}".split(',')
	//把选择的服务区信息转为数组 
	def selectedServers = "${publish_server}".split(',')

	stage('拉取代码') {
		checkout([$class: 'GitSCM', branches: [[name: '*/${branch}']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: '${git_auth}', url: 'git@192.168.66.100:itheima_group/tensquare_back_cluster.git']]])
	}

	stage('代码审查') {
		def scannerHome = tool 'sonarqube-scanner' 
		withSonarQubeEnv('sonarqube6.7.4') { 
			for(int i=0;i<selectedProjects.size();i++){ 
				//取出每个项目的名称和端口 
				def currentProject = selectedProjects[i]; 
				//项目名称 
				def currentProjectName = currentProject.split('@')[0] 
				//项目启动端口 
				def currentProjectPort = currentProject.split('@')[1] 
				sh """
					cd ${currentProjectName} ${scannerHome}/bin/sonar-scanner 
					""" 
				echo "${currentProjectName}完成代码审查" 
			} 
		}
	}

	stage('编译,构建镜像,部署服务') {
		//编译并安装公共工程
		sh "mvn -f tensquare_common clean install"

		for (int i = 0; i < selectedProjects.size(); i++) {
			//取出每个项目的名称和端口
			def currentProject = selectedProjects[i];
			//项目名称 
			def currentProjectName = currentProject.split('@')[0]
			//项目启动端口
			def currentProjectPort = currentProject.split('@')[1]
			//定义镜像名称 
			def imageName = "${currentProjectName}:${tag}"
			//编译,构建本地镜像
			sh "mvn -f ${currentProjectName} clean package dockerfile:build"
			//给镜像打标签
			sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
			//登录Harbor,并上传镜像 
			withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
				//登录 
				sh "docker login -u ${username} -p ${password} ${harbor_url}" 
				//上传镜像 
				sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
			}
			//删除本地镜像
			sh "docker rmi -f ${imageName}"
			sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
			//=====以下为远程调用进行项目部署========
			for(int j=0;j<selectedServers.size();j++){ 
				//每个服务名称 
				def currentServer = selectedServers[j] 
				//添加微服务运行时的参数:spring.profiles.active 
				def activeProfile = "--spring.profiles.active=" 	
				if(currentServer=="master_server"){ 
					activeProfile = activeProfile+"eureka-server1" 
				}else if(currentServer=="slave_server1"){ 
					activeProfile = activeProfile+"eureka-server2" 
				}
				sshPublisher(publishers: [sshPublisherDesc(configName: "${currentServer}", transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/opt/jenkins_shell/deployCluster.sh $harbor_url $harbor_project_name $currentProjectName $tag $currentProjectPort $activeProfile", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)]) 
			}
			echo "${currentProjectName}完成编译,构建镜像"
		}
	}
}

5)编写deployCluster.sh部署脚本

#! /bin/sh
#接收外部参数 
harbor_url=$1 
harbor_project_name=$2 
project_name=$3 
tag=$4 
port=$5 
profile=$6

imageName=$harbor_url/$harbor_project_name/$project_name:$tag
echo "$imageName" 
#查询容器是否存在,存在则删除
containerId=`docker ps -a | grep -w ${project_name}:${tag} | awk '{print $1}'`
if [ "$containerId" != "" ] ; then 
	#停掉容器
	docker stop $containerId 
	#删除容器 
	docker rm $containerId 
	echo "成功删除容器"
fi

#查询镜像是否存在,存在则删除 
imageId=`docker images | grep -w $project_name | awk '{print $3}'`

if [ "$imageId" != "" ] ; then 
	#删除镜像 
	docker rmi -f $imageId 
	echo "成功删除镜像" 
fi

# 登录Harbor私服 
docker login -u itcast -p Itcast123 $harbor_url 
# 下载镜像 
docker pull $imageName 
# 启动容器 
docker run -di -p $port:$port $imageName $profile 
echo "容器启动成功"

6)集群效果

5.7 Nginx+Zuul集群实现高可用网关

在这里插入图片描述
1)安装Nginx(已完成

2)修改Nginx配置

vi /etc/nginx/nginx.conf

内容如下:

upstream zuulServer {
	server 192.168.66.103 : 10020 weight = 1;
	server 192.168.66.104 : 10020 weight = 1;
}

server {
	listen 85 default_server;
	listen[: :] : 85 default_server;
	server_name _;
	root / usr / share / nginx / html;
	
	#Load configuration files for thedefault server block.
	include / etc / nginx /default.d/*.conf;
	
    location / { 
		### 指定服务器负载均衡服务器 
		proxy_pass http://zuulServer/; 
	}
	

3)重启Nginx: systemctl restart nginx

4)修改前端Nginx的访问地址
在这里插入图片描述

6. 基于Kubernetes/K8S构建Jenkins持续集成平台(上)

6.1 Jenkins的Master-Slave分布式构建

什么是Master-Slave分布式构建
在这里插入图片描述Jenkins的Master-Slave分布式构建,就是通过将构建过程分配到从属Slave节点上,从而减轻Master节点的压力,而且可以同时构建多个,有点类似负载均衡的概念。

如何实现Master-Slave分布式构建

1)开启代理程序的TCP端口

Manage Jenkins -> Configure Global Security

在这里插入图片描述
2)新建节点

Manage Jenkins—Manage Nodes—新建节点
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述有两种在Slave节点连接Master节点的方法
在这里插入图片描述
我们选择第二种:

2)安装和配置节点

下载agent.jar,并上传到Slave节点,然后执行页面提示的命令:

java -jar agent.jar -jnlpUrl http://192.168.66.101:8888/computer/slave1/slave- agent.jnlp -secret f2ecbb99e0c81331e8b7a7917a94d478f39cb9763fc6c66d9a9741c61f9ae6d6 -workDir "/root/jenkins"

刷新页面
在这里插入图片描述
3)测试节点是否可用

自由风格和Maven风格的项目:
在这里插入图片描述
流水线风格的项目:

node('slave1') { 
	stage('check out') { 
		checkout([$class: 'GitSCM', branches: [[name: '*/master']], 
		doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], 
		userRemoteConfigs: [[credentialsId: '68f2087f-a034-4d39-a9ff-1f776dd3dfa8', url: 'git@192.168.66.100:itheima_group/tensquare_back_cluster.git']]]) 
	} 
}

6.2 Kubernetes实现Master-Slave分布式构建方案

传统Jenkins的Master-Slave方案的缺陷

  • Master节点发生单点故障时,整个流程都不可用了
  • 每个 Slave节点的配置环境不一样,来完成不同语言的编译打包等操作,但是这些差异化的配置导致管理起来非常不方便,维护起来也是比较费劲
  • 资源分配不均衡,有的 Slave节点要运行的job出现排队等待,而有的Slave节点处于空闲状态
  • 资源浪费,每台 Slave节点可能是实体机或者VM,当Slave节点处于空闲状态时,也不会完全释放掉资源

以上种种问题,我们可以引入Kubernates来解决!

Kubernates简介

Kubernetes(简称,K8S)是Google开源的容器集群管理系统,在Docker技术的基础上,为容器化的应用提供部署运行、资源调度、服务发现和动态伸缩等一系列完整功能,提高了大规模容器集群管理的便捷性。 其主要功能如下:

  • 使用Docker对应用程序包装(package)、实例化(instantiate)、运行(run)。
  • 以集群的方式运行、管理跨机器的容器。
  • 解决Docker跨机器容器之间的通讯问题。
  • Kubernetes的自我修复机制使得容器集群总是运行在用户期望的状态。

Kubernates+Docker+Jenkins持续集成架构图
在这里插入图片描述
在这里插入图片描述
大致工作流程:手动/自动构建 -> Jenkins 调度 K8S API ->动态生成 Jenkins Slave pod -> Slave pod拉取 Git 代码/编译/打包镜像 ->推送到镜像仓库 Harbor -> Slave 工作完成,Pod 自动销毁 ->部署到测试或生产 Kubernetes平台。(完全自动化,无需人工干预)

Kubernates+Docker+Jenkins持续集成方案好处

  • 服务高可用:当 Jenkins Master 出现故障时,Kubernetes 会自动创建一个新的 Jenkins Master容器,并且将 Volume 分配给新创建的容器,保证数据不丢失,从而达到集群服务高可用。
  • 动态伸缩,合理使用资源:每次运行 Job 时,会自动创建一个 Jenkins Slave,Job 完成后,Slave自动注销并删除容器,资源自动释放,而且 Kubernetes 会根据每个资源的使用情况,动态分配Slave 到空闲的节点上创建,降低出现因某节点资源利用率高,还排队等待在该节点的情况。
  • 扩展性好:当 Kubernetes 集群的资源严重不足而导致 Job 排队等待时,可以很容易的添加一个Kubernetes Node 到集群中,从而实现扩展。

6.3 Kubeadm安装Kubernetes

Kubernetes的架构
在这里插入图片描述

  • API Server:用于暴露Kubernetes API,任何资源的请求的调用操作都是通过kube-apiserver提供的接口进行的。
  • Etcd:是Kubernetes提供默认的存储系统,保存所有集群数据,使用时需要为etcd数据提供备份计划。
  • Controller-Manager:作为集群内部的管理控制中心,负责集群内的Node、Pod副本、服务端点(Endpoint)、命名空间(Namespace)、服务账号(ServiceAccount)、资源定额
    (ResourceQuota)的管理,当某个Node意外宕机时,Controller Manager会及时发现并执行自动化修复流程,确保集群始终处于预期的工作状态。
  • Scheduler:监视新创建没有分配到Node的Pod,为Pod选择一个Node。
  • Kubelet:负责维护容器的生命周期,同时负责Volume和网络的管理
  • Kube proxy:是Kubernetes的核心组件,部署在每个Node节点上,它是实现Kubernetes Service的通信与负载均衡机制的重要组件。

安装环境说明

主机名称IP地址安装的软件
代码托管服务器192.168.66.100Gitlab-12.4.2
Docker仓库服务器192.168.66.102Harbor1.9.2
k8s-master192.168.66.101kube-apiserver、kube-controller-manager、kubescheduler、docker、etcd、calico,NFS
k8s-node1192.168.66.103kubelet、kubeproxy、Docker18.06.1-ce
k8s-node2192.168.66.104kubelet、kubeproxy、Docker18.06.1-ce

三台机器都需要完成

修改三台机器的hostname及hosts文件

hostnamectl set-hostname k8s-master
hostnamectl set-hostname k8s-node1 hostnamectl set-hostname k8s-node2

cat >>/etc/hosts<<EOF 192.168.66.101 k8s-master 192.168.66.103 k8s-node1
192.168.66.104 k8s-node2 EOF

关闭防火墙和关闭SELinux

systemctl stop firewalld
systemctl disable firewalld
setenforce 0 临时关闭
vi /etc/sysconfig/selinux 永久关闭

改为SELINUX=disabled

设置系统参数

设置允许路由转发,不对bridge的数据进行处理

创建文件

vi /etc/sysctl.d/k8s.conf
内容如下:
net.bridge.bridge-nf-call-ip6tables = 1 net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1 vm.swappiness = 0

执行文件

sysctl -p /etc/sysctl.d/k8s.conf

kube-proxy开启ipvs的前置条件

cat > /etc/sysconfig/modules/ipvs.modules <<EOF #!/bin/bash
modprobe – ip_vs
modprobe – ip_vs_rr
modprobe – ip_vs_wrr
modprobe – ip_vs_sh
modprobe – nf_conntrack_ipv4
EOF
chmod 755 /etc/sysconfig/modules/ipvs.modules && bash /etc/sysconfig/modules/ipvs.modules && lsmod | grep -e ip_vs -e nf_conntrack_ipv4

所有节点关闭swap

swapoff -a 临时关闭
vi /etc/fstab 永久关闭
注释掉以下字段
/dev/mapper/cl-swap swap swap defaults 0 0

安装kubelet、kubeadm、kubectl

  • kubeadm: 用来初始化集群的指令。
  • kubelet: 在集群中的每个节点上用来启动 pod 和 container 等。
  • kubectl: 用来与集群通信的命令行工具。

清空yum缓存

yum clean all

设置yum安装源

cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg EOF

安装:

yum install -y kubelet kubeadm kubectl

kubelet设置开机启动(注意:先不启动,现在启动的话会报错)

systemctl enable kubelet

查看版本

kubelet --version

安装的是最新版本:Kubernetes v1.16.3(可能会变化)

Master节点需要完成

1)运行初始化命令

kubeadm init --kubernetes-version=1.17.0 \
–apiserver-advertise-address=192.168.66.101 \
–image-repository registry.aliyuncs.com/google_containers \
–service-cidr=10.1.0.0/16 \
–pod-network-cidr=10.244.0.0/16\

注意:apiserver-advertise-address这个地址必须是master机器的IP
常用错误
错误一:[WARNING IsDockerSystemdCheck]: detected “cgroupfs” as the Docker cgroup driver作为Docker cgroup驱动程序。,Kubernetes推荐的Docker驱动程序是“systemd”
解决方案:修改Docker的配置: vi /etc/docker/daemon.json,加入

{
	"exec-opts":["native.cgroupdriver=systemd"] 
}

然后重启Docker

错误二:[ERROR NumCPU]: the number of available CPUs 1 is less than the required 2
解决方案:修改虚拟机的CPU的个数,至少为2个
在这里插入图片描述
安装过程日志:
在这里插入图片描述
最后,会提示节点安装的命令,必须记下来

kubeadm join 192.168.66.101:6443 --token 754snw.9xq9cotze1ybwnti \ --discovery-token-ca-cert-hash 
sha256:3372ff6717ea5997121213e2c9d63fa7c8cdfb031527e17f2e20254f382ea03a

2)启动kubelet

systemctl restart kubelet

在这里插入图片描述
3)配置kubectl工具

mkdir -p $HOME/.kube 
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config 
sudo chown $(id -u):$(id -g) $HOME/.kube/config

4)安装Calico

mkdir k8s 
cd k8s 
wget https://docs.projectcalico.org/v3.10/getting- started/kubernetes/installation/hosted/kubernetes-datastore/calico- networking/1.7/calico.yaml 

sed -i 's/192.168.0.0/10.244.0.0/g' calico.yaml 
kubectl apply -f calico.yaml

5)等待几分钟,查看所有Pod的状态,确保所有Pod都是Running状态

kubectl get pod --all-namespaces -o wide

在这里插入图片描述
Slave节点需要完成

1)让所有节点让集群环境

使用之前Master节点产生的命令加入集群

kubeadm join 192.168.66.101:6443 --token 754snw.9xq9cotze1ybwnti \ --discovery-token-ca-cert-hash 
sha256:3372ff6717ea5997121213e2c9d63fa7c8cdfb031527e17f2e20254f382ea03a

2)启动kubelet

systemctl start kubelet

在这里插入图片描述
3)回到Master节点查看,如果Status全部为Ready,代表集群环境搭建成功!!!

kubectl get nodes

在这里插入图片描述
kubectl常用命令

kubectl get nodes 查看所有主从节点的状态
kubectl get ns 获取所有namespace资源 
kubectl get pods -n {$nameSpace} 获取指定namespace的pod 
kubectl describe pod的名称 -n {$nameSpace} 查看某个pod的执行过程 
kubectl logs --tail=1000 pod的名称 | less 查看日志 
kubectl create -f xxx.yml 通过配置文件创建一个集群资源对象 
kubectl delete -f xxx.yml 通过配置文件删除一个集群资源对象 
kubectl delete pod名称 -n {$nameSpace} 通过pod删除集群资源 
kubectl get service -n {$nameSpace} 查看pod的service情况

7. 基于Kubernetes/K8S构建Jenkins持续集成平台(下)

Jenkins-Master-Slave架构图回顾:
在这里插入图片描述

7.1 安装和配置NFS

NFS简介

NFS(Network File System),它最大的功能就是可以通过网络,让不同的机器、不同的操作系统可以共享彼此的文件。我们可以利用NFS共享Jenkins运行的配置文件、Maven的仓库依赖文件等

NFS安装

我们把NFS服务器安装在192.168.66.101机器上

1)安装NFS服务(在所有K8S的节点都需要安装)

yum install -y nfs-utils

2)创建共享目录

mkdir -p /opt/nfs/jenkins
vi /etc/exports 编写NFS的共享配置
内容如下: /opt/nfs/jenkins *(rw,no_root_squash) *代表对所有IP都开放此目录,rw是读写

3)启动服务

systemctl enable nfs 开机启动 systemctl start nfs 启动

4)查看NFS共享目录

showmount -e 192.168.66.101

7.2 在Kubernetes安装Jenkins-Master

创建NFS client provisioner

nfs-client-provisioner 是一个Kubernetes的简易NFS的外部provisioner,本身不提供NFS,需要现有的NFS服务器提供存储。

1)上传nfs-client-provisioner构建文件
在这里插入图片描述
其中注意修改deployment.yaml,使用之前配置NFS服务器和目录
在这里插入图片描述
2)构建nfs-client-provisioner的pod资源

cd nfs-client 
kubectl create -f .

3)查看pod是否创建成功
在这里插入图片描述
安装Jenkins-Master

1)上传Jenkins-Master构建文件
在这里插入图片描述
其中有两点注意:

第一、在StatefulSet.yaml文件,声明了利用nfs-client-provisioner进行Jenkins-Master文件存储
在这里插入图片描述
第二、Service发布方法采用NodePort,会随机产生节点访问端口
在这里插入图片描述
2)创建kube-ops的namespace

因为我们把Jenkins-Master的pod放到kube-ops下

kubectl create namespace kube-ops

3)构建Jenkins-Master的pod资源

cd jenkins-master 
kubectl create -f .

4)查看pod是否创建成功

kubectl get pods -n kube-ops

5)查看信息,并访问

查看Pod运行在那个Node上

kubectl describe pods -n kube-ops

在这里插入图片描述
查看分配的端口

kubectl get service -n kube-ops

在这里插入图片描述
最终访问地址为:http://192.168.66.103:30136 (192.168.66.103为k8s-node1的IP)
在这里插入图片描述
安装过程跟之前是一样的!

6)先安装基本的插件

  • Localization:Chinese
  • Git
  • Pipeline
  • Extended Choice Parameter

7.3 Jenkins与Kubernetes整合

安装Kubernetes插件

系统管理->插件管理->可选插件
在这里插入图片描述实现Jenkins与Kubernetes整合

系统管理->系统配置->云->新建云->Kubernetes
在这里插入图片描述

  • kubernetes地址采用了kube的服务器发现:https://kubernetes.default.svc.cluster.local
  • namespace填kube-ops,然后点击Test Connection,如果出现 Connection test successful 的提示信息证明 Jenkins 已经可以和 Kubernetes 系统正常通信
  • Jenkins URL 地址:http://jenkins.kube-ops.svc.cluster.local:8080

7.4 构建Jenkins-Slave自定义镜像

Jenkins-Master在构建Job的时候,Kubernetes会创建Jenkins-Slave的Pod来完成Job的构建。我们选择运行Jenkins-Slave的镜像为官方推荐镜像:jenkins/jnlp-slave:latest,但是这个镜像里面并没有Maven环境,为了方便使用,我们需要自定义一个新的镜像:

准备材料:
在这里插入图片描述
Dockerfile文件内容如下:

FROM jenkins/jnlp-slave:latest 

MAINTAINER itcast 

# 切换到 root 账户进行操作 
USER root 

# 安装 maven 
COPY apache-maven-3.6.2-bin.tar.gz . 
RUN tar -zxf apache-maven-3.6.2-bin.tar.gz && \ 
	mv apache-maven-3.6.2 /usr/local && \ 
	rm -f apache-maven-3.6.2-bin.tar.gz && \ 
	ln -s /usr/local/apache-maven-3.6.2/bin/mvn /usr/bin/mvn && \
	ln -s /usr/local/apache-maven-3.6.2 /usr/local/apache-maven && \ 
	mkdir -p /usr/local/apache-maven/repo 
COPY settings.xml /usr/local/apache-maven/conf/settings.xml 
USER jenkins

构建出一个新镜像:jenkins-slave-maven:latest
然把镜像上传到Harbor的公共库library中

docker tag jenkins-slave-maven:latest 192.168.66.102:85/library/jenkins-slave- maven:latest 
docker push 192.168.66.102:85/library/jenkins-slave-maven:latest

7.5 测试Jenkins-Slave是否可以创建

1)创建一个Jenkins流水线项目
在这里插入图片描述2)编写Pipeline,从GItlab拉取代码

def git_address = "http://192.168.66.100:82/itheima_group/tensquare_back_cluster.git" 
def git_auth = "9d9a2707-eab7-4dc9-b106-e52f329cbc95" 

//创建一个Pod的模板,label为jenkins-slave 
podTemplate(label: 'jenkins-slave', cloud: 'kubernetes', containers: [ 
		containerTemplate( 
			name: 'jnlp', 
			image: "192.168.66.102:85/library/jenkins-slave-maven:latest" 
		) 
	] 
)

{ 
	//引用jenkins-slave的pod模块来构建Jenkins-Slave的pod 
	node("jenkins-slave"){ 
	// 第一步 
		stage('拉取代码'){ 
			checkout([$class: 'GitSCM', branches: [[name: 'master']], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]]) 
		} 
	}
}

3)查看构建日志
在这里插入图片描述

7.6 Jenkins+Kubernetes+Docker完成微服务持续集成

拉取代码,构建镜像

1)创建NFS共享目录
让所有Jenkins-Slave构建指向NFS的Maven的共享仓库目录

vi /etc/exports
添加内容:
/opt/nfs/jenkins *(rw,no_root_squash)
/opt/nfs/maven *(rw,no_root_squash)
systemctl restart nfs 重启NFS

2)创建项目,编写构建Pipeline

def git_address = "http://192.168.66.100:82/itheima_group/tensquare_back_cluster.git" 
def git_auth = "9d9a2707-eab7-4dc9-b106-e52f329cbc95" 
//构建版本的名称 
def tag = "latest" 
//Harbor私服地址 
def harbor_url = "192.168.66.102:85" 
//Harbor的项目名称 
def harbor_project_name = "tensquare" 
//Harbor的凭证 
def harbor_auth = "71eff071-ec17-4219-bae1-5d0093e3d060"

podTemplate(label: 'jenkins-slave', cloud: 'kubernetes', containers: [ 
		containerTemplate( 
			name: 'jnlp', 
			image: "192.168.66.102:85/library/jenkins-slave-maven:latest" 
		),
		containerTemplate( 
			name: 'docker', 
			image: "docker:stable", 
			ttyEnabled: true, 
			command: 'cat' 
		), 
	],
	volumes: [ 
		hostPathVolume(mountPath: '/var/run/docker.sock', 
		hostPath: '/var/run/docker.sock'), 
		nfsVolume(mountPath: '/usr/local/apache-maven/repo', serverAddress: '192.168.66.101' , serverPath: '/opt/nfs/maven'), 
	], 
)

{
	node("jenkins-slave") {
		// 第一步 
		stage('拉取代码') {
			checkout([$class: 'GitSCM', branches: [[name: '${branch}']], userRemoteConfigs: [[credentialsId: "${git_auth}", url: "${git_address}"]]])
		}
		// 第二步 
		stage('代码编译') {
			//编译并安装公共工程 
			sh "mvn -f tensquare_common clean install"
		}
		// 第三步
		stage('构建镜像,部署项目') {
			//把选择的项目信息转为数组 
			def selectedProjects = "${project_name}".split(',') for (int i = 0; i < selectedProjects.size(); i++) {
				//取出每个项目的名称和端口 
				def currentProject = selectedProjects[i];
				//项目名称 
				def currentProjectName = currentProject.split('@')[0]
				//项目启动端口
				def currentProjectPort = currentProject.split('@')[1]
				//定义镜像名称
				def imageName = "${currentProjectName}:${tag}"
				//编译,构建本地镜像 
				sh "mvn -f ${currentProjectName} clean package dockerfile:build"container('docker') {
					//给镜像打标签
					sh "docker tag ${imageName} ${harbor_url}/${harbor_project_name}/${imageName}"
					//登录Harbor,并上传镜像 
					withCredentials([usernamePassword(credentialsId: "${harbor_auth}", passwordVariable: 'password', usernameVariable: 'username')]) {
						//登录 
						sh "docker login -u ${username} -p ${password} ${harbor_url}"
						//上传镜像 
						sh "docker push ${harbor_url}/${harbor_project_name}/${imageName}"
					}
					//删除本地镜像
					sh "docker rmi -f ${imageName}"sh "docker rmi -f ${harbor_url}/${harbor_project_name}/${imageName}"
				}
			}
		}
	}
}

注意:在构建过程会发现无法创建仓库目录,是因为NFS共享目录权限不足,需更改权限

chown -R jenkins:jenkins /opt/nfs/maven 
chmod -R 777 /opt/nfs/maven

还有Docker命令执行权限问题

chmod 777 /var/run/docker.sock

需要手动上传父工程依赖到NFS的Maven共享仓库目录中
在这里插入图片描述
微服务部署到K8S

修改每个微服务的application.yml

Eureka
在这里插入图片描述其他微服务需要注册到所有Eureka中
在这里插入图片描述
1)安装Kubernetes Continuous Deploy插件
在这里插入图片描述
2)修改后的流水线脚本

def deploy_image_name = "${harbor_url}/${harbor_project_name}/${imageName}" 
//部署到K8S 
sh """ 
	sed -i 's#\$IMAGE_NAME#${deploy_image_name}#' ${currentProjectName}/deploy.yml 
	sed -i 's#\$SECRET_NAME#${secret_name}#' ${currentProjectName}/deploy.yml 
""" 

kubernetesDeploy configs: "${currentProjectName}/deploy.yml", 
kubeconfigId: "${k8s_auth}"

3)建立k8s认证凭证
在这里插入图片描述
kubeconfig到k8s的Master节点复制

cat /root/.kube/config

5)生成Docker凭证

Docker凭证,用于Kubernetes到Docker私服拉取镜像

docker login -u itcast -p Itcast123 192.168.66.102:85 登录Harbor 

kubectl create secret docker-registry registry-auth-secret --docker- 
server=192.168.66.102:85 --docker-username=itcast --docker-password=Itcast123 -- 
docker-email=itcast@itcast.cn 生成 

kubectl get secret 查看密钥

6)在每个项目下建立deploy.xml

Eureka的deply.yml
在这里插入图片描述
其他项目的deploy.yml主要把名字和端口修改:
在这里插入图片描述
7)项目构建后,查看服务创建情况

kubectl get pods -owide 
kubectl get service

效果如下:
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值