云计算百科
云计算领域专业知识百科平台

DevOps 进阶 Kubernetes 与 DevOps 整合实战:K8s 集群搭建 + Jenkins 自动部署 Pipeline 应用

/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}

【DevOps 进阶】Kubernetes 与 DevOps 整合实战:K8s 集群搭建 + Jenkins 自动部署 Pipeline 应用

前两章我们把镜像推到了 Harbor,用 docker run 在单机上跑起来。这一章换一种交付方式:让 Kubernetes 接管运行态——Jenkins 只负责构建和推送,kubectl apply 负责让它跑起来、扛住、扩缩容。

阅读导航

  • 先补上上期彩蛋 —— deploy.sh 的幂等优化,让闭环完美收口
  • 为什么从 docker run 走向 Kubernetes —— 两种交付方式对比
  • 集群规划与环境准备 —— hosts / 防火墙 / SELinux / 静态 IP
  • 安装 Docker 与 kubelet —— kuboard 一键脚本,锁定 1.19.5
  • 初始化 Master 节点
  • 加入 Worker 节点
  • 验证集群状态
  • 准备 YAML:Deployment + Service
  • 创建 harbor-secret(最关键的一步)
  • 让所有节点信任 Harbor
  • Jenkins 把 YAML 推到 master
  • Jenkins 免密 SSH 登录 master
  • 流水线增加 kubectl 部署阶段
  • 版本同步:tag、YAML、代码三处对齐
  • 验证结果
  • 踩坑清单
  • 总结

  • 一、先补上上期彩蛋

    上期留了个问题:跑完 pipeline 后 mytest 容器退出了。原因是 deploy.sh 每次执行都 systemctl restart docker,把没有重启策略的容器全带走了。

    优化后的 deploy.sh(在 Jenkins 服务器 /usr/local/docker/jenkins_docker/data/workspace/mytest 下)核心改动就一处——先判断是否配置过,避免重复重启 Docker:

    #! /bin/bash
    harbor_ip=$1
    harbor_repo=$2
    project=$3
    version=$4
    container_port=$5
    host_port=$6

    imageName=$harbor_ip/$harbor_repo/$project:$version
    echo $imageName

    # 如果当前容器正在运行,则删除
    container_id=`docker ps -a | grep ${project} | awk '{print $1}'`
    echo $container_id
    if [ "$container_id" != "" ]
    then
    docker stop $container_id
    docker rm $container_id
    fi

    # 如果当前镜像已存在,则删除
    tag=`docker images | grep ${project} | awk '{print $2}'`
    echo $tag
    if [[ "$tag" =~ "$version" ]]
    then
    docker rmi $imageName
    fi

    # ========== 此处优化:非本地登录镜像仓库,幂等处理 ==========
    if grep -q — "–insecure-registry" /lib/systemd/system/docker.service; then
    echo "已配置过 "
    else
    echo "初次配置 "
    cp /lib/systemd/system/docker.service /lib/systemd/system/docker.service.bak
    sed -i 's|ExecStart=/usr/bin/dockerd -H fd:// –containerd=/run/containerd/containerd.sock|ExecStart=/usr/bin/dockerd -H fd:// –insecure-registry 192.168.100.154 –containerd=/run/containerd/containerd.sock|g' /lib/systemd/system/docker.service
    systemctl daemon-reload && systemctl restart docker
    fi
    docker login -u admin -p harbor123 $harbor_ip
    # ==========================================================

    # 拉取镜像
    docker pull $imageName
    # 运行容器
    docker run -d -p $host_port:$container_port –name $project $imageName
    echo "SUCCESS"

    关键就是这三行判断:

    if grep -q — "–insecure-registry" /lib/systemd/system/docker.service; then
    echo "已配置过 "
    else
    ... 配置 + 重启 ...
    fi

    为什么这样改就解决了彩蛋问题:–insecure-registry 是一次性配置,第一次部署时改一次、重启一次 Docker 就够了;之后每次部署走 else 分支,不再重启 Docker,那些没设 –restart 策略的老容器(比如 mytest)自然不会被误伤。

    这就是运维脚本里非常重要的一个原则:幂等(Idempotent)——同一个脚本执行一次和执行一百次,结果应该一样,副作用也应该只发生一次。

    先运行 mytest,再运行 pipeline,两个容器各自独立存活,闭环才算真正完美。


    二、为什么从 docker run 走向 Kubernetes

    单机 docker run 能跑起来,但一到生产就暴露短板:

    维度docker run(第 3 部方案)Kubernetes(本章方案)
    运行位置 固定某台机器 集群调度,自动选节点
    副本数 手动起几个就是几个 replicas 声明式,自动补齐
    故障恢复 容器挂了就挂了 Pod 挂了自动重建
    滚动升级 先停后起,服务中断 逐个替换,零停机
    自愈/探针 无 liveness / readiness 探针
    服务发现 记 IP + 端口 Service 统一入口,ClusterIP/NodePort
    扩缩容 改脚本重新跑 改 replicas 或 HPA
    配置管理 散落在脚本参数 YAML 声明式,可版本控制

    对我们这条流水线来说,改造点非常小:Jenkins 仍然负责"构建 + 推送镜像",只是把最后一步从"SSH 执行 docker run"换成"SSH 执行 kubectl apply"。交付物从"一条命令"变成了"一份 YAML"。

    Jenkins 构建 → 推送 Harbor → SSH 到 master → kubectl apply -f pipeline.yml
    │
    ▼
    Deployment 拉镜像、起 2 个 Pod
    Service 暴露 NodePort 对外提供访问


    三、集群规划与环境准备

    本章用 1 master + 1 worker 的最小集群(生产建议 3 master):

    角色主机名IP说明
    Master master 192.168.100.145 控制面,kubectl 操作入口
    Worker node1 192.168.100.146 运行业务 Pod

    其他环境信息:

    项值
    系统 CentOS Linux 7 (Core),内核 3.10.0-693.el7.x86_64
    Kubernetes v1.19.5
    容器运行时 docker://19.3.11
    Pod 网段 10.100.0.1/16
    Harbor 192.168.100.154:80(沿用前两章)

    为什么选 1.19? kuboard.cn 的快速安装脚本默认支持 Docker 的版本就是 1.19。从 K8s 1.24 开始,dockershim 被移除,容器运行时需要换成 containerd 或 cri-dockerd。对初学阶段来说,1.19 + Docker 是最省心的组合——你已有的 Docker 知识、docker images / docker ps 排障手段全部还能用。

    3.1 主机名解析

    每台机器把自己的主机名解析到 127.0.0.1(kubelet 相关组件会用到):

    # master 节点
    [root@master ~]# echo "127.0.0.1 $(hostname)" >> /etc/hosts

    # node1 节点
    [root@node1 ~]# echo "127.0.0.1 $(hostname)" >> /etc/hosts

    注意追加的是本机主机名,两台机器分别执行,别在 master 上替 node1 写。

    3.2 关闭防火墙、禁用 SELinux

    # master 与 node1 都执行
    systemctl disable firewalld.service –now
    setenforce 0

    • systemctl disable … –now:既停止当前服务,又取消开机自启(等价于 stop + disable)。
    • setenforce 0:临时把 SELinux 切成 permissive,重启后会恢复。彻底禁用要改配置文件:

    vim /etc/selinux/config
    # SELINUX=disabled

    K8s 组件需要互相通信,防火墙与 SELinux 是新手阶段最常见的"集群起不来"原因,先关掉换确定性。

    3.3 配置固定 IP

    vim /etc/sysconfig/network-scripts/ifcfg-ens33

    master(192.168.100.145):

    TYPE="Ethernet"
    PROXY_METHOD="none"
    BROWSER_ONLY="no"
    BOOTPROTO="static"
    DEFROUTE="yes"
    IPV4_FAILURE_FATAL="no"
    IPV6INIT="yes"
    IPV6_AUTOCONF="yes"
    IPV6_DEFROUTE="yes"
    IPV6_FAILURE_FATAL="no"
    IPV6_ADDR_GEN_MODE="stable-privacy"
    NAME="ens33"
    UUID="f0967cdb-cfb4-4ed8-973b-03a171214395"
    DEVICE="ens33"
    ONBOOT="yes"
    IPADDR="192.168.100.145"
    NETMASK="255.255.255.0"
    GATEWAY="192.168.100.2"
    DNS1="192.168.100.2"

    node1(192.168.100.146):除 UUID 与 IPADDR 外完全相同:

    UUID="6b9a9262-0da7-4fb0-a558-c4680234b273"
    IPADDR="192.168.100.146"

    改完重启网络:

    systemctl restart network
    ip a # 确认 IP 生效
    ping -c 2 192.168.100.145 # 两台机器互 ping 验证

    要点:UUID 每台机器唯一(克隆虚拟机后必须改,否则网络服务异常);BOOTPROTO 必须是 static。


    四、安装 Docker 与 kubelet

    所有节点(master 和 node1)都要装。这里用 kuboard.cn 提供的一键脚本,把镜像源换到国内:

    # 配置镜像加速
    export REGISTRY_MIRROR=https://registry.cn-hangzhou.aliyuncs.com

    # 安装 docker 与 kubelet,指定版本 1.19.5
    curl -sSL https://kuboard.cn/install-script/v1.19.x/install_kubelet.sh | sh -s 1.19.5

    这条命令做了三件事:装 Docker、装 kubelet/kubeadm/kubectl、配好国内镜像源。

    验证:

    docker version
    kubelet –version # Kubernetes v1.19.5

    这一步需要联网,脚本会拉不少包,等待十分钟左右是正常的。如果卡住,先确认 REGISTRY_MIRROR 是否生效、DNS 是否可用。


    五、初始化 Master 节点

    只在 master 节点执行。

    5.1 设置变量

    # master 节点实际 IP(内网 IP)
    export MASTER_IP=192.168.100.145

    # apiserver 的 DNS 名称,可自定义
    export APISERVER_NAME=abner.com

    # Pod 网段,安装完成后由 k8s 创建,物理网络中事先不存在
    export POD_SUBNET=10.100.0.1/16

    重要:export 只在当前 shell 会话有效。新开窗口就必须重新执行这三个 export,否则后面初始化脚本会拿不到参数(这是初学者最常踩的坑之一)。

    5.2 写入 hosts

    echo "${MASTER_IP} ${APISERVER_NAME}" >> /etc/hosts

    worker 节点之后也要写同一条,保证集群内能通过 abner.com 解析到 master。

    5.3 执行初始化

    curl -sSL https://kuboard.cn/install-script/v1.19.x/init_master.sh | sh -s 1.19.5

    初始化完成后会打印出 kubeadm 的完整输出,并且自动配置好 kubectl 的 kubeconfig。

    5.4 检查初始化结果

    # 观察系统组件,需要等到全部 Running
    watch kubectl get pod -n kube-system -o wide

    kube-system 里会有 kube-apiserver、kube-controller-manager、kube-scheduler、etcd、kube-proxy、coredns、flannel 等组件。等全部进入 Running 再继续,尤其是 coredns 和网络插件,没起来后面加节点会失败。

    查看节点状态:

    kubectl get nodes -o wide

    NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
    master Ready master 14m v1.19.5 192.168.100.145 <none> CentOS Linux 7 (Core) 3.10.0-693.el7.x86_64 docker://19.3.11

    STATUS=Ready、ROLES=master、CONTAINER-RUNTIME=docker://…,说明控制面正常。


    六、加入 Worker 节点

    6.1 在 master 上生成 join 命令

    kubeadm token create –print-join-command

    输出形如:

    W0813 21:35:29.086601 90612 configset.go:348] WARNING: kubeadm cannot validate
    component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io]

    kubeadm join abner.com:6443 –token 38699p.691qqnx340kwyhby \\
    –discovery-token-ca-cert-hash sha256:8b595b2d12528ae246fac812343f36bc30eff95bab25832b0e109a949c67dee8

    那条 WARNING 是 kubeadm 的已知提示,不影响使用。token 有效期为 2 小时,过期重新执行这条命令即可。

    6.2 在 worker 节点执行加入

    # 替换为 master 节点的内网 IP
    export MASTER_IP=192.168.100.145

    # 必须与初始化 master 时的 APISERVER_NAME 一致
    export APISERVER_NAME=abner.com

    echo "${MASTER_IP} ${APISERVER_NAME}" >> /etc/hosts

    kubeadm join abner.com:6443 –token 38699p.691qqnx340kwyhby \\
    –discovery-token-ca-cert-hash sha256:8b595b2d12528ae246fac812343f36bc30eff95bab25832b0e109a949c67dee8

    6.3 检查加入结果

    在 master 上等待约 5 分钟:

    kubectl get node

    NAME STATUS ROLES AGE VERSION
    master Ready master 31m v1.19.5
    node1 Ready <none> 2m57s v1.19.5

    两个节点都是 Ready,集群可用。


    七、准备 YAML:Deployment + Service

    因为 YAML 资源文件可以在 k8s 上创建应用 Pod,所以要提前把 YAML 准备好,并让它随项目一起进入 Git 仓库。

    在 GitLab 项目中新建文件 pipeline.yml(推荐放在根目录)。

    地址约定(很重要):本文统一按 Harbor = 192.168.100.154:80、K8s master = 192.168.100.145 来写。原笔记里 secret 和 YAML 中曾出现过 192.168.100.145:80(Harbor 与 master 同机时的写法),而你如果确实把 Harbor 装在 master 上,就把下面所有 154 换成 145 即可——但必须四处同时改:harbor-secret 的 –docker-server、YAML 的 image、各节点 daemon.json 的 insecure-registries、Jenkinsfile 里的 ${hbaddr}。

    先看一份完整的资源清单:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: pipeline
    labels:
    app: pipeline
    spec:
    replicas: 2
    selector:
    matchLabels:
    app: pipeline
    template:
    metadata:
    labels:
    app: pipeline
    spec:
    imagePullSecrets: # 关键:私有仓库拉取凭证
    – name: harbor–secret
    containers:
    – name: pipeline
    image: 192.168.100.154:80/repo/pipeline:v4.0
    imagePullPolicy: Always # 复用同名 tag,必须 Always
    ports:
    – containerPort: 8080
    —
    apiVersion: v1
    kind: Service
    metadata:
    labels:
    app: pipeline
    name: pipeline
    spec:
    selector:
    app: pipeline
    ports:
    – port: 8081
    targetPort: 8080
    type: NodePort

    7.1 三个关键字段,决定了能不能跑起来

    ① imagePullSecrets 与 secret 的对应关系

    imagePullSecrets:
    – name: harbor–secret

    这是"用哪个凭证去私有仓库拉镜像"。kubelet 拉镜像是不认 docker login 保存在 /root/.docker/config.json 里的凭证的(它不读那个文件),所以必须在集群里创建一个 docker-registry 类型的 secret,并在 Pod 模板里引用。没这一步,Pod 一定 ImagePullBackOff。

    ② imagePullPolicy: Always

    imagePullPolicy: Always

    我们复用了同名 tag v4.0(每次构建覆盖同一个 tag)。Always 保证每次启动都重新拉取,否则节点上会继续用旧镜像缓存,出现"构建成功了,线上还是老代码"的灵异现象。

    ③ replicas: 2 + selector.matchLabels

    replicas: 2 表示两个副本,调度器会把它们分散到可用节点(这里只有一个 node1,所以两个 Pod 都在 node1,IP 不同)。selector.matchLabels.app: pipeline 必须与 template.metadata.labels 完全对应,写错会报 selector does not match template labels。

    7.2 Service 的端口链条(最容易搞混的地方)

    ports:
    – port: 8081 # Service 在集群内的端口
    targetPort: 8080 # 容器实际监听的端口
    type: NodePort # 额外在每个节点上开一个高位端口

    实际生效后 kubectl get svc 会显示:

    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    pipeline NodePort 10.96.131.139 <none> 8081:30724/TCP 45m

    三层端口要分清:

    层值谁来访问
    containerPort 8080 Pod 内应用监听
    port 8081 集群内部其他服务通过 pipeline:8081 访问
    nodePort 30724 集群外部通过 节点IP:30724 访问(范围 30000-32767,未指定则随机分配)

    所以最终访问地址是 http://192.168.100.146:30724/test——不是 8081。这个坑几乎人人都踩:port: 8081 只是"集群内的门牌号",对外的那扇门是 nodePort。


    八、创建 harbor-secret(最关键的一步)

    在 master 节点优先创建 secret 资源,用来保存访问 Harbor 的凭证,否则镜像拉取会失败:

    kubectl create secret docker-registry harbor-secret \\
    –docker-server=192.168.100.154:80 \\
    –docker-username=admin \\
    –docker-password=harbor123

    参数说明:

    参数含义注意
    docker-registry secret 类型 专门给私有镜像仓库用
    harbor-secret secret 名称 必须与 YAML 里 imagePullSecrets.name 一致
    –docker-server 仓库地址 必须带端口,且与 YAML 里 image 前缀一致
    –docker-username / –docker-password 账号密码 Harbor 的管理员账号

    创建后确认:

    kubectl get secret harbor-secret
    kubectl describe secret harbor-secret

    如果 secret 创建在非 default 命名空间,YAML 也要指定同一个 namespace,否则 Pod 找不到 secret。这是"明明建了 secret 却还是 ImagePullBackOff"的第二大原因。


    九、让所有节点信任 Harbor

    因为 Harbor 用的是 HTTP(非 HTTPS),每个 k8s 节点(master 和 node1)的 Docker 都必须信任它。注意是所有节点,不只是 master——镜像实际是在 node1 上拉的。

    vim /etc/docker/daemon.json

    {
    "insecure-registries": ["192.168.100.154:80"],
    "registry-mirrors": ["https://registry.cn-hangzhou.aliyuncs.com"],
    "exec-opts": ["native.cgroupdriver=systemd"],
    "log-driver": "json-file",
    "log-opts": {
    "max-size": "100m"
    },
    "storage-driver": "overlay2",
    "storage-opts": [
    "overlay2.override_kernel_check=true"
    ]
    }

    几个字段的意义:

    • insecure-registries:信任的 HTTP 仓库列表(本章新增)。
    • exec-opts: native.cgroupdriver=systemd:cgroup 驱动必须与 kubelet 一致,否则节点会 NotReady。
    • log-driver / log-opts:限制单个容器日志大小,防止日志把磁盘写满。
    • storage-driver: overlay2:推荐的存储驱动。

    重启 Docker 并验证登录:

    systemctl restart docker

    docker login 192.168.100.154:80 -u admin -p harbor123
    # Login Succeeded

    注意:重启 Docker 后如果 kubelet 报错、节点 NotReady,执行 systemctl restart kubelet 即可恢复。改 daemon.json 这类操作建议在业务低峰做。


    十、Jenkins 把 YAML 推到 master

    思路:Jenkins 不直接在 master 上写文件,而是把工作区里的 pipeline.yml 推到 master 的指定目录,再用 kubectl apply 应用它。

    10.1 在 master 上准备目标目录

    mkdir /usr/local/k8s
    chmod 777 /usr/local/k8s/

    777 是为了让 Jenkins 推送用户有写权限(生产环境建议改成指定属主 + 755)。

    10.2 配置 Publish Over SSH

    Jenkins「系统管理 → 系统配置 → Publish over SSH」:

    • Passphrase / Path to key:Jenkins 与目标机之间的密钥(见下一节免密配置)
    • SSH Servers 新增一台:
      • Name:k8s-master(或沿用 test,只要与流水线里 configName 一致)
      • Hostname:192.168.100.145
      • Username:root
      • Remote Directory:/usr/local/k8s

    填完点 「Test Configuration」,显示 Success 后再「应用并保存」。

    Test Configuration 失败基本都是三类原因:网络不通、账号密码/密钥错、Remote Directory 不存在。先手工 ssh root@192.168.100.145 验证通不通。

    10.3 修改 Jenkinsfile 的推送步骤

    到 GitLab 上修改 Jenkinsfile 里 Publish Over SSH 那个 stage,把 sourceFiles 指向 yml,remoteDirectory 指向目标目录:

    stage('推送 YAML 到 k8s master') {
    steps {
    sshPublisher(publishers: [sshPublisherDesc(
    configName: 'k8s-master',
    transfers: [sshTransfer(
    cleanRemote: false,
    excludes: '',
    execCommand: '',
    execTimeout: 120000,
    flatten: false,
    makeEmptyDirs: false,
    noDefaultExcludes: false,
    patternSeparator: '[, ]+',
    remoteDirectory: '/usr/local/k8s',
    remoteDirectorySDF: false,
    removePrefix: '',
    sourceFiles: 'pipeline.yml' // 相对 Jenkins 工作区
    )],
    usePromotionTimestamp: false,
    useWorkspaceInPromotion: false,
    verbose: false
    )])
    }
    }

    10.4 保存后先构建一次,测试推送

    保存配置,然后点「立即构建」前记得加一个新 tag——否则工作区不会刷新,Jenkins 识别不到新添加的 yml 文件。

    构建完成后查看构建日志,再到 master 上确认:

    [root@master ~]# ls /usr/local/k8s/
    pipeline.yml

    文件已成功传递。(日志里能看到 SSH: Transferred 1 file(s) 之类的字样。)


    十一、Jenkins 免密 SSH 登录 master

    后面要在流水线里执行 ssh root@192.168.100.145 kubectl apply -f …,这一步是交互式的(要输密码),流水线里会卡死。所以必须配置免密。

    11.1 在 Jenkins 容器内生成密钥

    docker exec -it jenkins bash

    jenkins@0eb81fc79a4a:/$ cd ~
    jenkins@0eb81fc79a4a:~$ ssh-keygen -t rsa
    # 一路回车(不要设 passphrase,否则流水线里仍需交互)

    输出:

    Generating public/private rsa key pair.
    Enter file in which to save the key (/var/jenkins_home/.ssh/id_rsa):
    Created directory '/var/jenkins_home/.ssh'.
    Enter passphrase (empty for no passphrase):
    Enter same passphrase again:
    Your identification has been saved in /var/jenkins_home/.ssh/id_rsa
    Your public key has been saved in /var/jenkins_home/.ssh/id_rsa.pub

    jenkins@0eb81fc79a4a:~$ cd .ssh/
    jenkins@0eb81fc79a4a:~/.ssh$ ls
    id_rsa id_rsa.pub

    passphrase 一定要留空。设了密码,流水线执行时同样会卡住(除非用 ssh-agent)。

    11.2 复制公钥到 master

    jenkins@0eb81fc79a4a:~/.ssh$ cat id_rsa.pub
    ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDEQpb25fdoeJS3f/c5cXXxuqIQ/x3OHOR8hKOB...

    然后在 master 上:

    [root@master ~]# mkdir .ssh
    [root@master ~]# cd .ssh/
    [root@master .ssh]# vim authorized_keys
    # 粘贴上一步的整行公钥,保存

    注意:authorized_keys 一行只能放一个公钥,粘贴时不要换行、不要带多余空格,否则认证失败。

    11.3 重启 sshd 并测试

    [root@master ~]# systemctl restart sshd

    回到 Jenkins 容器内测试:

    jenkins@0eb81fc79a4a:~/.ssh$ ssh root@192.168.100.145 ls /
    bin boot dev etc home lib lib64 media mnt opt proc root
    run sbin srv sys tmp usr var

    没有提示输密码,直接列出目录,说明免密成功。

    如果仍然要求密码,按顺序排查:① ~/.ssh 权限应为 700、authorized_keys 应为 600;② master 上 PermitRootLogin 是否为 yes;③ 公钥有没有被编辑器折行。


    十二、流水线增加 kubectl 部署阶段

    12.1 用「流水线语法」生成 sh 片段

    在任务「配置 → 流水线语法」里选 sh,输入:

    ssh root@192.168.100.145 kubectl apply -f /usr/local/k8s/pipeline.yml

    注意:kubectl 必须写绝对路径或用 ssh 登录后的默认 PATH 能找到的路径,pipeline.yml 也必须是绝对路径——因为通过 ssh 执行的是一条非交互命令,它的工作目录是 root 的家目录,不是 /usr/local/k8s。

    12.2 在 GitLab 的 Jenkinsfile 里增加 stage

    stage('远程执行 kubectl 命令') {
    steps {
    sh 'ssh root@192.168.100.145 kubectl apply -f /usr/local/k8s/pipeline.yml'
    }
    }

    建议放在「推送 YAML」阶段之后:

    stage('maven 构建') → stage('sonarqube 检测') → stage('Docker 制作镜像')
    → stage('推送 Harbor') → stage('推送 YAML 到 master') → stage('远程执行 kubectl 命令')

    顺序很重要:YAML 必须先到 master,kubectl apply 才能读到文件。反了就报 no such file or directory。

    12.3 一个更健壮的写法(可选)

    sh '''
    ssh root@192.168.100.145 "kubectl apply -f /usr/local/k8s/pipeline.yml"
    ssh root@192.168.100.145 "kubectl rollout status deployment/pipeline –timeout=120s"
    '''

    rollout status 会阻塞等待滚动更新完成,流水线失败能立刻反映,而不是"apply 成功但 Pod 起不来"却显示绿灯。生产环境强烈建议加这一步。


    十三、版本同步:tag、YAML、代码三处对齐

    这一步是本章最容易漏的地方。因为拉取的项目标签是 v4.0,pipeline.yml 里拉取镜像的标签也要同步变更。

    13.1 三处必须一起改

    #位置内容不改的后果
    1 构建参数 tag v4.0 镜像名对不上
    2 pipeline.yml 的 image …pipeline:v4.0 拉的还是旧镜像
    3 Harbor 里的 tag 需重新 push 拉取失败 manifest unknown

    13.2 顺带改一下首页,便于验证

    路径:src/main/java/com/chenyan/demo/controller/TestController.java,把返回内容改一下(比如加上版本号),这样页面上一眼就能看出新版本是否生效。

    13.3 删除并重建同名 tag

    在 GitLab 中把原来的 v4.0 标签删除,重新创建,命名依然写 v4.0,然后点「立即构建」。

    为什么要删了重建同一个名字? kuboard/流水线里用 ${JOB_NAME}:${tag} 做镜像名,tag 不变就意味着"同一路径被覆盖"。这本身是可用的(配合 imagePullPolicy: Always),但 GitLab 的 tag 是指针,直接覆盖同一个 tag 会让"到底哪个 commit 对应哪个镜像"变得不可追溯。删掉重建,等于强制刷新这个指针。

    13.4 ⚠️ 一个必须统一的命名问题

    原笔记里存在两处命名不一致,实际执行时一定会出问题,务必先统一:

    位置原笔记写法问题
    Jenkins 任务名 / 镜像仓库路径 pipline(拼写有误) 构建出的是 repo/pipline:v4.0
    pipeline.yml 里的 image repo/pipeline:v4.0 与上面不是同一个仓库路径
    Harbor 地址 YAML/secret 用 145:80,daemon.json 用 154:80 节点信任的仓库与实际拉取地址不同

    统一原则:任务名 = 镜像名 = YAML 里的 image 后两段 = Service/Deployment 的 metadata.name;Harbor 地址在 secret、YAML、daemon.json、Jenkinsfile 四处必须完全一致。

    否则典型报错是:

    Failed to pull image "192.168.100.154:80/repo/pipeline:v4.0":
    rpc error: code = NotFound desc = … manifest unknown


    十四、验证结果

    14.1 查看 Pod

    [root@master ~]# kubectl get pod -o wide
    NAME READY STATUS RESTARTS AGE IP NODE
    pipeline-7548f9c7f8-cb8hf 1/1 Running 0 6m45s 10.100.166.140 node1
    pipeline-7548f9c7f8-fpvfn 1/1 Running 0 6m42s 10.100.166.141 node1

    • 两个 Pod 都是 1/1 Running,符合 replicas: 2。
    • IP 落在 10.100.166.x 网段,说明 POD_SUBNET=10.100.0.1/16 生效。
    • NODE=node1,因为集群只有一个 worker。

    14.2 查看 Service

    [root@master ~]# kubectl get svc
    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 11h
    pipeline NodePort 10.96.131.139 <none> 8081:30724/TCP 45m

    8081:30724 就是"集群内 8081 / 对外 30724"。

    14.3 确认镜像真的拉下来了

    到 node1 上(Pod 所在节点)看:

    [root@node1 ~]# docker images
    REPOSITORY TAG IMAGE ID CREATED SIZE
    192.168.100.154:80/repo/pipeline v4.0 f9fb39b6f313 7 minutes ago 543MB

    [root@node1 ~]# docker ps -a | grep pipeline
    c7772f9ab89b 192.168.100.154:80/repo/pipeline "/bin/sh -c 'java -j…" 9 minutes ago Up 8 minutes
    k8s_pipeline_pipeline-7548f9c7f8-fpvfn_default_c9d85723-..._0

    d7bd836f1602 registry.aliyuncs.com/k8sxio/pause:3.2 "/pause" 9 minutes ago Up 9 minutes
    k8s_POD_pipeline-7548f9c7f8-fpvfn_default_..._0

    这说明 k8s 底层依然是 Docker:每个 Pod 有一个 pause 容器(持有网络命名空间)+ 一个业务容器,命名规则是 k8s_<容器名>_<Pod名>_<命名空间>_<uid>_<序号>。

    14.4 访问应用

    打开 node 地址:

    http://192.168.100.146:30724/test

    页面返回新版内容,说明从代码提交到 k8s 上线的全链路已打通。

    14.5 查看钉钉通知

    流水线跑完后,钉钉群里会收到构建结果。此时消息里的"版本"就是这次的 v4.0,和 k8s 里跑的镜像标签完全对应——构建结果与线上状态第一次做到了可对齐。


    十五、踩坑清单

    #现象根因解决
    1 deploy.sh 每次把老容器带走 每次执行都重启 Docker 用 grep -q 判断是否已配置,幂等处理
    2 Pod ImagePullBackOff 私有仓库没有拉取凭证 创建 harbor-secret + YAML 里 imagePullSecrets
    3 有 secret 仍拉不到镜像 secret 在别的 namespace / 名字不一致 同 namespace + 名称严格一致
    4 节点拉镜像报 http: server gave HTTP response to HTTPS client 节点未信任 HTTP 仓库 每个节点 daemon.json 加 insecure-registries
    5 构建成功但线上还是旧代码 复用同名 tag + 缓存 imagePullPolicy: Always
    6 访问 8081 打不开 混淆了 port 与 nodePort 用 节点IP:30724
    7 selector does not match template labels 两处 labels 不一致 matchLabels 必须等于 Pod 的 labels
    8 流水线卡在 ssh 阶段 ssh 需要交互输密码 配免密:ssh-keygen + authorized_keys
    9 免密配了仍要密码 目录/文件权限或公钥被折行 ~/.ssh 700、authorized_keys 600、公钥一行
    10 kubectl apply 报找不到文件 用了相对路径 一律绝对路径 /usr/local/k8s/pipeline.yml
    11 加了 yml 但 Jenkins 识别不到 工作区未刷新 建新 tag / 触发新构建
    12 kubeadm join 报 token 过期 token 有效期 2 小时 重新 kubeadm token create –print-join-command
    13 节点 NotReady cgroup 驱动不一致 / 改完 daemon.json 未重启 kubelet native.cgroupdriver=systemd + systemctl restart kubelet

    十六、总结

    这一章做的是"交付方式的升级":

  • 脚本幂等化。deploy.sh 从"每次都改 Docker 配置并重启"变成"判断一次、只配一次",既解决了上期彩蛋,也是运维脚本的基本素养。
  • 运行态交给 K8s。replicas: 2 + Deployment + Service,从此有副本、有自愈、有统一入口,不再依赖"某台机器上的某个容器"。
  • 凭证与信任要分开处理。docker login 解决"人能拉镜像",imagePullSecrets 解决"kubelet 能拉镜像";insecure-registries 解决"允许走 HTTP"。三者缺一不可,而且必须在所有节点上一致。
  • 端口链路要分清。containerPort 8080 → port 8081 → nodePort 30724,对外只看 nodePort。
  • 命名必须三处对齐。任务名、镜像名、YAML 里的 image、Service 名,任何一处对不上都会以"拉不到镜像"的形式报错。
  • 免密是自动化的前提。ssh-keygen 留空 passphrase + authorized_keys,否则流水线会卡在交互输入上。
  • 回头看这三章的演进路径,其实是一条很清晰的"抽象层级上升"路线:

    阶段交付物谁在管运行态解决的问题
    第 2 部 docker run 命令 人 能跑起来
    第 3 部 Jenkinsfile + deploy.sh 脚本 不用手动跑
    第 4 部(本章) pipeline.yml Kubernetes 跑得稳、可扩缩

    下一步很自然的延伸:

    • 加 liveness/readiness 探针,让 K8s 真正判断"应用是否健康",而不只是"容器是否在跑"。
    • 用 Ingress 取代 NodePort,把 30724 这种高位端口收敛成域名访问。
    • 用 HPA 按 CPU 自动扩缩容,配合 resources.requests 才能生效。
    • 把 YAML 拆成 Helm Chart,不同环境(dev/test/prod)用 values.yaml 区分,而不是改镜像 tag。
    • 流水线里加 kubectl rollout status 与 rollout undo,让"部署失败自动回滚"成为默认行为。

    如果这篇笔记对你有帮助,欢迎点赞 + 收藏,评论区交流。

    环境:CentOS 7 / Kubernetes v1.19.5 / Docker 19.3.11 / Harbor v2.8.2 / Jenkins 2.346.3-lts-jdk8

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » DevOps 进阶 Kubernetes 与 DevOps 整合实战:K8s 集群搭建 + Jenkins 自动部署 Pipeline 应用
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!