技术学习笔记

Appearance

集群搭建 ​

概述 ​

Kubernetes集群搭建有多种方式，从简单的单节点开发环境到复杂的高可用生产集群。本章将介绍常见的集群搭建方法。

环境准备 ​

系统要求 ​

  • 操作系统: Ubuntu 22.04+, CentOS 8+, RHEL 8+
  • 内存: Master节点至少4GB，Worker节点至少2GB
  • CPU: Master节点至少2核，Worker节点至少1核
  • 磁盘: 至少40GB可用空间，建议SSD
  • 网络: 节点间网络互通，建议1Gbps以上

软件依赖 ​

  • 容器运行时: containerd 1.6+（推荐）、Docker 20.10+、CRI-O 1.24+
  • kubeadm: 1.28+（最新稳定版本）
  • kubelet: 1.28+（与kubeadm版本匹配）
  • kubectl: 1.28+（与kubeadm版本匹配）
  • 网络插件: Calico、Flannel、Cilium等

硬件推荐配置 ​

集群规模Master节点Worker节点网络要求
小型（<10节点）2核4G2核4G1Gbps
中型（10-100节点）4核8G4核8G10Gbps
大型（>100节点）8核16G+8核16G+10Gbps+

搭建方法对比 ​

方法适用场景复杂度特点
Minikube本地开发测试低单节点，快速启动
kubeadm生产环境中灵活配置，支持高可用
K3s边缘计算/IoT低轻量级，资源消耗少
云服务商托管生产环境低免运维，按需付费
二进制部署定制化需求高完全控制，复杂部署

Minikube搭建 ​

安装Minikube ​

bash
# Linux
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# macOS
brew install minikube

# Windows
choco install minikube

启动集群 ​

bash
# 启动Minikube集群
minikube start --driver=docker --cpus=2 --memory=4096

# 查看集群状态
minikube status

# 访问Dashboard
minikube dashboard

配置示例 ​

bash
# 使用特定K8S版本
minikube start --kubernetes-version=v1.24.0

# 使用自定义配置
minikube config set memory 8192
minikube config set cpus 4
minikube config set driver virtualbox

# 启动集群
minikube start

kubeadm搭建 ​

环境初始化 ​

bash
# 所有节点执行
# 1. 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

# 2. 关闭selinux
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

# 3. 关闭swap
swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# 4. 设置主机名
hostnamectl set-hostname k8s-master

安装容器运行时 ​

bash
# 安装Docker
yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum install -y docker-ce docker-ce-cli containerd.io
systemctl enable docker && systemctl start docker

# 配置Docker
cat > /etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
systemctl restart docker

安装kubeadm、kubelet、kubectl ​

bash
# 配置K8S源
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF

# 安装K8S组件
yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
systemctl enable kubelet && systemctl start kubelet

初始化Master节点 ​

bash
# 初始化集群
kubeadm init \
  --apiserver-advertise-address=192.168.1.100 \
  --image-repository registry.aliyuncs.com/google_containers \
  --kubernetes-version v1.24.0 \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16

# 配置kubectl
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

安装网络插件 ​

bash
# 安装Flannel网络插件
kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

# 或安装Calico网络插件
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

加入Worker节点 ​

bash
# 在Master节点获取加入命令
kubeadm token create --print-join-command

# 在Worker节点执行加入命令
kubeadm join 192.168.1.100:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash>

K3s搭建 ​

单节点安装 ​

bash
# 安装K3s
curl -sfL https://get.k3s.io | sh -

# 查看节点状态
k3s kubectl get nodes

# 获取kubeconfig
sudo cat /etc/rancher/k3s/k3s.yaml

多节点集群 ​

bash
# Master节点
curl -sfL https://get.k3s.io | K3S_TOKEN=mysecret sh -s - server \
  --cluster-init \
  --tls-san k3s-master.local

# Worker节点
curl -sfL https://get.k3s.io | K3S_TOKEN=mysecret K3S_URL=https://k3s-master.local:6443 sh -

云服务商托管 ​

AWS EKS ​

bash
# 安装eksctl
curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin

# 创建EKS集群
eksctl create cluster \
  --name my-cluster \
  --region us-west-2 \
  --nodegroup-name standard-workers \
  --node-type t3.medium \
  --nodes 3 \
  --nodes-min 1 \
  --nodes-max 4

Google GKE ​

bash
# 创建GKE集群
gcloud container clusters create my-cluster \
  --zone us-central1-a \
  --num-nodes 3 \
  --machine-type n1-standard-2 \
  --enable-autoscaling \
  --min-nodes 1 \
  --max-nodes 5

Azure AKS ​

bash
# 创建AKS集群
az aks create \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --node-count 3 \
  --node-vm-size Standard_B2s \
  --enable-addons monitoring \
  --generate-ssh-keys

阿里云ACK ​

bash
# 创建ACK集群
aliyun cs CreateKubernetesCluster \
  --Name my-cluster \
  --RegionId cn-hangzhou \
  --ZoneId cn-hangzhou-b \
  --NodePool \
  '[{"InstanceType":"ecs.g6.xlarge","NodeCount":3,"Name":"worker-pool"}]'

腾讯云TKE ​

bash
# 创建TKE集群
tccli tke CreateCluster \
  --ClusterName my-cluster \
  --ClusterType MANAGED_CLUSTER \
  --VpcId vpc-xxxx \
  --SubnetIds '["subnet-xxxx"]' \
  --Worker节点配置 \
  '{"InstanceType":"S2.LARGE8","Count":3}'

Kubespray部署 ​

概述 ​

Kubespray是一个基于Ansible的Kubernetes集群部署工具，支持多节点高可用集群部署。

环境准备 ​

bash
# 安装依赖
sudo apt update && sudo apt install -y git python3-pip
pip3 install ansible jinja2 netaddr

# 克隆Kubespray仓库
git clone https://github.com/kubernetes-sigs/kubespray.git
cd kubespray

# 安装依赖
pip3 install -r requirements.txt

配置集群 ​

bash
# 复制配置模板
cp -rfp inventory/sample inventory/my-cluster

# 编辑主机清单
vim inventory/my-cluster/hosts.yaml

配置示例：

yaml
all:
  hosts:
    master1:
      ansible_host: 192.168.1.101
      ip: 192.168.1.101
      access_ip: 192.168.1.101
    master2:
      ansible_host: 192.168.1.102
      ip: 192.168.1.102
      access_ip: 192.168.1.102
    master3:
      ansible_host: 192.168.1.103
      ip: 192.168.1.103
      access_ip: 192.168.1.103
    worker1:
      ansible_host: 192.168.1.201
      ip: 192.168.1.201
      access_ip: 192.168.1.201
    worker2:
      ansible_host: 192.168.1.202
      ip: 192.168.1.202
      access_ip: 192.168.1.202
  children:
    kube_control_plane:
      hosts:
        master1:
        master2:
        master3:
    kube_node:
      hosts:
        master1:
        master2:
        master3:
        worker1:
        worker2:
    etcd:
      hosts:
        master1:
        master2:
        master3:
    k8s_cluster:
      children:
        kube_control_plane:
        kube_node:
    calico_rr:
      hosts:

部署集群 ​

bash
# 执行部署
ansible-playbook -i inventory/my-cluster/hosts.yaml cluster.yml -b -v

# 部署网络插件（如果未自动部署）
ansible-playbook -i inventory/my-cluster/hosts.yaml roles/network_plugin/calico.yml -b -v

验证集群 ​

bash
# 复制kubeconfig
scp master1:~/.kube/config ~/.kube/config

# 查看集群状态
kubectl get nodes
kubectl get pods --all-namespaces

高可用集群搭建 ​

高可用架构 ​

┌─────────────────────────────────────────────┐
│                Load Balancer                │
├─────────────────────────────────────────────┤
│      ┌─────────┐  ┌─────────┐  ┌─────────┐ │
│      │ Master1 │  │ Master2 │  │ Master3 │ │
│      └─────────┘  └─────────┘  └─────────┘ │
├─────────────────────────────────────────────┤
│      ┌─────────┐  ┌─────────┐  ┌─────────┐ │
│      │ Worker1 │  │ Worker2 │  │ Worker3 │ │
│      └─────────┘  └─────────┘  └─────────┘ │
└─────────────────────────────────────────────┘

高可用etcd集群 ​

bash
# 在每个Master节点安装etcd
kubeadm init phase etcd local --config=kubeadm-config.yaml

# 生成etcd配置
kubeadm config print init-defaults > kubeadm-config.yaml

# 修改配置
cat >> kubeadm-config.yaml <<EOF
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
etcd:
  external:
    endpoints:
    - https://192.168.1.101:2379
    - https://192.168.1.102:2379
    - https://192.168.1.103:2379
    caFile: /etc/kubernetes/pki/etcd/ca.crt
    certFile: /etc/kubernetes/pki/etcd/server.crt
    keyFile: /etc/kubernetes/pki/etcd/server.key
EOF

负载均衡器配置 ​

bash
# 使用HAProxy作为负载均衡器
# /etc/haproxy/haproxy.cfg
global
    log /dev/log local0
    log /dev/log local1 notice
    chroot /var/lib/haproxy
    stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
    stats timeout 30s
    user haproxy
    group haproxy
    daemon

defaults
    log global
    mode tcp
    option tcplog
    option dontlognull
    timeout connect 5000
    timeout client 50000
    timeout server 50000

frontend k8s-api
    bind *:6443
    default_backend k8s-masters

backend k8s-masters
    balance roundrobin
    server master1 192.168.1.101:6443 check
    server master2 192.168.1.102:6443 check
    server master3 192.168.1.103:6443 check

集群验证 ​

基本验证 ​

bash
# 查看节点状态
kubectl get nodes

# 查看组件状态
kubectl get componentstatus

# 查看Pod状态
kubectl get pods --all-namespaces

# 查看集群信息
kubectl cluster-info

部署测试应用 ​

yaml
# test-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80
bash
# 部署测试应用
kubectl apply -f test-deployment.yaml

# 创建Service
kubectl expose deployment nginx-deployment --port=80 --type=NodePort

# 测试访问
kubectl get svc nginx-deployment
curl http://<node-ip>:<node-port>

常见问题排查 ​

节点NotReady ​

bash
# 检查kubelet状态
systemctl status kubelet

# 查看kubelet日志
journalctl -u kubelet -f

# 检查网络插件
kubectl get pods -n kube-system

网络问题 ​

bash
# 检查网络插件Pod
kubectl describe pod <network-pod> -n kube-system

# 检查网络策略
kubectl get networkpolicy --all-namespaces

# 测试Pod间通信
kubectl run test --image=busybox --restart=Never --rm -it -- ping <pod-ip>

存储问题 ​

bash
# 检查存储类
kubectl get storageclass

# 检查PV/PVC
kubectl get pv,pvc --all-namespaces

# 查看存储插件日志
kubectl logs <storage-pod> -n kube-system

集群维护 ​

节点维护 ​

bash
# 排空节点
kubectl drain <node-name> --ignore-daemonsets --delete-local-data

# 恢复节点
kubectl uncordon <node-name>

# 删除节点
kubectl delete node <node-name>

证书更新 ​

bash
# 检查证书过期时间
kubeadm certs check-expiration

# 更新证书
kubeadm certs renew all

# 重启kubelet
systemctl restart kubelet

集群升级 ​

升级前准备 ​

  1. 备份集群数据：备份etcd数据和重要配置
  2. 检查兼容性：确认目标版本与现有应用的兼容性
  3. 阅读发布说明：了解新版本的特性和变更
  4. 测试环境验证：在测试环境中先进行升级测试

升级步骤（kubeadm） ​

1. 升级控制平面节点

bash
# 1. 升级第一个Master节点
# 更新kubeadm
yum update kubeadm-1.28.0-0 --disableexcludes=kubernetes

# 检查升级计划
kubeadm upgrade plan v1.28.0

# 执行升级
kubeadm upgrade apply v1.28.0

# 更新kubelet和kubectl
yum update kubelet-1.28.0-0 kubectl-1.28.0-0 --disableexcludes=kubernetes

# 重启kubelet
systemctl daemon-reload
systemctl restart kubelet

# 2. 升级其他Master节点
# 驱逐Pod
kubectl drain <master-node> --ignore-daemonsets --delete-local-data

# 升级kubeadm
yum update kubeadm-1.28.0-0 --disableexcludes=kubernetes

# 执行升级
kubeadm upgrade node

# 更新kubelet和kubectl
yum update kubelet-1.28.0-0 kubectl-1.28.0-0 --disableexcludes=kubernetes

# 重启kubelet
systemctl daemon-reload
systemctl restart kubelet

# 恢复节点
kubectl uncordon <master-node>

2. 升级Worker节点

bash
# 1. 驱逐Pod
kubectl drain <worker-node> --ignore-daemonsets --delete-local-data

# 2. 升级kubeadm
yum update kubeadm-1.28.0-0 --disableexcludes=kubernetes

# 3. 执行升级
kubeadm upgrade node

# 4. 更新kubelet和kubectl
yum update kubelet-1.28.0-0 kubectl-1.28.0-0 --disableexcludes=kubernetes

# 5. 重启kubelet
systemctl daemon-reload
systemctl restart kubelet

# 6. 恢复节点
kubectl uncordon <worker-node>

升级注意事项 ​

  • 版本跳跃：建议每次升级不超过一个小版本（如1.27→1.28）
  • 备份：升级前必须备份etcd数据
  • 滚动升级：先升级控制平面，再升级Worker节点
  • 监控：升级过程中密切监控集群状态
  • 回滚：准备回滚方案，以防升级失败

升级后验证 ​

bash
# 查看集群状态
kubectl get nodes
kubectl get componentstatus

# 检查Pod状态
kubectl get pods --all-namespaces

# 测试应用
kubectl run test --image=nginx --restart=Never --rm -it -- curl -s http://<service-ip>

集群备份与恢复 ​

etcd备份 ​

bash
# 备份etcd数据
export ETCDCTL_API=3
etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot save /backup/etcd-snapshot-$(date +%Y%m%d).db

# 查看备份状态
etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot status /backup/etcd-snapshot-$(date +%Y%m%d).db

etcd恢复 ​

bash
# 停止etcd服务
systemctl stop etcd

# 恢复etcd数据
export ETCDCTL_API=3
etcdctl snapshot restore /backup/etcd-snapshot-20230101.db \
  --data-dir=/var/lib/etcd \
  --initial-cluster=etcd1=https://192.168.1.101:2380,etcd2=https://192.168.1.102:2380,etcd3=https://192.168.1.103:2380 \
  --initial-cluster-token=etcd-cluster-1 \
  --initial-advertise-peer-urls=https://192.168.1.101:2380

# 启动etcd服务
systemctl start etcd

集群配置备份 ​

bash
# 备份kubeconfig
cp ~/.kube/config ~/.kube/config-$(date +%Y%m%d)

# 备份重要配置
mkdir -p /backup/k8s-config
cp -r /etc/kubernetes /backup/k8s-config/

# 备份PV/PVC配置
kubectl get pv --all-namespaces -o yaml > /backup/pv-backup.yaml
kubectl get pvc --all-namespaces -o yaml > /backup/pvc-backup.yaml

# 备份重要应用配置
kubectl get deployments --all-namespaces -o yaml > /backup/deployments-backup.yaml
kubectl get services --all-namespaces -o yaml > /backup/services-backup.yaml

总结 ​

Kubernetes集群搭建有多种方法，选择合适的方法取决于使用场景和需求：

部署方法选择 ​

  • 开发测试环境：Minikube（单节点，快速启动）、K3s（轻量级，资源消耗少）
  • 生产环境：
    • kubeadm：灵活配置，支持高可用，适合有经验的团队
    • Kubespray：基于Ansible，自动化部署，适合大规模集群
    • 云服务商托管：AWS EKS、Google GKE、Azure AKS、阿里云ACK、腾讯云TKE等，免运维，按需付费

最佳实践建议 ​

  1. 高可用设计：生产环境建议部署3个Master节点，实现控制平面高可用
  2. 网络选择：根据需求选择合适的网络插件，如Calico（功能丰富）、Cilium（高性能）
  3. 存储规划：使用持久卷和存储类，确保数据持久化
  4. 监控告警：部署Prometheus和Grafana，建立完善的监控体系
  5. 备份策略：定期备份etcd数据和集群配置
  6. 升级管理：制定合理的升级计划，确保集群版本及时更新
  7. 安全配置：启用RBAC、网络策略和Pod安全标准

维护要点 ​

  • 定期检查：监控集群状态和资源使用
  • 节点管理：合理规划节点扩容和维护
  • 证书管理：定期更新集群证书
  • 故障演练：定期进行故障演练，提高故障处理能力
  • 文档管理：建立完善的集群文档，记录配置和变更

通过本章的学习，你应该掌握了Kubernetes集群的多种部署方法和维护技巧，能够根据实际需求选择合适的部署方案，并建立稳定、可靠的容器编排平台。

下一步学习 ​