前言
Kubernetes（简称 K8S）作为容器编排领域的事实标准，已成为企业级容器化部署、微服务架构落地的核心基础设施。本文将从基础环境准备开始，一步步完成 K8S 集群搭建，并集成 Jenkins 实现 CI/CD 流水线、Harbor 作为私有镜像仓库，最终实现 SpringBoot 应用的自动化部署，全程基于 CentOS 7 系统，所有操作均经过实际验证，适合新手入门和企业级环境参考。

一、环境准备

1.1 服务器规划
本次搭建采用 1 主 2 从的集群架构，服务器配置如下（可根据实际资源调整）：

节点名称 IP 地址 配置要求 角色
master 192.168.100.100 4 核 6G 内存 / 40G 硬盘 主节点
node1 192.168.100.101 2 核 2G 内存 / 20G 硬盘 从节点
node2 192.168.100.102 2 核 2G 内存 / 20G 硬盘 从节点

1.2 系统基础要求

  • 操作系统：CentOS 7.x（最小化安装）
  • 关闭 SELINUX：setenforce 0 && sed -i ‘s/^SELINUX=enforcing/SELINUX=disabled/’ /etc/selinux/config
  • 所有节点时间同步：确保集群节点时间偏差≤1 秒

二、集群环境初始化（所有节点执行）

2.1 配置主机名映射

cat >> /etc/hosts << EOF
192.168.100.100 master
192.168.100.101 node1
192.168.100.102 node2
EOF

2.2 配置 SSH 免密登录（master 节点执行）

# 生成密钥（一路回车）
ssh-keygen -t rsa
# 分发密钥到所有节点
ssh-copy-id master
ssh-copy-id node1
ssh-copy-id node2
# 验证连通性
ssh node1 "hostname"

2.3 关闭 Swap 分区

K8S 要求必须禁用 Swap，否则 kubelet 会无法正常工作：

# 临时关闭
swapoff -a
# 永久关闭（重启生效）
sed -i '/swap/s/^/#/' /etc/fstab
echo "vm.swappiness = 0" >> /etc/sysctl.conf
sysctl -p

2.4 关闭防火墙

systemctl stop firewalld && systemctl disable firewalld

2.5 配置内核参数

modprobe br_netfilter
echo "modprobe br_netfilter" >> /etc/profile
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl -p /etc/sysctl.d/k8s.conf

2.6 配置 K8S YUM 源

使用阿里云镜像源提升下载速度：

cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
EOF

三、安装 Docker（所有节点执行）

3.1 卸载旧版本

yum remove -y docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate

3.2 配置 Docker YUM 源

yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3.3 安装并配置 Docker

# 安装指定版本（兼容性更好）
yum install -y docker-ce-20.10.9 docker-ce-cli-20.10.9 containerd.io
# 启动并设置开机自启
systemctl start docker && systemctl enable docker
# 配置镜像加速
cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": ["https://xxxxxx.mirror.aliyuncs.com"] # 替换为自己的阿里云加速地址
}
EOF
# 重启生效
systemctl daemon-reload && systemctl restart docker

四、安装 K8S 集群

4.1 安装核心组件

# 安装指定版本（1.23.17稳定性佳）
yum install -y kubelet-1.23.17 kubeadm-1.23.17 kubectl-1.23.17
# 设置开机自启
systemctl enable kubelet

4.2 初始化 Master 节点

# 添加集群端点映射
echo "192.168.100.100 cluster-endpoint" >> /etc/hosts

# 初始化集群
kubeadm init \
--apiserver-advertise-address=192.168.100.100 \
--control-plane-endpoint=cluster-endpoint \
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers \
--kubernetes-version v1.23.17 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=172.20.0.0/16

# 配置kubectl权限（master节点执行）
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config

4.3 节点加入集群
初始化成功后，会输出节点加入命令，在 node1、node2 节点执行：

kubeadm join cluster-endpoint:6443 --token xxxxx.xxxxxxxxxx \
--discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

注：如果 token 过期，可在 master 节点执行kubeadm token create --print-join-command重新生成。

4.4 安装网络插件 Calico

# 下载配置文件
curl https://docs.projectcalico.org/v3.15/manifests/calico.yaml -O
# 修改Pod网段（与初始化时一致）
sed -i 's/192.168.0.0\/16/172.20.0.0\/16/g' calico.yaml
# 部署Calico
kubectl apply -f calico.yaml
# 验证状态
kubectl get pod -A | grep calico

4.5 安装 Kuboard 可视化工具（master 节点）

# 下载配置文件
curl https://addons.kuboard.cn/kuboard/kuboard-v3.yaml -O
# 部署Kuboard
kubectl apply -f kuboard-v3.yaml
# 验证部署
kubectl get pods -n kuboard

访问地址：http://master:30080，默认账号密码：admin/Kuboard123。

五、安装 Jenkins（master 节点）

5.1 准备工作

# 配置Docker权限
chown root:root /var/run/docker.sock
chmod o+rw /var/run/docker.sock

# 创建挂载目录
mkdir -p /data/jenkins/mount
chmod 777 /data/jenkins/mount

5.2 编写 docker-compose.yml

version: '3.1'
services:
  jenkins:
    image: jenkins/jenkins
    privileged: true
    user: root
    ports:
      - 8088:8080
      - 50000:50000
    container_name: jenkins-server
    volumes:
      - /data/jenkins/mount:/var/jenkins_home
      - /etc/localtime:/etc/localtime
      - /var/run/docker.sock:/var/run/docker.sock
      - /usr/bin/docker:/usr/bin/docker

5.3 启动 Jenkins

docker compose up -d
# 获取初始密码
cat /data/jenkins/mount/secrets/initialAdminPassword

5.4 Jenkins 初始化配置

  1. 访问http://master:8088，输入初始密码登录；
  2. 安装推荐插件，之后创建管理员账号；
  3. 安装必备插件：Git Parameter Plug-In、Publish Over SSH；
  4. 配置 JDK 和 Maven：将 JDK、Maven 包上传到挂载目录并解压，在 Jenkins 全局配置中指定路径；
  5. 配置 Maven 镜像源：修改 settings.xml，添加阿里云镜像加速。

六、安装 Harbor 私有镜像仓库（master 节点）

6.1 下载并解压

# 下载离线包（可手动下载后上传）
wget https://github.com/goharbor/harbor/releases/download/v2.10.0/harbor-offline-installer-v2.10.0.tgz
# 解压
tar -zxvf harbor-offline-installer-v2.10.0.tgz
cd harbor

6.2 修改配置文件

cp harbor.yml.tmpl harbor.yml
# 编辑配置
vim harbor.yml
# 修改内容：
# hostname: 192.168.100.100
# port: 5000
# 注释https相关配置
# 修改admin密码：harbor_admin_password: Harbor12345

6.3 安装 Harbor

./prepare
./install.sh

七、配置 CI/CD 流水线

7.1 准备工作

  1. 配置 Docker 信任 Harbor 私有仓库：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

cat >> /etc/docker/daemon.json << EOF
"insecure-registries": ["192.168.100.100:5000"]
EOF
systemctl daemon-reload && systemctl restart docker
  1. 编写 Dockerfile（项目根目录）：
FROM java:8
MAINTAINER dev@example.com
ENV TZ=Asia/Shanghai
RUN ln -sf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ENV JAVA_OPTS="-Xms128m -Xmx256m -Djava.security.egd=file:/dev/./urandom"
WORKDIR /app
ADD ./target/*.jar app.jar
EXPOSE 9111
CMD ["sh", "-c","java $JAVA_OPTS -jar app.jar"]

7.2 Jenkins 流水线脚本

def TAG = 'v1.0.0'
pipeline{
    agent any
    environment {
        harborUser = 'admin'
        harborPassword = 'Harbor12345'
        harborAddress = '192.168.100.100:5000'
        harborRepo = 'demo'
    }
    stages {
        stage('拉取代码') {
            steps {
                checkout scmGit(branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: 'git-auth', url: 'https://codeup.aliyun.com/xxx/xxx/springbootdemo.git']])
                script{
                    TAG = sh(script: "git tag --sort=-creatordate |head -n1", returnStdout:true).trim()
                }
                checkout scmGit(branches: [[name: TAG]], extensions: [], userRemoteConfigs: [[credentialsId: 'git-auth', url: 'https://codeup.aliyun.com/xxx/xxx/springbootdemo.git']])
            }
        }
        stage('Maven构建') {
            steps {
                sh '/var/jenkins_home/maven/bin/mvn clean package -DskipTests'
            }
        }
        stage('构建镜像') {
            steps {
                sh '''cp ./target/*.jar ./
                    docker build -t ${JOB_NAME}:'''+TAG+''' ./'''
            }
        }
        stage('推送镜像到Harbor') {
            steps {
                sh '''docker login -u ${harborUser} -p ${harborPassword} ${harborAddress}
                    docker tag ${JOB_NAME}:'''+TAG+''' ${harborAddress}/${harborRepo}/${JOB_NAME}:'''+TAG+'''
                    docker push ${harborAddress}/${harborRepo}/${JOB_NAME}:'''+TAG
            }
        }
        stage('部署到K8S') {
            steps {
                // 修改YAML中的镜像版本
                sh 'ssh root@master "yq -i \'.spec.template.spec.containers[0].image = \\"${harborAddress}/${harborRepo}/${JOB_NAME}:'+TAG+'\\"\' /data/k8s/deployment.yml"'
                // 执行部署
                sh '''ssh root@master kubectl apply -f /data/k8s/deployment.yml
                    ssh root@master kubectl apply -f /data/k8s/service.yml'''
            }
        }
    }
}

7.3 K8S 部署文件示例

deployment.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: springboot-demo
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: demo-pod
  template:
    metadata:
      labels:
        app: demo-pod
    spec:
      containers:
        - name: demo-app
          image: 192.168.100.100:5000/demo/springboot-demo:v1.0.0
          ports:
            - containerPort: 9111

service.yml

apiVersion: v1
kind: Service
metadata:
  name: springboot-demo
  namespace: default
spec:
  selector:
    app: demo-pod
  type: NodePort
  ports:
    - port: 31111
      protocol: TCP
      targetPort: 9111
      nodePort: 31111

八、总结

  1. 本次实践完成了 K8S 1.23.17 集群的完整搭建，核心步骤包括环境初始化、Docker 安装、K8S 组件部署、网络插件配置；
  2. 集成 Jenkins 实现了从代码拉取、Maven 构建、镜像制作到 Harbor 推送的完整 CI 流程，结合 K8S 实现了应用的自动化部署；
  3. 关键注意点：集群节点时间同步、Swap 分区关闭、Pod 网段一致、私有镜像仓库信任配置，这些是保证集群稳定运行的核心。

通过这套流程，可快速搭建一套企业级的容器化 CI/CD 平台，满足微服务应用的自动化部署需求，后续可根据实际业务场景扩展监控、日志、告警等能力。

# kubernetes # jenkins # 容器
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

AI写小说用什么模型最好？DeepSeek、Claude、豆包实测对比，别只盯着一个用

avatar AI编程社区
cover

[论文学习]ToolEmu:用语言模型模拟沙盒识别语言模型智能体的风险

avatar AI编程社区
cover

ChatGPT 的公式怎么复制到 word？AI 导出鸭一站式搞定 AI 文档导出各类难题

avatar AI编程社区