带你轻松玩转DevOps

已于 2024-07-18 09:46:59 修改
阅读量654 收藏 24
点赞数 11
分类专栏： 云原生 文章标签： devops 云原生 kubernetes docker k8s maven gitlab
于 2024-07-17 17:43:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010589700/article/details/140500861
版权

一、DevOps详细介绍

软件开发最开始是由两个团队组成：

  • 开发计划由**开发团队**从头开始设计和整体系统的构建。需要系统不停的迭代更新。
  • **运维团队**将开发团队的Code进行测试后部署上线。希望系统稳定安全运行。

这两个看似目标不同的团队，需要协同完成一个软件的开发。在开发团队制定好计划并完成coding后，需要提供到运维团队。运维团队向开发团队反馈需要修复的BUG以及一些需要返工的任务。这时开发团队需要经常等待运维团队的反馈。这无疑延长了事件并推迟了整个软件开发的周期。会有一种方式，在开发团队等待的时候，让开发团队转移到下一个项目中。等待运维团队为之前的代码提供反馈。可是这样就意味着一个完整的项目需要一个更长的周期才可以开发出最终代码。基于现在的互联网现状，更推崇敏捷式开发，这样就导致项目的迭代速度更快，但是由于开发团队与运维团队的沟通问题，会导致新版本上线的时间成本很高。这又违背的敏捷式开发的最初的目的。那么如何让开发团队和运维团队整合成一个团队，协同应对一套软件的整个生命周期呢？这就被称为**DevOps**。

DevOps 全称是 Development & Operations 的缩写，也就是 开发 & 运维。

虽然字面意思只涉及到了开发团队和运维团队，其实QA测试团队也是参与其中的。网上可以查看到 DevOps 的符号类似于一个无穷大的符号

69c100870de0483ca3bf60d41de1ed45

这表明 DevOps 是一个不断提高效率并且持续不断工作的过程，DevOps 的方式可以让开发快速交付，部署也更加稳定，从而使公司能够更快地应对业务市场的发展变化。其核心就在于 简化Dev和Ops团队之间的流程，使整体软件开发过程更快速。

通常情况下，整体的软件开发流程包括：

  • PLAN：开发团队根据客户的目标制定开发计划
  • CODE：根据PLAN开始编码过程，需要将不同版本的代码存储在一个库中。
  • BUILD：编码完成后，需要将代码构建并且运行。
  • TEST：成功构建项目后，需要测试代码是否存在BUG或错误。
  • DEPLOY：代码经过手动测试和自动化测试后，认定代码已经准备好部署并且交给运维团队。
  • OPERATE：运维团队将代码部署到生产环境中。
  • MONITOR：项目部署上线后，需要持续的监控产品。
  • INTEGRATE：然后将监控阶段收到的反馈发送回PLAN阶段，整体反复的流程就是 DevOps 的核心，即持续集成、持续部署。

为了保证整体流程可以高效的完成，各个阶段都有比较常见的工具，如下图：

4c4064505ab2431c9953fb5f92969911

最终可以给 DevOps 下一个定义：DevOps 强调的是高效组织团队之间如何通过自动化的工具协作和沟通来完成软件的生命周期管理，从而更快、更频繁地交付更稳定的软件。

二、Code阶段工具

在code阶段，我们需要将不同版本的代码存储到一个仓库中，常见的版本控制工具就是SVN或者Git，这里我们采用Git作为版本控制工具，GitLab作为远程仓库。

2.1 Git安装

Git客户端安装

2.2 GitLab安装

单独准备服务器，采用Docker安装

  • 查看GitLab镜像

    $ docker search gitlab

  • 拉取GitLab镜像

    $ docker pull gitlab/gitlab-ce

  • 准备docker-compose.yml文件

    #version: '3.1'
services:
  gitlab:
    image: 'gitlab/gitlab-ce:latest'
    container_name: gitlab
    restart: always
#    hostname: 'gitlab.xfq.com'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://192.168.1.211:8929'
        gitlab_rails['gitlab_shell_ssh_port'] = 2224
    ports:
        - '8929:8929'
        - '2224:22'
    volumes:
        - '/home/docker/data/gitlab/config:/etc/gitlab'
        - '/home/docker/data/gitlab/logs:/var/log/gitlab'
        - '/home/docker/data/gitlab/data:/var/opt/gitlab'
    shm_size: '256m'

  • 启动容器（需要稍等一小会……）

    $ docker-compose up -d

  • 访问GitLab首页

    image-20240712142336948

  • 查看root用户初始密码

    $ docker exec -it gitlab cat /etc/gitlab/initial_root_password
 # WARNING: This value is valid only in the following conditions
 
 #          1. If provided manually (either via `GITLAB_ROOT_PASSWORD` environment variable or via `gitlab_rails['initial_root_password']` setting in `gitlab.rb`, it was provided before database was seeded for the first time (usually, the first reconfigure run).
 
 #          2. Password hasn't been changed manually, either via UI or via command line.
 
 
 
 #          If the password shown here doesn't work, you must reset the admin password following https://docs.gitlab.com/ee/security/reset_user_password.html#reset-your-root-password.
 
 Password: EqDVVNwlltKdmu+fkOYF0KPhR/HF8g172itE2z7DNRA=
 
 # NOTE: This file will be automatically deleted in the first reconfigure run after 24 hours.

  • 登录root用户成功后跳转页面

    image-20240712141444436

  • 第一次登录后需要修改密码

    image-20240712141351500

    上面的操作成功后，就可以如同Gitee、GitHub一样使用了。

三、Build阶段工具

构建Java项目的工具一般有两种选择，一个是Maven，一个是Gradle。这里我们选择Maven作为项目的编译工具。Maven的安装非常简单，这里不再赘述，自行配置好Maven私服和本地仓库即可。

四、Operate阶段工具

部署过程，会采用Docker进行部署，暂时只安装Docker即可，后续还需安装Kubernetes

4.1 Docker安装

  • 下载Docker依赖组件

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

  • 设置下载Docker的镜像源为阿里云

    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

  • 安装Docker服务

    yum -y install docker-ce

  • 安装成功后，启动Docker并设置开机自启

    # 设置Docker开机自动启动,并立即启动docker服务
systemctl enable docker --now

  • 测试安装成功

    $ docker version
Client: Docker Engine - Community
 Version:           26.1.4
 API version:       1.45
 Go version:        go1.21.11
 Git commit:        5650f9b
 Built:             Wed Jun  5 11:32:04 2024
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          26.1.4
  API version:      1.45 (minimum version 1.24)
  Go version:       go1.21.11
  Git commit:       de5c9cf
  Built:            Wed Jun  5 11:31:02 2024
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.33
  GitCommit:        d2d58213f83a351ca8f528a95fbd145f5654e957
 runc:
  Version:          1.1.12
  GitCommit:        v1.1.12-0-g51d5e94
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

4.2 Docker-Compose安装

  • 下载Docker/Compose

  • 将下载好的docker-compose-Linux-x86_64文件移动到Linux操作系统安装目录下

  • 设置docker-compose-Linux-x86_64文件权限，并移动到$PATH目录中

    # 设置文件权限
chmod a+x docker-compose-Linux-x86_64
# 移动到/usr/bin目录下，并重命名为docker-compose
mv docker-compose-Linux-x86_64 /usr/local/bin/docker-compose

  • 测试安装成功

    $ docker compose version
Docker Compose version v2.27.1

五、Integrate工具

  • 持续集成、持续部署CI、CD的工具很多，其中Jenkins是一个开源的持续集成平台。

  • Jenkins可以交互式将研发人员编写的代码发布到测试和生产环境

  • Jenkins需要大量的插件保证工作，安装成本较高，下面会基于Docker搭建Jenkins。

5.1 Jenkins介绍

Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具。大多数互联网公司都采用Jenkins配合GitLab、Docker、Kubernetes 作为实现 devops 的核心工具。Jenkins最强大的就在于插件，Jenkins官方提供了大量的插件库，来自动化CI/CD过程中的各种琐碎功能。

Jenkins最主要的工作就是将GitLab上可的工程代码拉取、构建、发布到测试环境或是生产环境。一般是GitLab上的代码经过大量的测试后，确定发行版本，再发布到生产环境。

CI/CD可以理解为：

  • CI过程即是通过Jenkins将代码拉取、构建、制作镜像交给测试人员测试。
  • 持续集成：让软件代码可以持续的集成到主干上，并自动构建和测试。
  • CD过程即是通过Jenkins将打好标签的发行版本代码拉取、构建、制作镜像交给运维人员部署。
  • 持续交付：让经过持续集成的代码可以进行手动部署。
  • 持续部署：让可以持续交付的代码随时随地的自动化部署。

5.2 Jenkins安装

  • 拉取Jenkins镜像

    docker pull jenkins/jenkins

  • 编写docker-compose.yml

    #version: "3.6"
services:
  jenkins:
    image: jenkins/jenkins:latest
    container_name: jenkins
    ports:
      - 18080:8080
      - 50000:50000
    volumes:
      - /home/docker/data/jenkins/:/var/jenkins_home/

  • 使用docker-compose启动jenkins容器

    $ docker-compose up -d

    查看jenkins容器启动状态，发现容器启动自动退出，首次启动失败

    $ docker-compose ps -a
WARN[0000] /home/docker/jenkins/docker-compose.yaml: `version` is obsolete
NAME      IMAGE                         COMMAND                  SERVICE   CREATED         STATUS                   PORTS
jenkins   jenkins/jenkins:2.319.1-lts   "/sbin/tini -- /usr/…"   jenkins   8 minutes ago   Exited (1) 8 minutes ago

    查看docker-compose的启动日志

    $ docker-compose -f logs
WARN[0000] /home/docker/jenkins/docker-compose.yaml: `version` is obsolete
jenkins  | touch: cannot touch '/var/jenkins_home/copy_reference_file.log': Permission denied
jenkins  | Can not write to /var/jenkins_home/copy_reference_file.log. Wrong volume permissions?

    原因分析：首次启动会因为数据卷/home/docker/data/jenkins/目录没有写权限导致启动失败

    设置/home/docker/data/jenkins/目录的写权限

    chmod -R a+w /home/docker/data/jenkins/

  • 重新启动Jenkins容器后，由于Jenkins需要下载大量内容，但是由于默认下载地址下载速度较慢，需要重新设置下载地址为国内镜像站

    修改数据卷中的hudson.model.UpdateCenter.xml文件

    <?xml version='1.1' encoding='UTF-8'?>
<sites>
  <site>
    <id>default</id>
    <url>https://updates.jenkins.io/update-center.json</url>
  </site>
</sites>

    将下载地址替换为：http://mirror.esuni.jp/jenkins/updates/update-center.json

    <?xml version='1.1' encoding='UTF-8'?>
<sites>
  <site>
    <id>default</id>
    <url>http://mirror.esuni.jp/jenkins/updates/update-center.json</url>
  </site>
</sites>

  • 再次重启Jenkins容器，访问Jenkins（需要稍微等会）

    获取Jenkins管理员登录密码

    image-20240711142156573

    访问http://192.168.xxx.xxx:18080

    image-20240712130544865

  • 查看密码登录Jenkins，并登录下载插件

    $ cat /home/docker/data/jenkins/secrets/initialAdminPassword
  • 登录并下载插件
    image-20240712130307528

  • 选择需要安装的插件
    image-20240711144843435

    image-20240711144903802

    image-20240711164018494

  • 初始化时使用的admin用户，在完成Jenkins的引导过程后就失效了，需要重新创建管理员用户

    image-20240711164720746

    image-20240711164857427

    image-20240711164941457

  • 至此Jenkins安装成功
    image-20240711165240402

5.3 Jenkins入门配置

由于Jenkins需要从Git拉取代码、需要本地构建、甚至需要直接发布自定义镜像到Docker仓库，所以Jenkins需要配置大量内容。

5.3.1 构建任务

准备好GitLab仓库中的项目，并且通过Jenkins配置实现当前项目的 DevOps 基本流程。

  • GitLab查看项目

    image-20240712151411036

  • Jenkins点击左侧导航新建任务
    image-20240712153554549

  • 选择自由风格构建任务
    image-20240712154447474

5.3.2 配置源码拉取地址

Jenkins需要将Git上存放的源码存储到Jenkins服务所在磁盘的本地

  • 配置任务源码拉取的地址

image-20240712162622650

  • 点击任务test中的立即构建
    image-20240712162921106

  • 查看构建日志

    image-20240712163157443

    可以看到源码已经拉取带Jenkins本地，可以根据第三行日志信息，查看Jenkins本地拉取到的源码。

  • 查看Jenkins容器中拉取下来的源码

    $ docker exec -it jenkins bash
jenkins@86b09258ebb5:/$ cd /var/jenkins_home/workspace/devops-test
jenkins@86b09258ebb5:~/workspace/devops-test$ ls
Dockerfile  README.md  mvnw  mvnw.cmd  pom.xml  src
5.3.3 配置Maven构建代码

代码拉取到Jenkins本地后，需要在Jenkins中对代码进行构建，这里需要Maven的环境，而Maven需要Java的环境，接下来需要在Jenkins中安装JDK和Maven，并且配置到Jenkins服务。

  • 准备JDK、Maven压缩包通过数据卷映射到Jenkins容器内部

  • 将maven和jdk通过数据卷映射到Jenkins容器中

    #将maven安装目录/root/projects/maven/apache-maven-3.9.6通过软连接放至Jenkins数据卷/home/docker/data/jenkins/maven目录中
ln -s /root/projects/maven/apache-maven-3.9.6 /home/docker/data/jenkins/maven
#将jdk安装目录/root/projects/jdk/jdk1.8.0_411通过软连接放至Jenkins数据卷/home/docker/data/jenkins/jdk目录中
ln -s /root/projects/jdk/jdk1.8.0_411 /home/docker/data/jenkins/jdk
#查看操作结果
ll -h

    image-20240715140528452

  • 配置Maven的settings.xml

    <!-- 阿里云镜像地址 -->
<mirror>  
    <id>alimaven</id>  
    <name>aliyun maven</name>  
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<!-- JDK1.8编译插件 -->
<profile>
    <id>jdk-1.8</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>  
</profile>

  • Jenkins配置JDK&Maven并保存

    image-20240715174044654

    image-20240715174125783

  • 配置Jenkins任务

    image-20240715173943215

  • 执行构建

    image-20240715173842870

  • 查看数据卷目录/home/docker/data/jenkins/workspace/devops-test/target/下是否生成了jar包

    image-20240715173047120

5.3.4 配置Publish发布&远程操作

jar包构建好之后，就可以根据情况发布到测试或生产环境。

  • 下载Publish Over SSH插件

    image-20240715174739844

  • Publish Over SSH配置

    image-20240715190532272

  • 发布jar包到目标服务器

    image-20240715190859367

  • 构建任务

    image-20240715191104527

  • 进入目标服务查看jar包是否部署成功

image-20240715191344528

六、CI、CD入门操作

基于Jenkins拉取GitLab的SpringBoot代码进行构建发布到测试环境实现持续集成

基于Jenkins拉取GitLab指定发行版本的SpringBoot代码进行构建发布到生产环境实现CD实现持续部署

6.1 持续集成

为了让程序代码可以自动推送到测试环境基于Docker服务运行，需要添加Docker配置和脚本文件让程序可以在集成到主干的同时运行起来。

  • 添加Dockerfile文件

    FROM maven:3-jdk-8-alpine

WORKDIR /usr/local

COPY . /usr/local
RUN mvn package

ENV PORT 8080
EXPOSE $PORT
CMD [ "sh", "-c", "mvn -Dserver.port=${PORT} spring-boot:run" ]

  • 添加docker-compose.yaml文件

    version: '3.6'
services:
    demo:
        build: ./
        image: demo:v1.0.0
        container_name: demo
        ports:
            - 8888:8080

  • 追加Jenkins构建后操作脚本命令

    image-20240716161436950

  • 发布到GitLab后由Jenkins立即构建并推送到目标服务器

    image-20240716155255774

  • 查看目标服务器

    $ cd /home/testApp
$ docker-compose ps
NAME  IMAGE        COMMAND                  SERVICE  CREATED         STATUS         PORTS
demo  demo:v1.0.0  "/bin/sh -c 'java -j…"   demo     32 seconds ago  Up 31 seconds  0.0.0.0:8888->8080/tcp, :::8888->8080/tcp

6.2 持续交付、部署

程序代码在经过多次集成操作最终到达高质量交付的目的，持续交付整体流程和持续集成类似，只不过持续交付需要选择指定的发行版本

  • 安装Git Parameter插件

    image-20240716161747295

  • 基于Git分支、标签构建

    image-20240716164043181

    设置项目参数化构建

    image-20240716173503244

  • 任务构建时，采用Shell方式构建，拉取指定tag或branch代码

    image-20240716174155681

  • 基于Parameter构建任务，任务发布到目标服务器

    image-20240716175246477

七、集成Sonar Qube

7.1 Sonar Qube介绍

Sonar Qube是一个开源的代码分析平台，支持Java、Python、PHP、JavaScript、CSS等25种以上的语言，可以检测出重复代码、代码漏洞、代码规范和安全性漏洞的问题。

Sonar Qube可以与多种软件整合进行代码扫描，比如Maven，Gradle，Git，Jenkins等，并且会将代码检测结果推送回Sonar Qube并且在系统提供的UI界面上显示出来

image-20240717113830617

7.2 Sonar Qube环境搭建

7.2.1 Sonar Qube安装

Sonar Qube在7.9版本中已经放弃了对MySQL的支持，并且建议在商业环境中采用PostgreSQL，那么安装Sonar Qube时需要依赖PostgreSQL。

并且这里会安装Sonar Qube的长期支持版本8.9

  • 拉取镜像

     $ docker pull postgres
 $ docker pull sonarqube:8.9.3-community

  • 编写docker-compoe.yml

    version: "3.1"
services:
  postgre:
    image: postgres
    container_name: postgre
    ports:
      - 5432:5432
    networks:
      - sonarnet
    environment:
      POSTGRES_USER: sonar
      POSTGRES_PASSWORD: sonar
    volumes:
      - /home/docker/data/postgresql/bin:/var/lib/postgresql
      - /home/docker/data/postgresql/data:/var/lib/postgresql/data
  sonarqube:
    image: sonarqube:8.9.3-community
    container_name: sonarqube
    depends_on:
      - postgre
    ports:
      - "9000:9000"
    networks:
      - sonarnet
    environment:
      SONAR_JDBC_URL: jdbc:postgresql://postgre:5432/sonar
      SONAR_JDBC_USERNAME: sonar
      SONAR_JDBC_PASSWORD: sonar
    volumes:
      - /home/docker/data/sonarqube/data:/opt/sonarqube/data
      - /home/docker/data/sonarqube/extensions:/opt/sonarqube/extensions
      - /home/docker/data/sonarqube/logs:/opt/sonarqube/logs
networks:
  sonarnet:
    driver: bridge

  • 启动容器

    docker-compose up -d

    需要一定时间启动，可以可以查看容器日志，看到如下内容代表启动成功

    需要设置sysctl.conf文件信息

    34f7e6451ca34067adbda2aa1cdfed49

  • 访问Sonar Qube首页

    image-20240717113524500

  • 重新设置密码

    image-20240717113356133

  • Sonar Qube首页

    d0808dca09d94691acc8ea726f3b1fe4

7.2.2 安装中文插件

cc85662578614765a8a65bf6d3dc8156

安装成功后需要重启，安装失败重新点击install重装即可。

安装成功后，会查看到重启按钮，点击即可

image-20240717113149985

重启后查看效果

image-20240717171519228

7.3 Sonar Qube基本使用

Sonar Qube的使用方式很多，Maven可以整合，也可以采用sonar-scanner的方式，再查看Sonar Qube的检测效果

7.3.1 Maven实现代码检测

  • 修改Maven的settings.xml文件配置Sonar Qube信息

    <profile>
    <id>sonar</id>
    <activation>
        <activeByDefault>true</activeByDefault>
    </activation>
    <properties>
        <sonar.login>admin</sonar.login>
        <sonar.password>123456789</sonar.password>
        <sonar.host.url>http://192.168.11.11:9000</sonar.host.url>
    </properties>
</profile>

  • 在代码位置执行命令：mvn sonar:sonar

  • 查看Sonar Qube界面检测结果

    fcbe2c37c135433382146af7abd265f9

7.3.2 Sonar-scanner实现代码检测

  • 下载Sonar-scanner：https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.6.0.2311-linux.zip

  • 解压并配置sonar服务端信息

    • 由于是zip压缩包，需要安装unzip解压插件
      yum -y install unzip
    • 解压压缩包
      unzip sonar-scanner-cli/sonar-scanner-cli-4.6.0.2311-linux.zip

    • 配置sonarQube服务端地址，修改conf下的sonar-scanner.properties

      f02f2eeadf7d43e4b757cb9e802ac62b

  • 执行命令检测代码

    # 在项目所在目录执行以下命令
~/sonar-scanner/bin/sonar-scanner -Dsonar.sources=./ -Dsonar.projectname=demo -Dsonar.projectKey=java -Dsonar.java.binaries=target/

    eb92ff5c099a4d09a668340298dce29d

  • 查看SonarQube检测结果

    969546ab48f04819a4163a2485481acb

7.4 Jenkins集成Sonar Qube

Jenkins继承Sonar Qube实现代码扫描需要先下载整合插件

7.4.1 Jenkins安装插件

ac20977c0dff4db0800ec467a3adfa6e

6cbda080190944d482db264cb2e80a1f

21f2021a79954fc2a8d75c53af9611f4

7.4.2 Jenkins配置Sonar Qube

  • 开启Sonar Qube权限验证

    371b22bbdaac4cc9b87cee32259af8c8

  • 获取Sonar Qube令牌

    873b42b4549643c0a15ce811da842ea0

  • 配置Jenkins的Sonar Qube信息

    f923c5c984844b2d935fa0d7b58cb6f0

    b1288c2533554b5b9751a93e6c9fd324

    28844b85532d47319ce7a46e24686fe7

7.4.3 配置Sonar-scanner

  • 将Sonar-scaner添加到Jenkins数据卷中并配置全局配置

    da252dd39ecf4e6a9b4ab005ecd31514

  • 配置任务的Sonar-scanner

    3b1ff30d1c874ce28db5d6c076c62e5c

7.4.4 构建任务

00a97c936cab4915bd0a17533320578f

eb6918ee940448bcacd203006721d97e

八、集成Harbor

8.1 Harbor介绍

前面在部署项目时，我们主要采用Jenkins推送jar包到指定服务器，再通过脚本命令让目标服务器对当前jar进行部署，这种方式在项目较多时，每个目标服务器都需要将jar包制作成自定义镜像再通过docker进行启动，操作比较容器范围，还会降低项目部署时间。

我们可以通过Harbor作为私有的Docker镜像仓库。让Jenkins统一将项目打包并制作成Docker镜像发布到Harbor仓库中，只需要通知目标服务，让目标服务统一去Harbor仓库上拉取镜像并在本地部署即可。

Docker官方提供了Registry镜像仓库，但是Registry的功能相对简陋。Harbor是VMware公司提供的一款镜像仓库，提供了权限控制、分布式发布、强大的安全扫描与审查机制等功能

8.2 Harbor安装

这里采用原生的方式安装Harbor。

8.3 Harbor使用方式

Harbor作为镜像仓库，主要的交互方式就是将镜像上传到Harbor上，以及从Harbor上下载指定镜像

在传输镜像前，可以先使用Harbor提供的权限管理，将项目设置为私有项目，并对不同用户设置不同角色，从而更方便管理镜像。

8.3.1 添加用户构建项目

  • 创建用户

    129dc6943ae44dd6a739b7eb7685b3f0

  • 构建项目（设置为私有)

    5ccd8cce8f324240a0411dbcfde7bed7

  • 给项目追加用户

    3e55e8b556334387941cf43d4bd732b3

  • 切换测试用户

    0067e4c3d0b0453881454028e05edbaa

8.3.2 发布镜像到Harbor

  • 修改镜像名称
    名称要求：harbor地址/项目名/镜像名:版本

    41ca1b62a3b0408981c5ab3f182a7407

  • 修改daemon.json，支持Docker仓库，并重启Docker

    24fa53ea6cf24815a75b3c60d67e3070

  • 设置登录仓库信息

    $ docker login -u 用户名 -p 密码 Harbor地址

  • 推送镜像到Harbor

    a870032db9a347fdb4c35217780b1de7

    7dea6d5a4d8b4ecba63e65d6f26dae64

8.3.3 从Harbor拉取镜像

  • 配置/etc/docker/daemon.json文件

    {
        "registry-mirrors": ["https://pee6w651.mirror.aliyuncs.com"],
        "insecure-registries": ["IP:PORT"]
}

  • 拉取镜像

    image20211201222450091.png

九、Jenkins流水线

9.1 Jenkins流水线任务介绍

前面采用的是Jenkins自由风格构建的项目，每个步骤流程都要通过不同的方式设置，并且构建过程中整体流程是不可见的，无法确认每个流程花费的时间，并且一旦出了问题不方便定位、排查。

Jenkins的Pipeline可以让项目的发布整体流程可视化，明确执行的阶段，可以快速的定位问题。并且整个项目的生命周期可以通过一个Jenkinsfile文件管理，而且Jenkinsfile文件是可以放在项目中维护。

所以Pipeline相对自由风格或者其他的项目风格更容易操作。

9.2 Jenkins流水线任务

9.2.1 构建Jenkins流水线任务

  • 构建Jenkins流水线任务

    image-20240717094805031

  • 生成Groovy脚本

    image-20240717094611621

  • 构建后查看视图

    image-20240717095533463

9.2.2 Groovy脚本

  • Groovy脚本基础语法

    // 所有脚本命令都包含在pipeline{}中
pipeline {  
	// 指定任务在哪个节点执行（Jenkins支持分布式）
    agent any

    // 配置全局环境，变量名=变量值
    environment{
    	host = 'xxx.xxx.xxx.xxx'
    }

    // 存放所有任务的合集
    stages {
    	// 单个任务
        stage('任务1') {
        	// 实现任务的具体流程
            steps {
                echo 'do something'
            }
        }
		// 单个任务
        stage('任务2') {
        	// 实现任务的具体流程
            steps {
                echo 'do something'
            }
        }
        // ……
    }
}

  • 编写例子测试

    pipeline {
    agent any

    // 存放所有任务的合集
    stages {
        stage('拉取Git代码') {
            steps {
                echo '拉取Git代码'
            }
        }

        stage('检测代码质量') {
            steps {
                echo '检测代码质量'
            }
        }

        stage('构建代码') {
            steps {
                echo '构建代码'
            }
        }

        stage('制作自定义镜像并发布Harbor') {
            steps {
                echo '制作自定义镜像并发布Harbor'
            }
        }

        stage('基于Harbor部署工程') {
            steps {
                echo '基于Harbor部署工程'
            }
        }
    }
}

  • 查看效果

    image-20240717100150296

  • 生成命令位置

    c484f13d7f5246e8bc636d27586548ac

9.2.3 Jenkinsfile实现

Jenkinsfile方式需要将脚本内容编写到项目中的Jenkinsfile文件中，每次构建会自动拉取项目并且获取项目中Jenkinsfile文件对项目进行构建

  • 配置pipeline

    79a480494c2143fd9eb433ba9dd87675

  • 准备Jenkinsfile

    1db4a18a746c4b71a851de3aa2110c7c

  • 测试效果

0312d109edbd4a128bc0cb95ac356c4f

9.3 Jenkins流水线任务实现

9.3.1 参数化构建

添加参数化构建，方便选择不同的项目版本

fad377ce5a764133b518f79253893cfc

9.3.2 拉取Git代码

通过流水线语法生成Checkout代码的脚本

cdee40fa5084427790a0afa1e085ae3f

03a67fe9777941c98dd843b390356284

将*/master更改为标签${tag}

pipeline {
    agent any
    stages {
        stage('拉取Git代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }
    }
}
9.3.3 构建代码

通过脚本执行mvn的构建命令

pipeline {
    agent any
    stages {
        stage('拉取Git代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }
        stage('构建代码') {
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }
}
9.3.4 代码质量检测

通过脚本执行sonar-scanner命令即可

pipeline {
    agent any
    stages {
        stage('拉取Git代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }

        stage('构建代码') {
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }

        stage('检测代码质量') {
            steps {
                sh '/var/jenkins_home/sonar-scanner/bin/sonar-scanner -Dsonar.sources=./ -Dsonar.projectname=${JOB_NAME} -Dsonar.projectKey=${JOB_NAME} -Dsonar.java.binaries=target/ -Dsonar.login=31388be45653876c1f51ec02f0d478e2d9d0e1fa' 
            }
        }
    }
}
9.3.5 制作自定义镜像并发布

构建镜像和发布镜像到harbor都需要使用到docker命令。官方推荐直接采用宿主机中安装的Docker即可。

  • 设置Jenkins容器使用宿主机Docker

    设置宿主机docker.sock权限：

    sudo chown root:root /var/run/docker.sock
sudo chmod o+rw /var/run/docker.sock

  • 添加数据卷

    version: "3.1"
services:
  jenkins:
    image: jenkins/jenkins
    container_name: jenkins
    ports:
      - 8080:8080
      - 50000:50000
    volumes:
      - ./data/:/var/jenkins_home/
      - /usr/bin/docker:/usr/bin/docker
      - /var/run/docker.sock:/var/run/docker.sock
      - /etc/docker/daemon.json:/etc/docker/daemon.json

  • 添加脚本

    pipeline {
    agent any
    environment{
        harborHost = '192.168.1.211:80'
        harborRepo = 'repository'
        harborUser = 'DevOps'
        harborPasswd = 'P@ssw0rd'
    }

    // 存放所有任务的合集
    stages {
      stage('拉取Git代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }

		stage('构建代码') {
              steps {
                  sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
              }
          }

        stage('检测代码质量') {
              steps {
                  sh '/var/jenkins_home/sonar-scanner/bin/sonar-scanner -Dsonar.sources=./ -Dsonar.projectname=${JOB_NAME} -Dsonar.projectKey=${JOB_NAME} -Dsonar.java.binaries=target/ -Dsonar.login=31388be45653876c1f51ec02f0d478e2d9d0e1fa' 
              }
          }

        stage('制作自定义镜像并发布Harbor') {
              steps {
                  sh '''cp ./target/*.jar ./docker/
                  cd ./docker
                  docker build -t ${JOB_NAME}:${tag} ./'''
                  sh '''docker login -u ${harborUser} -p ${harborPasswd} ${harborHost}
                docker tag ${JOB_NAME}:${tag} ${harborHost}/${harborRepo}/${JOB_NAME}:${tag}
                  docker push ${harborHost}/${harborRepo}/${JOB_NAME}:${tag}'''
              }
          }
      }
  }
9.3.6 部署项目

部署项目需要通过Publish Over SSH插件，让目标服务器执行命令。为了方便一次性实现拉取镜像和启动的命令，推荐采用脚本文件的方式。

添加脚本文件到目标服务器，再通过Publish Over SSH插件让目标服务器执行脚本即可。

  • 编写脚本文件，添加到目标服务器

    harbor_url=$1
harbor_project_name=$2
project_name=$3
tag=$4
port=$5

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

containerId=`docker ps -a | grep ${project_name} | awk '{print $1}'`
if [ "$containerId" != "" ] ; then
    docker stop $containerId
    docker rm $containerId
    echo "Delete Container Success"
fi

imageId=`docker images | grep ${project_name} | awk '{print $3}'`

if [ "$imageId" != "" ] ; then
    docker rmi -f $imageId
    echo "Delete Image Success"
fi

docker login -u DevOps -p P@ssw0rd $harbor_url

docker pull $imageName

docker run -d -p $port:$port --name $project_name $imageName

echo "Start Container Success"
echo $project_name

    并设置权限为可执行

    chmod a+x deploy.sh

  • 生成Publish Over SSH脚本

    pipeline {
    agent any
    environment{
        harborHost = '192.168.1.211:80'
        harborRepo = 'repository'
        harborUser = 'DevOps'
        harborPasswd = 'P@ssw0rd'
    }

    // 存放所有任务的合集
    stages {

        stage('拉取Git代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }

        stage('构建代码') {
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }

        stage('检测代码质量') {
            steps {
                sh '/var/jenkins_home/sonar-scanner/bin/sonar-scanner -Dsonar.sources=./ -Dsonar.projectname=${JOB_NAME} -Dsonar.projectKey=${JOB_NAME} -Dsonar.java.binaries=target/ -Dsonar.login=7d66af4b39cfe4f52ac0a915d4c9d5c513207098' 
            }
        }

        stage('制作自定义镜像并发布Harbor') {
            steps {
                sh '''cp ./target/*.jar ./docker/
                cd ./docker
                docker build -t ${JOB_NAME}:${tag} ./'''

                sh '''docker login -u ${harborUser} -p ${harborPasswd} ${harborHost}
                docker tag ${JOB_NAME}:${tag} ${harborHost}/${harborRepo}/${JOB_NAME}:${tag}
                docker push ${harborHost}/${harborRepo}/${JOB_NAME}:${tag}'''
            }
        }
        
        stage('目标服务器拉取镜像并运行') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: 'testEnvironment', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/usr/bin/deploy.sh $sonarHost $sonarRepo $JOB_NAME $tag $port ", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
    }
}

9.4 Jenkins流水线整合钉钉

在程序部署成功后，可以通过钉钉的机器人及时向群众发送部署的最终结果通知

  • 安装插件

    0d6e591aa81f46488ac0065ca58a9b90

  • 钉钉内部创建群组并构建机器人

    324ef843b3ed45d9a8f5786e574a61d2

    31c04e9167a24b08a70d88feaefd4eef

    96d042c8c5c5484f947c8680d6268eae

    最终或获取到Webhook信息

    https://oapi.dingtalk.com/robot/send?access_token=kej4ehkj34gjhg34jh5bh5jb34hj53b4

  • 系统配置添加钉钉通知

    8ac2738612654728b074e038a6ccf9f5

  • 任务中追加流水线配置

    pipeline {
    agent any

    environment {
        sonarLogin = '2bab7bf7d5af25e2c2ca2f178af2c3c55c64d5d8'
        sonarUser = 'admin'
        sonarPassword = 'Harbor12345'
        sonarHost = '192.168.11.12:8888'
        sonarRepo = 'repository'
    }

    stages {
        stage('拉取Git代码'){
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '$tag']], extensions: [], userRemoteConfigs: [[url: 'http://49.233.115.171:8929/root/lsx.git']]])
            }
        }
        stage('Maven构建代码'){
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }
        stage('SonarQube检测代码'){
            steps {
                sh '/var/jenkins_home/sonar-scanner/bin/sonar-scanner -Dsonar.sources=./ -Dsonar.projectname=${JOB_NAME} -Dsonar.projectKey=${JOB_NAME} -Dsonar.java.binaries=target/ -Dsonar.login=${sonarLogin}'
            }
        }
        stage('制作自定义镜像'){
            steps {
                sh '''cd docker
                mv ../target/*.jar ./
                docker build -t ${JOB_NAME}:$tag .
                '''
            }
        }

        stage('推送自定义镜像'){
            steps {
                sh '''docker login -u ${sonarUser} -p ${sonarPassword} ${sonarHost}
                docker tag ${JOB_NAME}:$tag ${sonarHost}/${sonarRepo}/${JOB_NAME}:$tag
                docker push ${sonarHost}/${sonarRepo}/${JOB_NAME}:$tag'''
            }
        }

        stage('通知目标服务器'){
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: 'centos-docker', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: "/usr/bin/deploy.sh $sonarHost $sonarRepo $JOB_NAME $tag $port", execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: '')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }  
        }
    }
    post {
        success {
            dingtalk (
                robot: 'Jenkins-DingDing',
                type:'MARKDOWN',
                title: "success: ${JOB_NAME}",
                text: ["- 成功构建:${JOB_NAME}项目!\n- 版本:${tag}\n- 持续时间:${currentBuild.durationString}\n- 任务:#${JOB_NAME}"]
            )
        }
        failure {
            dingtalk (
                robot: 'Jenkins-DingDing',
                type:'MARKDOWN',
                title: "fail: ${JOB_NAME}",
                text: ["- 失败构建:${JOB_NAME}项目!\n- 版本:${tag}\n- 持续时间:${currentBuild.durationString}\n- 任务:#${JOB_NAME}"]
            )
        }
    }
}

  • 查看钉钉通知效果

    653d7931f5954a25894c8d6a272827cb

十、Kubernetes编排工具

10.1 Kubernetes介绍

Kubernetes是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效（powerful）,Kubernetes提供了应用部署，规划，更新，维护的一种机制。

Kubernetes一个核心的特点就是能够自主的管理容器来保证云平台中的容器按照用户期望的状态运行，管理员可以加载一个服务，让规划器来找到资源最优的节点进行部署，同时，Kubernetes也提供了一些快捷的命令行工具和可视化管理界面，让用户可以较为方便的部署并管理自己的应用。

Kubernetes主要能帮助我们完成：

  • 服务发现和负载均衡
    Kubernetes 可以使用 DNS 名称或自己的 IP 地址公开容器，如果进入容器的流量很大， Kubernetes 可以负载均衡并分配网络流量，从而使部署稳定。
  • 存储编排
    Kubernetes 允许你自动挂载你选择的存储系统，比如本地存储，类似Docker的数据卷。
  • 自动部署和回滚
    你可以使用 Kubernetes 描述已部署容器的所需状态，它可以以受控的速率将实际状态 更改为期望状态。Kubernetes 会自动帮你根据情况部署创建新容器，并删除现有容器给新容器提供资源。
  • 自动完成装箱计算
    Kubernetes 允许你设置每个容器的资源，比如CPU和内存。
  • 自我修复
    Kubernetes 重新启动失败的容器、替换容器、杀死不响应用户定义的容器，并运行状况检查的容器。
  • 秘钥与配置管理
    Kubernetes 允许你存储和管理敏感信息，例如密码、OAuth 令牌和 ssh 密钥。你可以在不重建容器镜像的情况下部署和更新密钥和应用程序配置，也无需在堆栈配置中暴露密钥。

10.2 Kubernetes架构

Kubernetes 搭建需要至少两个节点，一个Master负责管理，一个Slave搭建在工作服务器上负责分配。

4e326d77d52144d68121f2624e530ed3

从图中可以看到各个组件的基本功能：

  • API Server：作为K8s通讯的核心组件，K8s内部交互以及接收发送指令的组件。
  • controller-manager：作为K8s的核心组件，主要做资源调度，根据集群情况分配资源
  • etcd：一个key-value的数据库，存储存储集群的状态信息
  • scheduler：负责调度每个工作节点
  • cloud-controller-manager：负责调度其他云服务产品
  • kubelet：管理Pods上面的容器。
  • kube-proxy：负责处理其他Slave或客户端的请求。
  • Pod：可以理解为就是运行的容器

10.3 Kubernetes安装

这里会采用https://kuboard.cn/提供的方式安装K8s，安装单Master节点

  • 要求使用Centos7.8版本：https://vault.centos.org/7.8.2003/isos/x86_64/CentOS-7-x86_64-Minimal-2003.iso

  • 至少2台2核4G 的服务器

  • 重新设置hostname，不允许为localhost

    # 修改 hostname，名字不允许使用下划线、小数点、大写字母，不能叫master
hostnamectl set-hostname your-new-host-name
# 查看修改结果
hostnamectl status
# 设置 hostname 解析
echo "127.0.0.1   $(hostname)" >> /etc/hosts

  • 要求2台服务之间可以相互通讯

  • 安装软件

    # 阿里云 docker hub 镜像
export REGISTRY_MIRROR=https://registry.cn-hangzhou.aliyuncs.com
curl -sSL https://kuboard.cn/install-script/v1.19.x/install_kubelet.sh | sh -s 1.19.5

    首先初始化Master节点

    关于初始化时用到的环境变量

    • APISERVER_NAME 不能是 master 的 hostname
    • APISERVER_NAME 必须全为小写字母、数字、小数点，不能包含减号
    • POD_SUBNET 所使用的网段不能与master节点/worker节点 所在的网段重叠。该字段的取值为一个CIDR 值，如果您对 CIDR 这个概念还不熟悉，请仍然执行 export POD_SUBNET=10.100.0.0/16 命令，不做修改

  • 设置ip，域名，网段并执行初始化操作

    # 只在 master 节点执行
# 替换 x.x.x.x 为 master 节点实际 IP（请使用内网 IP）
# export 命令只在当前 shell 会话中有效，开启新的 shell 窗口后，如果要继续安装过程，请重新执行此处的 export 命令
export MASTER_IP=xxx.xxx.xxx.xxx
# 替换 apiserver.demo 为 您想要的 dnsName
export APISERVER_NAME=apiserver.demo
# Kubernetes 容器组所在的网段，该网段由 kubernetes 负责创建，事先并不存在于您的物理网络中
export POD_SUBNET=10.100.0.1/16
echo "${MASTER_IP}    ${APISERVER_NAME}" >> /etc/hosts
curl -sSL https://kuboard.cn/install-script/v1.19.x/init_master.sh | sh -s 1.19.5

  • 检查Master启动状态

    # 只在 master 节点执行
# 执行如下命令，等待所有的容器组处于 Running 状态
watch kubectl get pod -n kube-system -o wide

# 查看 master 节点初始化结果
kubectl get nodes -o wide

    docker pull quay.io/coreos/flannel:v0.10.0-amd64 
mkdir -p /etc/cni/net.d/
cat <<EOF> /etc/cni/net.d/10-flannel.conf
{"name":"cbr0","type":"flannel","delegate": {"isDefaultGateway": true}}
EOF
mkdir /usr/share/oci-umount/oci-umount.d -p
mkdir /run/flannel/
cat <<EOF> /run/flannel/subnet.env
FLANNEL_NETWORK=172.100.0.0/16
FLANNEL_SUBNET=172.100.1.0/24
FLANNEL_MTU=1450
FLANNEL_IPMASQ=true
EOF
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

  • 安装网络服务插件

      export POD_SUBNET=10.100.0.0/16
  kubectl apply -f https://kuboard.cn/install-script/v1.22.x/calico-operator.yaml
  wget https://kuboard.cn/install-script/v1.22.x/calico-custom-resources.yaml
  sed -i "s#192.168.0.0/16#${POD_SUBNET}#" calico-custom-resources.yaml
  kubectl apply -f calico-custom-resources.yaml

  • 获取Join命令参数，在Master节点执行

    # 只在 master 节点执行
kubeadm token create --print-join-command

  • 在worker节点初始化

    # 只在 worker 节点执行
# 替换 x.x.x.x 为 master 节点的内网 IP
export MASTER_IP=192.168.11.32
# 替换 apiserver.demo 为初始化 master 节点时所使用的 APISERVER_NAME
export APISERVER_NAME=apiserver.demo
echo "${MASTER_IP}    ${APISERVER_NAME}" >> /etc/hosts

# 替换为 master 节点上 kubeadm token create 命令的输出
kubeadm join apiserver.demo:6443 --token vwfilu.3nhndohc5gn1jv9k     --discovery-token-ca-cert-hash sha256:22ff15cabfe87ab48a7db39b3bbf986fee92ec92eb8efc7fe9b0abe2175ff0c2

  • 在 master 节点上执行

    # 只在 master 节点执行
kubectl get nodes -o wide

    docker pull quay.io/coreos/flannel:v0.10.0-amd64 
mkdir -p /etc/cni/net.d/
cat <<EOF> /etc/cni/net.d/10-flannel.conf
{"name":"cbr0","type":"flannel","delegate": {"isDefaultGateway": true}}
EOF
mkdir /usr/share/oci-umount/oci-umount.d -p
mkdir /run/flannel/
cat <<EOF> /run/flannel/subnet.env
FLANNEL_NETWORK=172.100.0.0/16
FLANNEL_SUBNET=172.100.1.0/24
FLANNEL_MTU=1450
FLANNEL_IPMASQ=true
EOF
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

  • 输出结果如下所示：

    [root@k8smaster ~]# kubectl get nodes

安装Kuboard管理K8s集群

  • 安装Kuboard

    kubectl apply -f https://addons.kuboard.cn/kuboard/kuboard-v3.yaml
# 您也可以使用下面的指令，唯一的区别是，该指令使用华为云的镜像仓库替代 docker hub 分发 Kuboard 所需要的镜像
# kubectl apply -f https://addons.kuboard.cn/kuboard/kuboard-v3-swr.yaml

  • 查看启动情况

    watch kubectl get pods -n kuboard

  • 在浏览器中打开链接 http://your-node-ip-address:30080

    image-20240717105243382

  • 输入初始用户名和密码，并登录

    • 用户名：admin
    • 密码：Kuboard123

    image-20240717105415123

10.4 Kubernetes操作

首先我们要了解Kubernetes在运行我们的资源时，关联到了哪些内容

  • 资源的构建方式：

    1. kubectl的命令

    2. yaml文件

10.4.1 Namespace

  • 命名空间：主要是为了对Kubernetes中运行的资源进行过隔离， 但是网络是互通的，类似Docker的容器，可以将多个资源配置到一个NameSpace中。而NameSpace可以对不同环境进行资源隔离，默认情况下Kubernetes提供了default命名空间，在构建资源时，如果不指定资源，默认采用default资源。
    命令方式：

    # 查看现有的全部命名空间
kubectl get ns

# 构建命名空间
kubectl create ns 命名空间名称

# 删除现有命名空间， 并且会删除空间下的全部资源
kubectl delete ns 命名空间名称

    yaml文件方式：

    # 构建资源时，设置命名空间
apiVersion: v1
kind: Namespace
metadata:
  name: test
10.4.2 Pod
  • Pod：Kubernetes运行的一组容器，Pod是Kubernetes的最小单位，但是对于Docker而言，Pod中会运行多个Docker容器

    1. 命令方式：

      # 查看所有运行的pod
kubectl get pods -A

# 查看指定Namespace下的Pod
kubectl get pod [-n 命名空间]  #（默认default）

# 创建Pod
kubectl run pod名称 --image=镜像名称

# 查看Pod详细信息
kubectl describe pod pod名称

# 删除pod
kubectl delete pod pod名称 [-n 命名空间]  #（默认default）

# 查看pod输出的日志
kubectl logs -f pod名称

# 进去pod容器内部
kubectl exec -it pod名称 -- bash

# 查看kubernetes给Pod分配的ip信息，并且通过ip和容器的端口，可以直接访问
kubectl get pod -owide

    2. yaml方式（推荐）

      apiVersion: v1
kind: Pod
metadata:
  labels:
    run: 运行的pod名称
  name: pod名称
  namespace: 命名空间
spec:
  containers:
  - image: 镜像名称
     name: 容器名称

# 启动Pod：kubectl apply -f yaml文件名称
# 删除Pod：kubectl delete -f yaml文件名称

      Pod中运行多个容器

      apiVersion: v1
kind: Pod
metadata:
  labels:
    run: 运行的pod名称
  name: pod名称
  namespace: 命名空间
spec:
  containers:
  - image: 镜像名称
    name: 容器名称
  - image: 镜像名称
    name: 容器名称
…………

      启动后可以查看到

      ff33321683f14c74a6c5db4d6207fcdf

10.4.3 Deployment

  • Deployment管理和编排

    • 通过命令管理和编排

      # 基于Deployment启动容器
kubectl create deployment deployment名称 --image=镜像名称
# 用deployment启动的容器会在被删除后自动再次创建，达到故障漂移的效果
# 需要使用deploy的方式删除deploy
# 查看现在的deployment
kubectl get deployment

# 删除deployment
kubectl delete deployment deployment名称

# 基于Deployment启动容器并设置Pod集群数
kubectl create deployment pod名称 --image=镜像名称 --replicas 集群个数

    • 通过配置文件管理和编排

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
       image: nginx
       ports:
       - containerPort: 80

      正常使用kubectl运行yaml即可

  • 通过命令进行弹性伸缩

    # 基于scale实现弹性伸缩
kubectl scale deploy/Deployment名称 --replicas 集群个数
# 或者修改yaml文件
kubectl edit deploy Deployment名称

  • 借助图形化管理界面进行伸缩

    5c978f1318664c5e965a7571333bbdbe

  • 灰度发布

    Deploy可以在部署新版本数据时，成功启动一个pod，才会下线一个老版本的Pod

    kubectl set image deployment/Deployment名称 容器名=镜像:版本
10.4.4 Service

可以将多个Pod对外暴露一个Service，让客户端可以通过Service访问到这一组Pod，并且可以实现负载均衡

  • ClusterIP方式：

    ClusterIP是集群内部Pod之间的访问方式

    # 通过生成service映射一个Deployment下的所有pod中的某一个端口的容器
kubectl expose deployment Deployment名称 --port=Service端口号 --target-port=Pod内容器端口

    之后通过 kubectl get service查看Service提供的IP，即可访问。

    也可以通过 Deployment名称.namespace名称.svc作为域名访问，使用方式如下

    curl nginx.default.svc:8888

  • NodePort方式：

    ClusterIP的方式只能在Pod内部实现访问，但是一般需要对外暴露网关，所以需要NodePort的方式对外暴露访问端口

    # 通过生成service映射一个Deployment下的所有pod中的某一个端口的容器
kubectl expose deployment Deployment名称 --port=Service端口号 --target-port=Pod内容器端口 --type=NodePort
10.4.5 Ingress

Kubernetes推荐将Ingress作为所有Service的入口，提供统一的入口，避免多个服务之间需要记录大量的IP或者域名，毕竟IP可能改变，服务太多域名记录不方便。

Ingress底层其实就是一个Nginx， 可以在Kuboard上直接点击安装

4da7acc8f5714bbc8e7d845841149e3e

80a8002d4b914585887bf461dea05e32

因为副本数默认为1，k8s整体集群只有2个节点，所以显示下面信息即为安装成功

c9c5a2e071ad4e6daa0730dfd6fd68d9

可以将Ingress接收到的请求转发到不同的Service中。

推荐使用yaml文件方式

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
spec:
  ingressClassName: ingress
  rules:
  - host: nginx.mashibing.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 8888

启动时如果出现如下错误

41dd5037e867412992b149982b3a7f66

Kuboard安装的Ingress有admission的校验配置，需要先删除配置再启动

找到指定的ingress的校验信息，删除即可

c5e3731f31b64cda923007566d26019b

# 查看校验webhook的配置
kubectl get -A ValidatingWebhookConfiguration

# 删除指定的校验
kubectl delete ValidatingWebhookConfiguration ingress-nginx-admission-my-ingress-controller

在本地hosts文件中添加如下配置

access-ip-address  your-domain

接下来即可访问在Service中暴露的Nginx服务

http://your-domain:30191

10.5 基于Kubernetes发布

10.5.1 准备部署的yml文件
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: test
  name: pipeline
  labels:
    app: pipeline
spec:
  replicas: 2
  selector:
    matchLabels:
      app: pipeline
  template:
    metadata:
      labels:
        app: pipeline  
    spec:
      containers:
      - name: pipeline
        image: xxx.xxx.xxx.xxx:80/repo/pipeline:v4.0.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  namespace: test
  labels:
    app: pipeline
  name: pipeline  
spec:
  selector:
    app: pipeline
  ports:
  - port: 8081
    targetPort: 8080
  type: NodePort
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: test
  name: pipeline
spec:
  ingressClassName: ingress
  rules:
  - host: xxx.xxx.xxx
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: pipeline
            port:
              number: 8081
10.5.2 Harbor私服配置

在尝试用kubernetes的yml文件启动pipeline服务时，会出现Kubernetes无法拉取镜像的问题，这里需要在kubernetes所在的Linux中配置Harbor服务信息，并且保证Kubernetes可以拉取Harbor上的镜像

  • 设置Master和Worker的私服地址信息

    c187d8fbe5ec407cbac4405ee8096075

  • 在Kuboard上设置私服密文信息

    53709f5834b04d40aba7cd54f3f2f384

  • 按照复制指令的位置测试认证，效果如下

    7ac59e62422b4aebaa77879f0ffa137f

10.5.3 测试使用效果
  • 执行kubectl命令，基于yaml启动服务，并且基于部署后服务的提示信息以及Ingress的设置，直接访问

6c74e78220aa4ac5afc43f554cb264b3

10.5.4 Jenkins远程调用

  • 将pipeline.yaml配置到Gitlab中

    2e9405d7881c4ed28da7225803aced6d

  • 配置Jenkins的目标服务器，将yaml文件传输到K8s的Master上

    4390900ac72d457d924402eb2e254837

  • 修改Jenkinsfile，重新设置流水线任务脚本，并测试效果

    1bd2a8f44a3c454c9994d07d44c7d086

    c8e2dd3d969f4285874590fc4025379c

  • 设置Jenkins无密码登录k8s-master

    将Jenkins中公钥信息复制到k8s-master的~/.ssh/authorized_keysz中，保证远程连接无密码

    bed4f78bbb614ab0976daeb8e3a5b282

  • 设置执行kubectl的脚本到Jenkinsfile

    74409ebd73434715983f8c0514ac1264

  • 执行流水线

    83c59f40013447c9bfdcd0e3ca811d9f

​ 可以查看到yml文件是有变化的， 这样k8s就会重新加载

  • 浏览器访问查看是否发布成功

    http://your-domain:30604/test

10.6 基于GitLab的WebHooks

这里要实现自动化的一个CI操作，也就是开发人员Push代码到Git仓库后，Jenkins会自动的构建项目，将最新的提交点代码构建并进行打包部署，这里区别去上述的CD操作，CD操作需要基于某个版本进行部署，而这里每次都是将最新的提交点集成到主干上并测试。

10.6.1 WebHooks通知

开启Jenkins的自动构建

c1374b9e57744a319bc92c6634b597a4

设置Gitlab的Webhooks

82e1583dc68b43559c39ad21facf307c

关闭Jenkins的Gitlab认证

7e9e4a86acb7400d9f8bd51fe791281b

再次测试Gitlab

ac975530780b472f837b4560b6605244

10.6.2 修改配置

修改Jenkinsfile实现基于最新提交点实现持续集成效果，将之前引用${tag}的全部去掉

// 所有的脚本命令都放在pipeline中
pipeline{
	// 指定任务再哪个集群节点中执行
	agent any

	// 声明全局变量，方便后面使用
	environment {
		harborUser = 'admin'
        harborPasswd = 'Harbor12345'
        harborAddress = '192.168.1.102:80'
        harborRepo = 'repo'
	}

    stages {
        stage('拉取git仓库代码') {
            steps {
                checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[url: 'http://192.168.1.211:8929/devops/test.git']]])
            }
        }
        stage('通过maven构建项目') {
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }
        stage('通过SonarQube做代码质量检测') {
            steps {
                sh '/var/jenkins_home/sonar-scanner/bin/sonar-scanner -Dsonar.source=./ -Dsonar.projectname=${JOB_NAME} -Dsonar.projectKey=${JOB_NAME} -Dsonar.java.binaries=./target/ -Dsonar.login=40306ae8ea69a4792df2ceb4d9d25fe8a6ab1701'
            }
        }
        stage('通过Docker制作自定义镜像') {
            steps {
                sh '''mv ./target/*.jar ./docker/
                docker build -t ${JOB_NAME}:latest ./docker/'''
            }
        }
        stage('将自定义镜像推送到Harbor') {
            steps {
                sh '''docker login -u ${harborUser} -p ${harborPasswd} ${harborAddress}
                docker tag ${JOB_NAME}:latest  ${harborAddress}/${harborRepo}/${JOB_NAME}:latest
                docker push ${harborAddress}/${harborRepo}/${JOB_NAME}:latest '''
            }
        }
        stage('将yml文件传到k8s-master上') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: 'k8s', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: '', remoteDirectorySDF: false, removePrefix: '', sourceFiles: 'pipeline.yml')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: false)])
            }
        }
        stage('远程执行k8s-master的kubectl命令') {
            steps {
               sh '''ssh root@192.168.11.201 kubectl apply -f /usr/local/k8s/pipeline.yml
                ssh root@192.168.11.201 kubectl rollout restart deployment pipeline -n test'''
            }
        }

    }
    post {
        success {
            dingtalk(
                robot: 'Jenkins-DingDing',
                type: 'MARKDOWN',
                title: "success: ${JOB_NAME}",
                text: ["- 成功构建：${JOB_NAME}! \n- 版本：latest \n- 持续时间：${currentBuild.durationString}" ]
            )
        }
        failure {
            dingtalk(
                robot: 'Jenkins-DingDing',
                type: 'MARKDOWN',
                title: "success: ${JOB_NAME}",
                text: ["- 构建失败：${JOB_NAME}! \n- 版本：latest \n- 持续时间：${currentBuild.durationString}" ]
            )
        }
    }
}

修改pipeline.yaml，更改镜像版本

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: test
  name: pipeline
  labels:
    app: pipeline
spec:
  replicas: 2
  selector:
    matchLabels:
      app: pipeline
  template:
    metadata:
      labels:
        app: pipeline  
    spec:
      containers:
      - name: pipeline
        image: 192.168.11.102:80/repo/pipeline:latest   # 这里
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
# 省略部分内容…………
10.6.3 滚动更新

因为pipeline没有改变时，每次不会重新加载，这样会导致Pod中的容器不会动态更新，这里需要使用kubectl的rollout restart命令滚动更新

dfdc52091fe041a784adda4c398b74b3

a91b7128c5804ee19044dd4eff76cc00

灯火烛光
关注
  • 11
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
玩转CVM：Gitlab安装搭建
腾讯云服务器
01-25 264
本教程将讲解如何依托腾讯云主机(CVM)，以Docker方式搭建Gitlab服务。具体将包括：Docker安装，Gitlab安装与配置，Gitlab的开发流程示例，以及基于Gitlab的持续集成(CI/CD)的介绍。 Gitlab简介 Gitlab 是完整的一套DevOps工具，开发人员可以通过它方便地进行管理项目、源码管理、持续集成/部署、开发文档维护甚至安全监控等工作，而这些重要工作涉及了软件的整个开发周期。 Gitlab的代码提交模式完全兼容Git，而合作模式又类似Github，Gitlab中的Mer
DevOps上玩转Kubernetes共21页.pdf.z
11-09
【标题】"DevOps上玩转Kubernetes共21页.pdf" 提供的是一份关于在DevOps实践中应用Kubernetes的详细指南。Kubernetes（通常称为K8s）是目前最流行的容器编排系统，它使得部署、管理和扩展微服务化应用程序变得更为...
五个数据库性能指标让你轻松玩转DevOps
weixin_33834910的博客
08-02 434
我们都知道数据库的性能调整相当重要，但难度也较大。数据库管理员只有认真分析数据库运行过程当中出现的各种性能问题，才能保证数据库高效稳定地运行。然而，数据库的性能调整是一个系统工程，涉及的方面很多，不能仅仅根据一个时间点的情况就断定数据库运行性能的好与坏。数据库管理员需要经过反反复复的过程才能进行有效地调整。这些都需要在大量的实践工作中不断地积累经验，从而...
C#与Azure DevOps：手把手教你玩转CI/CD自动化
java专栏
07-04 869
恭喜你，亲爱的朋友！你已经成功地创建了一个从代码提交到自动部署的完整CI/CD流程。Azure DevOps和C#的结合就像魔法一样，让软件开发变得更加高效和有趣。希望这篇文章能帮你在编程的旅途中迈出坚实的一步，继续前进，未来无限可能！如果你在操作过程中遇到任何问题，不要忘了查阅Azure DevOps的官方文档，那里有更详细的指导。祝你编程愉快，再见啦！👋。
没有Docker还能玩转DevOps吗？
cpongo011702
11-27 166
启迪云-解决方案部蒋运龙企业应用程序开发正处于从瀑布模型的传统方式向强调快速迭代和持续交付的更敏捷的方法过渡- 即所谓的DevOps模型。与DevOps密切相关的关键技术是容器，或者至少是Docker的容器模型：代码被部署到单独的沙盒环境中执行，每个环境都有自己的资源限制。通过将应用程序分解为离散组件，可以单独部署和维护这些组件，并在条件需求时单独扩展。这种方法称为微服务。网络链接微服务架构成功的...
6 张图带你搞懂 DevOps 与 CI/CD
easylife206的专栏
02-09 1138
公众号关注「奇妙的 Linux 世界」设为「星标」，每天带你玩转 Linux ！DevOpsDevOps是Development和Operations的组合，是一种方法论，是一组过程、方...
DevOps的发展史
easylife206的专栏
02-25 710
公众号关注「奇妙的 Linux 世界」设为「星标」，每天带你玩转 Linux ！—1—可操作的概述多亏了云计算和开源，软件开发的速度从几年缩短到几个月。每家公司都在向一个软件公司转变。DevOps 已迅速成为公司大规模开发和部署软件的最有效方式。DevOps 是将成熟的工作流和工具应用于软件开发生命周期的过程。Amazon、Adobe 和 Netflix 等领先公司都有成熟的 DevOps ...
快来技术中台吧 带你轻松玩转Node.js
bcltb04468的专栏
07-02 406
前言　　用友云技术中台——开发者中心提供对开发态以及运行态的全面支持，它可以看成是开发者的云、运维人员的云、DevOps的云、行业领域的云、支持创新的云。它是一个应用全生命周期的管理平台，底层基于容器技术（Docker），正在快速改变着公司和用户创建、发布和运行分布式应用的方式。　　DevOps的理念使得软件行业日益清晰地认识到，为了按时交付软件产品和服务，开发、运维和运营工作必须紧密合作。用友云...
学习一下什么是SRE和DevOps
yongwan5637的博客
06-04 995
DevOps 和 SRE 最近有一位朋友和我聊职业发展方向问题，聊了不少 DevOps 和 SRE 话题。 我几年前刚接触这两个概念时也常常将之混淆，可惜当时没有人来解答我困惑。 现在这虽然已经极为流行，但是我发现我这位朋友对这两个职位还存在一些误区。 于是我给了一些见解并整理成文章以饕大众。 最常见的误区： DevOps 新概念，好高级哦 SRE 是高级版 DevOps 运维可以轻松转...
45 个常用Linux 命令，让你轻松玩转Linux！
alss13237的博客
09-03 346
Linux 的命令确实非常多，然而熟悉 Linux 的人从来不会因为 Linux 的命令太多而烦恼。因为我们仅仅只需要掌握常用命令，就完全可以驾驭 Linux。 接下来，让我们一起来看看都有那些常用的 Linux 命令吧！ 一、文件目录操作 1. ls 命令 ls 命令不仅可以查看 linux 文件夹包含的文件而且可以查看文件权限(包括目录、文件夹、文件权限)查看目录信息等等。 命令格式...
度量驱动的DevOps转型
02-25
虚拟化，容器化，云计算，自动化为DevOps运动提供了底层技术支持，新的工具链和技术栈的采用进一步降低了DevOps的技术门槛，越来越多的企业纷纷开始自己的DevOps转型之路，然而……本次分享我们将会讨论到：DevOps...
你所不了解的DevOps
01-27
【DevOps的理解与重要性】 DevOps是一种组织文化、实践和工具的集合，旨在通过加强开发（Development）和运维（Operations）之间的合作，提高软件交付的速度和质量。它并不是一个具体的框架、工具或技术，而是一种...
创业团队如何选择DevOps工具？
GitLab 中国发行版
07-25 980
极狐GitLab SaaS 团队版详解！
在KubeSphere 容器中快速部署使用 GitLab 并构建 DevOps 项目
最新发布
petaexpress的博客
07-26 729
GitLab的初始密码被作为Secret保存，我们可以回到项目首页，在「配置」下的「保密字典」中搜索initial可以找到gitlab-initial-root-password的条目。通过「确定」按钮保存凭证后回到「选择代码面板」，在「凭证」下拉框中选择刚刚创建的gitlab-root，然后在「项目组/所有者」文本库中填入我们的账号root，点击「代码仓库」下拉框可看到root账号下所有的代码仓库，这里我们可以看到并选择之前创建的示例项目root/rak-test-express。答案是肯定的：可以！
前后端都用得上的 Nginx 日常使用经验
我不懂，可我不傻
07-26 602
nginx 是一个高性能的开源反向代理服务器和 web 服务器，一般用来搭建静态资源服务器、负载均衡器、反向代理，本文将分享其在 Windows/docker 中的使用,使用 nssm 部署成服务的方案脚本，局域网中自定义域名解决https提示不安全的解决方案，以及一路踩过的坑。将前文 Windows 的配置部分修改到 default.conf 如下所示server {listen 80;aNULL:!MD5;
参加可观测性Observability Foundation认证培训，您有哪些收益？
weixin_46959162的博客
07-24 759
可观测性认证培训专注于SRE（站点可靠性工程）和全栈可观测性。课程内容涵盖应用程序生命周期中的核心概念和实践，包括事件、指标、跟踪和上下文。学员将学习构建智能异常检测和根因定位能力，提升故障处理、业务洞察和跨职能协作能力。培训包括实践案例和工具的使用，重点介绍云原生应用程序的全栈度量、事件、日志和分布式跟踪，以及网络和安全可观测性的关键作用。最终，学员可获得由PeopleCert和DevOps Institute颁发的国际认证。
浅谈Devops
小男孩儿的博客
07-24 621
DevOps（Development和Operations的混合词）是一种重视“软件开发人员（Dev）”和“IT运维技术人员（Ops）”之间沟通合作的文化、运动或惯例。通过自动化“软件交付”和“架构变更”的流程，来使得构建、测试、发布软件能够更加地快捷、频繁和可靠。
【DevOps系列】构建Devops系统
u013379032的博客
07-23 1033
那就着手开始干吧。先介绍一下我们的工具链。主要工具：GitHub、Jenkins、Kubernetes、Ansible、Prometheus和JMeter。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值