SpringCloud--20CICD和DevOps

1.CICD

1）Continuous integration（CI）

持续集成是一种软件开发实践，即团队开发成员经常集成他们的工作，通常每个成员至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，从而尽快地发现集成错误。许多团队发现这个过程可以大大减少集成的问题，让团队能够更快的开发内聚的软件。

  
  CD：持续部署

DevOps:更好的去优化，开发，测试流程，使其高度一体化

2.体验CICD

 各公司的cicd落地技术不一样，我们这里使用git+jenkins+k8s

 Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能，Jenkins只是一个平台，真正运作的都是插件。这就是jenkins流行的原因，因为jenkins什么插件都有 Hudson是Jenkins的前身，是基于Java开发的一种持续集成工具，用于监控程序重复的工作，Hudson后来被收购，成为商业版。后来创始人又写了一个jenkins，jenkins在功能上远远超过hudson。

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

Jenkins下载：http://updates.jenkins-ci.org/

 jenkins的全部镜像：http://mirrors.jenkins-ci.org/status.html

持续集成的流程：

 先把GitLab装起来

 安装教程参考这里：https://github.com/liuyi01/imooc-docs/blob/master/gitlab-install.md

 一、下载镜像

docker pull registry.cn-hangzhou.aliyuncs.com/imooc/gitlab-ce:latest

二、运行GitLab容器

       使用docker命令运行容器，注意修改hostname为自己喜欢的名字，-v部分挂载目录要修改为自己的目录。
端口映射这里使用的都是安全端口，如果大家的环境没有端口限制或冲突可以使用与容器同端口，如：-p 443:443 -p 80:80 -p 22:22

   1. 生成启动文件 - start.sh

#!/bin/bash
HOST_NAME=gitlab.haojing.com
GITLAB_DIR=/root
docker stop gitlab
docker rm gitlab
docker run -d \
    --privileged=true \
    --hostname ${HOST_NAME} \
    -p 8443:443 -p 8080:80 -p 2222:22 \
    --name gitlab \
    -v ${GITLAB_DIR}/config:/etc/gitlab \
    -v ${GITLAB_DIR}/logs:/var/log/gitlab \
    -v ${GITLAB_DIR}/data:/var/opt/gitlab \
    registry.cn-hangzhou.aliyuncs.com/imooc/gitlab-ce:latest

  修改配置:配置gitlab的域名,端口等等

  

  ok，然后启动

sh start.sh

 

3. 配置环境

• 修改host文件，使域名可以正常解析

127.0.0.1 gitlab.haojing.com

• 修改ssh端口（如果主机端口使用的不是22端口）

修改文件：${GITLAB_DIR}/config/gitlab.rb 找到这一行：# gitlab_rails['gitlab_shell_ssh_port'] = 22 把22修改为你的宿主机端口（这里是2222）。然后将注释去掉。

• 重新启动容器

$ sh start.sh

 

 三、GitLab试用

1. 打开首页

地址：http://gitlab.haojing.com:8080/

ok，如果返回502就多等一会儿，容器还没起来。

ok输入一个密码后再注册一个普通的用户,用户名为邮箱，用户密码为手机号

4. 创建项目

注册成功后会跳到首页，我们创建一个项目，名字大家随意

5. 添加ssh key

项目建好了，我们加一个ssh key，以后本地pull/push就简单啦

创建key,

#如果上一步没有这个文件 我们就创建一个，运行下面命令（邮箱改成自己的哦），一路回车就好了
ssh-keygen -t rsa -C "xxxxx@qq.com"

查看; cd ~/.ssh

然后添加：

然后创建项目

将代码推上去就可以了

 

 

3.安装jenkins

 

在这里我安装到了安装了kubectl命令的那台机器上面，目的方便k8s调用，还需要git,mvn，java的环境。

下载jenkins

http://mirrors.jenkins.io/war-stable/latest/jenkins.war

  运行jar:

运行命令 这里不能用8080,改成8888
 java -jar jenkins.war --httpPort=8888.

 运行过程中会把密码打印出来：

 

51707d2a10184b508dda0bf4a1c5a316

 访问：http://192.168.237.137:8888,然后输入密码

选择选择插件来安装

把这个的插件都选上，然后就可以点击安装了

 

安装好后创建用户，插件安装失败处理方法：https://blog.csdn.net/KingBoyWorld/article/details/77923615

然后创建一个新任务，选择流水线，构建

显示蓝色 则jenkins环境ok.

环境好了以后下面串起整个CICD

这个时候我们选择一个持续集成的服务，就选择 user-service吧，然后在Jenkins里面创建一个任务，然后选择一个流水线

然后选择构建触发器，触发远程构建，token随便写一个简单的123456，主要是拿到这个url放到gitlab的持续集成里面去

拿到它的url，放到gitlab的持续集成里面

然后就添加webhook

添加成功

接下来配置jenkins,去掉勾

 

ok，然后回到gitlab，测试webhook

返回这个表示成功

jenkins也显示蓝色成功

这个时候从gitlab通过webhook调用jenkins就是成功了的。然后接下来的一步就是要通过jenkins去调maven的构建，需要编写groov脚本,写一步测一步

 

然后配置host 解析 配置 git的ssh,测试脚本点击立即构建

下一个阶段就是执行maven命令，继续写脚本，编译user-service模块和其依赖的模块

#!groovy
pipeline {
    agent any
    environment{
     repository="ssh://git@gitlab.haojing.com:2222/Andy/haojing.git"
     module="user-service"
    }
    stages {
        stage('获取代码') {
            steps {
                echo "start fetch code from git:${repository}"
                deleteDir()
                git "${repository}"
            }
        }
         stage('编译+单元测试') {
            steps {
                echo "start compile"
                sh "mvn -U -pl ${module} -am clean package"
            }
        }
    }
}

   

  构建成功。
  然后是代码静态检查，这里就直接跳过了，不做了，下一个阶段就是构建镜像了

  构建脚本

 

#!groovy
pipeline {
    agent any
    environment{
     repository="ssh://git@gitlab.haojing.com:2222/Andy/haojing.git"
     module="user-service"
     secript_path="/home/scripts"
    }
    stages {
        stage('获取代码') {
            steps {
                echo "start fetch code from git:${repository}"
                deleteDir()
                git "${repository}"
            }
        }
        stage('代码检查') {
            steps {
                echo "start checkout code"
            }
        }
         stage('编译+单元测试') {
            steps {
                echo "start compile"
                sh "mvn -U -pl ${module} -am clean package"
            }
        }
         stage('构建镜像') {
            steps {
                echo "start build images"
                sh "${secript_path}/build-images.sh ${module}"
            }
        }
    }
}

 脚本种执行的shell文件

#!/bin/bash
MODULE=$1
TIME=$(date "+%Y%m%d%M%H%M")
GIT_REVERSION=$(git log -1 --pretty=format:"%h")

IMAGE_NAME=hub.haojing.com/haojing/${MODULE}:${TIME}_${GIT_REVERSION}
cd ${MODULE}
pwd
echo ${MODULE}
echo ${IMAGE_NAME}
docker build -t ${IMAGE_NAME} .

cd -

docker push ${IMAGE_NAME}

 

 

 然后构建和推送镜像已经完成，接下来就是要更新服务了，即发布系统了，发布系统就是要更新镜像。那么镜像的名字就要在上一个步骤中生成了之后保存起来

 

然后编写发布系统的脚本

#!/bin/bash
IMAGE='cat IMAGE_NAME'
DEPLOYMENT=$1
MODULE=$2
echo IMAGE
kubectl set deployments/${DEPLOYMENT} ${MODULE}=${IMAGE}

编写流水线：

#!groovy
pipeline {
    agent any
    environment{
     repository="ssh://git@gitlab.haojing.com:2222/Andy/haojing.git"
     module="user-service"
     secript_path="/home/scripts"
    }
    stages {
        stage('获取代码') {
            steps {
                echo "start fetch code from git:${repository}"
                deleteDir()
                git "${repository}"
            }
        }
        stage('代码检查') {
            steps {
                echo "start checkout code"
            }
        }
         stage('编译+单元测试') {
            steps {
                echo "start compile"
                sh "mvn -U -pl ${module} -am clean package"
            }
        }
         stage('构建镜像') {
            steps {
                echo "start build images"
                sh "${secript_path}/build-images.sh ${module}"
            }
        }
         stage('发布系统') {
            steps {
                echo "start deploy"
                sh "${secript_path}/deploy.sh user-service-deployment ${module}"
            }
        }
    }
}

 然后查看是否更新成功：

kubectl get deploy

kubectl get pods