Devops

一、devops介绍

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

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

这看似两个目标不同的团队需要协同完成一个软件的开发。

在开发团队指定好计划完成coding后，需要提供到运维团队。

运维团队向开发团队反馈需要修复的BUG以及一些需要返工的任务。

这时开发团队需要经常等待运维团队的反馈，这无疑延长了事件并推迟了整个软件开发的周期。

会有一种方式，在开发团队等待的时候，让开发团队转移到下一个项目中，等待运维团队之前的代码提供反馈。

可是这样就意味着一个完整的项目需要一个更长的周期才能开发出最终代码。

---

基于现在的互联网现状，更推崇敏捷式开发，这样就导致项目的迭代速度更快，但是由于开发团队与运维团队的沟通问题，会导致新版本上线的时间成本很高，这又违背的敏捷式开发的最初的目的。

那么如果让开发团队和运维团队整合到成一个团队，协同应对一套软件呢？这就被称为DevOps。

DevOps，字面意思是Development & Operations的缩写，就是运维&开发。

虽然字面意思只涉及到了开发团队合运维团队，其实QA测试团队也是参与其中的。

网上可以查看到DevOps的符号类似于一个无穷大的符号

这表明DevOps是一个不断提高效率并且持续不断工作的过程

DevOps的方式可以让公司能够更快地应对更新和市场发展变化，开发可以快速交付，部署也更加稳定。

核心就在于简化Dev和Ops团队之间德流程，使整体软件开发过程更快速。

整体的软件开发流程：

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

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

这表明DevOps是一个不断提高效率并且持续不断工作的过程

DevOps的方式可以让公司能够更快地应对更新和市场发展变化，开发可以快速交付，部署也更加稳定。

核心就在于简化Dev和Ops团队之间德流程，使整体软件开发过程更快速。

整体的软件开发流程：

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

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

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

二、准备环境

1、安装jdk

本次我们安装的是JDK11是因为jenkins新版本最低要求是11

jdk下载地址：https://download.oracle.com/otn/java/jdk/11.0.24%2B7/21cffd70ff1e41a3a5ef9898f46e442d/jdk-11.0.24_linux-x64_bin.tar.gz

把下载的jdk上传到服务器

[root@jenkins ~]# mkdir -p /opt/environment
[root@jenkins ~]# tar -zxvf jdk-11.0.24_linux-x64_bin.tar.gz -C /opt/environment/

配置jdk环境变量

[root@jenkins ~]# vim /etc/profile
添加到最后
# Set java environment
JAVA_HOME=/opt/environment/jdk-11.0.24
PATH=$PATH:$JAVA_HOME/bin
export JAVA_HOME PATH

[root@jenkins ~]# source /etc/profile
[root@jenkins ~]# java -version
java version "11.0.24" 2024-07-16 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.24+7-LTS-271)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.24+7-LTS-271, mixed mode)

2、 安装Maven

# 下载Maven
[root@jenkins ~]# wget https://archive.apache.org/dist/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz

# 解压Maven
[root@jenkins ~]# tar -zxvf apache-maven-3.8.8-bin.tar.gz -C /opt/environment

# 配置jar包存放位置
[root@jenkins ~]# vim /opt/environment/apache-maven-3.8.8/conf/settings.xml 
# 在55行添加
<localRepository>/opt/environment/apache-maven-3.8.8/repository</localRepository>

因为maven的默认依赖下载地址是国外的maven官方地址，下载依赖的时候可能下载过慢甚至下载失败，所以我们需要将下载地址改为国内的阿里云地址，找到 mirrors 标签，然后在下面新增一个 mirror 配置项，加入代码：

<mirror>
  <id>alimaven</id>
  <name>aliyun maven</name>
  <url>https://maven.aliyun.com/repository/public</url>
  <mirrorOf>central</mirrorOf>
</mirror>

# 配置Maven环境变量
[root@jenkins ~]# vim /etc/profile

文件最后添加
# Set maven environment
MAVEN_HOME=/opt/environment/apache-maven-3.8.8
PATH=$PATH:$MAVEN_HOME/bin
export MAVEN_HOME PATH

生效一下
[root@jenkins ~]# source /etc/profile

 3、安装docker

# 下载docker的安装包
wget https://download.docker.com/linux/static/stable/x86_64/docker-20.10.7.tgz

[root@jenkins ~]#  tar -zxvf docker-20.10.7.tgz
[root@jenkins ~]# mv docker/* /usr/bin
[root@jenkins ~]# rm -rf docker-20.10.7.tgz
[root@jenkins ~]# rm -rf docker


# system管理docker
cat > /usr/lib/systemd/system/docker.service << EOF
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target
EOF

配置镜像地址：不能配置阿里的，我使用的阿里的镜像加速是不行了

[root@jenkins ~]# mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors": [
        "https://do.nark.eu.org",
        "https://dc.j8.work",
        "https://docker.m.daocloud.io",
        "https://dockerproxy.com",
        "https://docker.mirrors.ustc.edu.cn",
        "https://docker.nju.edu.cn"
    ]
}
EOF
[root@jenkins ~]# systemctl daemon-reload
[root@jenkins ~]# systemctl start docker && systemctl enable docker

4、安装git

[root@jenkins ~]# yum -y install git

5、安装jenkins

这次我准备的是最新稳定版的jenkins下载地址，根据官方文档显示，最新的稳定版本支持的最低jdk版本为jdk11，所以这也是之前要安装jdk11的原因：

# 下载依赖
[root@jenkins ~]# yum install -y fontconfig

# 下载安装包
[root@jenkins ~]# wget https://mirrors.jenkins.io/redhat-stable/jenkins-2.401.2-1.1.noarch.rpm


# 创建jenkins工作目录
[root@jenkins ~]# mkdir -p /opt/server/jenkins

[root@jenkins ~]# mv jenkins-2.401.2-1.1.noarch.rpm /opt/server/jenkins/
[root@jenkins ~]# cd /opt/server/jenkins/
[root@jenkins jenkins]# rpm -ivh jenkins-2.401.2-1.1.noarch.rpm 


# 修改jenkins的Javahome
vim /usr/lib/systemd/system/jenkins.service
51行 

修改启动用户不然会有权限问题

vim /usr/lib/systemd/system/jenkins.service

设置用户数组

[root@jenkins jenkins]# chown -R root:root /var/lib/jenkins/ && chown -R root:root /var/cache/jenkins/ && chown -R root:root /var/log/jenkins/

[root@jenkins jenkins]# systemctl daemon-reload

[root@jenkins jenkins]# systemctl start jenkins
[root@jenkins jenkins]# systemctl enable jenkins

6、初始化jenkins

根据提示查看密码

安装 

安装完成后我们需要创建第一个管理员用户，按照提示填写内容后我们直接点击保存并完成

然后来到jenkins主页

点击Manage Jenkins然后点击Plugins，我们需要在安装一些插件

搜索：

1. Git Parameter
2. Maven Integration

 设置jdk

我们继续忘下面找找到Maven的配置地方点击新增Maven

点击系统配置

选择环境变量

应用，保存

先点击应用，在点击保存，到这里就初始化完成了。

7、准备JAVA项目

注意pom文件的<skip>true</skip>

一定要删除或者注释掉

完整的pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.greateme</groupId>
    <artifactId>Devops</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Devops</name>
    <description>Devops</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--添加maven-plugin-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.6.13</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <!--打包name定义-->
        <finalName>${artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.greateme.devops.DevopsApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

访问测试

8、准备gitlab

GitLab最少4内存，4CPU，不然带不起来

上传软件包

# 安装依赖
[root@gitlab ~]# yum install -y curl policycoreutils openssh-server openssh-clients postfix policycoreutils-python cronie

# 安装
[root@gitlab ~]# rpm -ivh gitlab-ce-12.0.2-ce.0.el7.x86_64.rpm

# 配置访问地址

[root@gitlab ~]# vim /etc/gitlab/gitlab.rb

# 修改完重启gitlab
[root@gitlab ~]# gitlab-ctl reconfigure

 登录gitlab

日志位置：/var/log/gitlab 可以进去查看访问日志以及报错日志等，供访问查看以及异常排查。
gitlab-ctl tail #查看所有日志
gitlab-ctl tail nginx/gitlab_access.log #查看nginx访问日志

关闭 gitlab： # gitlab-ctl stop
启动 gitlab： # gitlab-ctl start
重启 gitlab： # gitlab-ctl restart
gitlab 主配置文件：/etc/gitlab/gitlab.rb #可以自定义一些邮件服务等
日志地址：/var/log/gitlab/  #对应各服务
服务地址：/var/opt/gitlab/  #对应各服务的主目录
仓库地址：/var/opt/gitlab/git-data #记录项目仓库等提交信息

9、汉化Gitlab

我们这里安装的是v12版本的gitlab，下载v12的汉化包（注：版本要对应）

https://gitlab.com/xhang/gitlab/-/archive/12-0-stable/gitlab-12-0-stable-zh.tar.gz

[root@gitlab ~]# tar -zxvf gitlab-12-0-stable-zh.tar.gz
# 停止gitlab
[root@gitlab ~]# gitlab-ctl stop

# 开始汉化
[root@gitlab ~]#  \cp -rf  gitlab-12-0-stable-zh/* /opt/gitlab/embedded/service/gitlab-rails/

# 开启gitlab
[root@gitlab ~]# gitlab-ctl restart

关闭注册功能

Save changes

配置邮箱报警

[root@gitlab ~]# vim /etc/gitlab/gitlab.rb #57行后添加以下内容

 gitlab_rails['smtp_enable'] = true
  gitlab_rails['smtp_address'] = "smtp.163.com"  #SMTP服务器
  gitlab_rails['smtp_port'] = 465
  gitlab_rails['smtp_user_name'] = "guoweijiemail@163.com" #邮箱账号
  gitlab_rails['smtp_password'] = "nihao123" #客户端授权码，注意：此为163邮箱设置的客户端授权码，授权码是用于登录第三方邮件客户端的专用密码。
  gitlab_rails['smtp_authentication'] = "login"
  gitlab_rails['smtp_enable_starttls_auto'] = true
  gitlab_rails['smtp_tls'] = true
  gitlab_rails['gitlab_email_from'] = '你的邮箱' #发邮件的邮箱地址

# 重载gitlab
[root@gitlab ~]# gitlab-ctl reconfigure

# 登录邮件控制台
[root@gitlab ~]# gitlab-rails console
Notify.test_email('guoweijiemail@163.com','test','hello world').deliver_now

创建群组

创建一个用户

将新建的用户添加到组里

 去邮箱设置密码

用新用户登录，并创建项目

 10、用idea项目连接gitlab

在idea的控制台

PS D:\Java-code\Devops> git init
PS D:\Java-code\Devops> git remote add origin http://192.168.1.11/guoweijie/devops.git
PS D:\Java-code\Devops> git add --all
PS D:\Java-code\Devops> git config --global user.email "guoweijiemail@163.com"
PS D:\Java-code\Devops> git config --global user.name "guoweijie"
PS D:\Java-code\Devops> git commit -m 'init commit'
PS D:\Java-code\Devops> git push origin master


# 生成密钥
PS D:\Java-code\Devops> ssh-keygen -t rsa  一路回车

 11、创建dockerfile

首先需要在pom.xml文件中定义jar包的规范

执行package

看到package的名字

 创建dockerfile文件

dockerfile文件

# 使用openjdk11做基础镜像
FROM openjdk:11-jre

# 作者
MAINTAINER gwjcloud

# 将可执行的jar包放到容器当中去
ADD java/Devops.jar app.jar

# 暴露8080端口
EXPOSE 8080

# JVM 调优参数
ENV JAVA_OPTION="-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"

# JVM 内存默认值
ENV XMX=128m
ENV MXS=128m
ENV XMN=64m

# 运行程序
ENTRYPOINT ["sh", "-c",  "java -Djava.security.egd=file:/dev/./urandom -jar -Xmx${XMX} -Xms${MXS} -Xmn${XMN} $JAVA_OPTION /app.jar"]

 12、生成ssh-key

[root@jenkins ~]# git config --global user.name "gwjcloud"
[root@jenkins ~]# git config --global user.email "gwjcloud@163.com"
[root@jenkins ~]# ssh-keygen -t rsa -C "JenkinsServer"

查看公钥

[root@jenkins ~]# cat .ssh/id_rsa.pub

然后把内容配置到gitlab上面

在jenkins服务器上面测试，是否能免密码拉取代码

[root@jenkins ~]# git clone git@192.168.1.11:guoweijie/devops.git

[root@jenkins ~]# ls
anaconda-ks.cfg  devops

可以看到没问题的

13、创建jenkinsfile

pipeline {
    agent any

    stages {
        stage('Hello') {
            steps {
                echo 'Hello World'
            }
        }
    }
}

14、创建流水线

参数化构建过程——git参数

15、提交代码并打tag

推送并提交

PS D:\Java-code\devops> git tag -a v1.0.0 -m "New Version"
PS D:\Java-code\devops> git push origin v1.0.0

打开gitlab看一下tag

 打开jenkins页面点击

Build with Parameters

 看构建过程

三、流水线构建

• 切换到我们指定的版本
• 通过maven构建项目
• 将构建好的maven项目打成Docker镜像
• 推送Docker镜像到镜像仓库
• 通过远程连接部署到Kubernetes上面

1、jenkinsfile切换代码仓库到指定版本

最下面找到流水线语法

选择checkout: Check out from version control

点击生成流水线脚本会出现脚本

打开开发工具Idea，修改Jenkinsfile文件

把上面的改成Checkout From Git

中间的是生成的流水线脚本

2、通过Maven构建项目

继续使用脚本生成器来生成脚本，按照提示并

选择：sh: Shell Script

mvn clean package -Dmaven.test.skip
mkdir docker/java
mv target/Devops.jar docker/java
mvn clean

 修改Jenkinsfile

pipeline {
    agent any

    stages {
        stage('Checkout From Git') {
            steps {
                checkout scmGit(branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'git@192.168.1.11:guoweijie/devops.git']])
            }
        }
        stage('Build By Maven'){
            steps {
                sh '''mvn clean package -Dmaven.test.skip
                mkdir docker/java
                mv target/Devops.jar docker/java
                mvn clean'''
            }
        }
    }
}

 提交一下代码

打开Jenkins测试一下

3、使用阿里云镜像仓库来构建镜像

首先我们需要将Docker仓库准备好，来到阿里云新建一个仓库，选择个人实例

 创建命名空间

创建镜像仓库

 创建RAM用户来使容器镜像服务

添加权限

使用RAM账户登录阿里云，并开通容器镜像服务

在jenkins服务器上面执行登录阿里云的docker Registry

继续使用jenkins的脚本生成器来生成脚本

cd docker
docker build -t registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:${tag}
rm -rf java

在Jenkinsfile中新增一个阶段Build By Docker 将生成的脚本复制进去

pipeline {
    agent any

    stages {
        stage('Checkout From Git') {
            steps {
                checkout scmGit(branches: [[name: '${tag}']], extensions: [], userRemoteConfigs: [[url: 'git@192.168.1.11:guoweijie/devops.git']])
            }
        }
        stage('Build By Maven'){
            steps {
                sh '''mvn clean package -Dmaven.test.skip
                mkdir docker/java
                mv target/Devops.jar docker/java
                mvn clean'''
            }
        }
        stage('Build By Docker'){
            steps {
                sh '''cd docker
                docker build -t registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:${tag} .
                rm -rf java'''
            }
        }
    }
}

提交代码略

用find找到pip脚本创建的java目录，把他删除，不然会报错的

开始jenkins构建

可以看到logs有镜像生成

jenkins服务器查看镜像

 4、将镜像推送到阿里云仓库

docker push registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:${tag}
docker rmi -f registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:${tag}

在jenkins服务中添加

推送gitlab略

删除镜像

 记得在jenkins服务器上登录

 再次构建

 四、准备kubernetes集群

1、服务器列表

服务器名称	IP地址	配置	用途
k8s-master	192.168.1.20	2c2g20g	主节点
k8s-node01	192.168.1.21	2c2g20g	工作节点1
k8s-node02	192.168.1.22	2c2g20g	工作节点2

关闭防火墙，selinux略

 2、同步时间（all服务器）

[root@k8s-master ~]# yum -y install chrony
[root@k8s-master ~]# systemctl enable --now chronyd
[root@k8s-master ~]# vim /etc/chrony.conf
1 # Use public servers from the pool.ntp.org project.
  2 # Please consider joining the pool (http://www.pool.ntp.org/join.html).
  3 #server 0.centos.pool.ntp.org iburst
  4 #server 1.centos.pool.ntp.org iburst
  5 #server 2.centos.pool.ntp.org iburst
  6 #server 3.centos.pool.ntp.org iburst
  7 server ntp1.aliyun.com iburst
[root@k8s-master ~]# systemctl restart chronyd

3、关闭swap分区和添加主机映射

[root@k8s-master ~]# swapoff -a
[root@k8s-master ~]# sed -ri 's/.*swap.*/#&/' /etc/fstab

[root@k8s-master ~]# vim /etc/hosts
192.168.1.20 k8s-master
192.168.1.21 k8s-worker01
192.168.1.22 k8s-worker02

4、加载br_netfilter模块（all）

由于开启内核 ipv4 转发需要加载 br_netfilter 模块，所以加载下该模块，但是这个模块不会默认加载，所以我们开启后还要设置开机自动加载这个模块

# 设置开机自动加载这个模块
cat >> /etc/rc.d/rc.local << EOF
/usr/sbin/modprobe br_netfilter
EOF
chmod +x /etc/rc.d/rc.local
# 立刻加载
modprobe br_netfilter

5、桥接的ipv4流量传递给iptables（all）

cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sysctl --system

6、安装ipset和ipvsadm（all）

请求多的时候可能会导致响应过慢，安装这两个软件能够在一定程度上提升ipvs转发速度

[root@k8s-master ~]# yum install -y ipset ipvsadm

cat > /etc/sysconfig/modules/ipvs.modules << EOF
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack
EOF

7、安装containerd（all）

下载地址：https://github.com/containerd/containerd/releases/download/v1.6.21/cri-containerd-cni-1.6.21-linux-amd64.tar.gz

上传到每台服务器上的/usr/local/src/下面

解压
[root@k8s-master src]# tar -zxvf cri-containerd-cni-1.6.21-linux-amd64.tar.gz -C /

查看版本号：[root@k8s-master src]# containerd -version



# 生成配置文件
[root@k8s-master ~]# mkdir /etc/containerd
[root@k8s-master ~]# containerd config default > /etc/containerd/config.toml

配置文件(/etc/containerd/config.toml)需要将 sandbox_image 的版本号改一下版本号和镜像地址，因为默认的镜像地址是在谷歌上的，谷歌国内访问不到

默认值：sandbox_image = “registry.k8s.io/pause:3.6”

目标值：sandbox_image = “registry.aliyuncs.com/google_containers/pause:3.9”

启动并设置为开机自启动

[root@k8s-master ~]# systemctl enable --now containerd

8、安装runc（all）

containerd自带有runc，但是自带的有些问题，所以我们还需要特意安装一遍稳定版的runc

[root@k8s-master ~]# runc

runc: symbol lookup error: runc: undefined symbol: seccomp_notify_respond

需要下载gperf，因为自己的服务器yum下不到这个包所以要使用这种方法；看文档：【腾讯文档】自制repo包

使用腾讯云或者阿里云的服务器

腾讯文档

使用yum指定安装

[root@k8s-master ~]# yum -y install gperf/gperf-3.0.4-8.el7.x86_64.rpm

下载libseccomp地址：

https://github.com/opencontainers/runc/releases/download/v1.1.7/libseccomp-2.5.4.tar.gz

/usr/local/src下面

[root@k8s-master src]# tar -zxvf libseccomp-2.5.4.tar.gz

[root@k8s-master src]# yum install -y gcc gcc-c++ 
[root@k8s-master src]# cd libseccomp-2.5.4
[root@k8s-master libseccomp-2.5.4]# ./configure 
[root@k8s-master libseccomp-2.5.4]# make && make install

查看是否安装成功

下载runc

地址：https://github.com/opencontainers/runc/releases/download/v1.1.7/runc.amd64

到：/usr/local/src下面

[root@k8s-master src]# rm -rf /usr/local/sbin/runc
[root@k8s-master src]# chmod +x runc.amd64
[root@k8s-master src]# mv runc.amd64 /usr/local/sbin/runc

 9、安装k8s（all）

配置k8s的yum源

cat <<EOF > /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

#安装阿里源
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

#安装epel源
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

#清除缓存并生成新的缓存
yum clean all && yum makecache

[root@k8s-master ~]# yum install -y kubeadm-1.26.5 kubectl-1.26.5 kubelet-1.26.5

[root@k8s-master ~]# systemctl enable kubelet

10、配置Cgroup启动更改为systemd（all）

[root@k8s-master ~]# sed -i 's/KUBELET_EXTRA_ARGS=/KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"/g' /etc/sysconfig/kubelet

11、初始化集群（master节点）

下载离线镜像

链接：https://pan.baidu.com/s/1-ILbg0GG8jNHQhVaVhUKww?pwd=kfe2

提取码：kfe2

上传到master服务器

解压

[root@k8s-master ~]# tar -zxvf k8s-image.tar.gz

需要使用文件传输命令把 k8s-node.tar.gz 传输到所有的node上：

如果没有这个命令空间需要创建all服务器

[root@k8s-master ~]# ctr ns create k8s.io

master导入镜像

[root@k8s-master ~]# ctr -n k8s.io image import k8s-master.tar.gz

worker导入镜像

[root@k8s-worker01 ~]# ctr -n k8s.io image import k8s-node.tar.gz

master初始化

[root@k8s-master ~]# kubeadm init --apiserver-advertise-address=192.168.1.20 --image-repository registry.aliyuncs.com/google_containers --kubernetes-version v1.26.5 --service-cidr=10.96.0.0/12 --pod-network-cidr=10.244.0.0/16

[root@k8s-master ~]# mkdir -p $HOME/.kube
[root@k8s-master ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@k8s-master ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

 12、工作节点加入集群（worker01，worker02）

远程执行的代码需要改一下，需要加上 --cri-socket=unix:///var/run/containerd/containerd.sock所以执行：

[root@k8s-worker02 ~]# kubeadm join 192.168.1.20:6443 --token swhy5s.uckong39hcyfuz59 --discovery-token-ca-cert-hash sha256:71717f742f2a48e1efb05bdbd48c3f65a26d3a223def2e529149ff1776230fa0 --cri-socket=unix:///var/run/containerd/containerd.sock

设置开机自启动

[root@k8s-master ~]# systemctl enable --now kubelet

13、安装Calico网络插件（master）

[root@k8s-master ~]# kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.1/manifests/tigera-operator.yaml

安装Calico

cat <<EOF > custom-resources.yaml
apiVersion: operator.tigera.io/v1
kind: Installation
metadata:
  name: default
spec:
  calicoNetwork:
    ipPools:
    - blockSize: 26
      cidr: 10.244.0.0/16
      encapsulation: VXLANCrossSubnet
      natOutgoing: Enabled
      nodeSelector: all()

---

apiVersion: operator.tigera.io/v1
kind: APIServer
metadata:
  name: default
spec: {}
EOF

[root@k8s-master ~]# kubectl create -f custom-resources.yaml

14、安装MetaILB负载均衡器（master）

metallb是用于kubernetes的Service暴露LoadBalancer的负载均衡器

kubectl edit configmap -n kube-system kube-proxy

root@k8s-master ~]# kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.9/config/manifests/metallb-native.yaml

五、部署到kubernetes

1、尝试手动部署

首先我们使用yaml的方式部署到kubernetes，先创建一个secret保存Docker的登陆信息：

# 注意修改自己对应的信息
[root@k8s-master ~]# kubectl create secret docker-registry devops-secret --docker-server='registry.cn-hangzhou.aliyuncs.com' --docker-username='devops@1013754841765121' --docker-password='Aq123456' --docker-email='guoweijiemail@163.com' --dry-run -o yaml >> deploy-devops.yaml

然后我们再生成一个Deployment部署这个java程序，生成之前需要现在deploy-devops.yaml后面加上 ---，因为需要分开两段yaml，如图：

# 生成yaml文件 注意替换自己的信息
[root@k8s-master ~]# kubectl create deployment devops-example --image=registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:v1.0.0 --replicas=1 --port=8080 --dry-run -o yaml >> deploy-devops.yaml

在yaml文件中添加自己的secret信息

[root@k8s-master ~]# kubectl apply -f deploy-devops.yaml

[root@k8s-master ~]# kubectl get pod -o wide
NAME                              READY   STATUS    RESTARTS   AGE    IP             NODE           NOMINATED NODE   READINESS GATES
devops-example-56f7597746-kh2tn   1/1     Running   0          6m5s   10.244.79.82   k8s-worker01   <none>           <none>
[root@k8s-master ~]# curl 10.244.79.82:/devops
curl: (7) Failed connect to 10.244.79.82:80; Connection refused
[root@k8s-master ~]# curl 10.244.79.82:8080/devops
Hello DevOps --- V1.0.0[root@k8s-master ~]# 

接下来暴漏端口给外部访问，也是生成yaml文件

[root@k8s-master ~]# vim deploy-devops.yaml

[root@k8s-master ~]# kubectl expose deployment devops-example --name=devops-example-svc --port=8080 --target-port=8080 --type=NodePort -o yaml --dry-run >> deploy-devops.yaml

执行这个yaml文件
[root@k8s-master ~]# kubectl apply -f deploy-devops.yaml 

通过这个端口，集群的任意一个节点加端口都可以访问

 2、jenkins自动完成kubernetes部署

需要在Jenkins上面新安装一个插件

publish over ssh

配置远程服务器

应用保存

重启jenkins

[root@jenkins ~]# systemctl restart jenkins

使用流水线脚本来配置

kubectl set image deployment devops-example devops-example=registry.cn-hangzhou.aliyuncs.com/devops-gwjcloud/devops-example:${tag} --record

把生成的流水线脚本放到jenkinsfile文件中

推送并提交

测试修改代码并通过流水线构建

提交到gitlab

打标签并推送

PS D:\Java-code\devops> git tag -a v1.1.0 -m 'Version v1.1.0'
PS D:\Java-code\devops> git push origin v1.1.0

成功

可以看到镜像切换完成

访问测试

点击v1.0.0构建看看会发生什么

成功回退

要注意的是：jenkins是根据tag之前的代码来进行拉取的，如果你刚刚打完tag，后提交的代码是不会生效的。要重新打tag版本，在次构建才会生效！