1 硬件要求

1.1 测试环境

  • master：2核 4G 20G
  • master：4核 8G 40G

1.2 生产环境

配置要求更高

2 搭建方式

  • kubeadm：部署工具，提供kubeadm init和kubeadm join，用于快速部署k8s集群
    • 门槛低，屏蔽了很多细节，遇到问题很难排查
  • 二进制包：下载发行包，手动部署每个组件，组成k8s集群。
    • 手动部署，过程麻烦，但是利于后期维护

3 kubeadm方式搭建（推荐）

  1. // 1 对所有服务器进行初始化操作
  2. // 1.1 关闭防火墙
  3. sys
  4. // 注意，必须开放的端口6443 10250
  5. firewall-cmd --zone=public --add-port=6443/tcp --permanent
  6. firewall-cmd --zone=public --add-port=10250/tcp --permanent
  7. // 1.2 关闭selinux
  8. // 1.3 关闭swap分区
  9. // 1.4 设置主机名称
  10. hostnamectl set-hostname 主机名
  11. // 1.5 在master添加host
  12. vim /etv/hosts
  13. ip1 主机名1
  14. ip2 主机名2
  15. ip3 主机名3
  16. // 1.6 将桥接的ipv4流量拆改地道iptables的链
  17. // 1.7 时间同步(更新到最新)
  19. // 2 安装docker
  21. // 3 安装kubeadm，kubelet,kubectl
  22. // 3.1 设置yum源 vim /
  23. [kubernetes]
  24. name=Kubernetes
  25. baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
  26. enabled=1
  27. gpgcheck=1
  28. repo_gpgcheck=1
  29. gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
  30. https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
  31. // 3.2 安装kubelet
  32. yum install -y kubelet
  33. // 3.3 安装kubeadm
  34. yum install -y kubeadm
  35. // 3.4 安装kubectl
  36. yum install -y kubectl
  38. // 4 部署master节点
  39. // 4.1 在master节点执行
  40. kubeadm init \
  41. --apiserver-advertise-address=本机ip \
  42. --image-repository registry.aliyuncs.com/google_containers \
  43. --kubernetes-version v1.23.1(当前版本) \
  44. --service-cidr=10.96.0.0/12 \
  45. --pod-network-cidr=10.244.0.0/16
  46. // 4.2 查看nodes
  47. kubectl get nodes
  49. // 5 加入node节点
  50. // 5.1 在node节点执行
  51. kubeadm join 节点ip \
  52. --token=[token] \
  53. --discovery-token-ca-cert-hash [hash值]
  54. // 5.2 查看nodes
  55. kubectl get nodes
  57. // 6 配置CNI网络插件
  59. // 7 最后测试检验集群部署的正确性

4 kubectl方式手动搭建（重要）

4.1 所有机器进行初始化操作

  1. // 1 关闭防火墙 --可以不关
  2. // 1.1 临时关闭
  3. systemctl stop firewall
  4. // 1.2 永久关闭
  5. systemctl disable firewall
  6. // 1.3 注意，必须开放的端口2379
  7. firewall-cmd --zone=public --add-port=2379/tcp --permanent
  8. firewall-cmd --reload
  10. // 2 关闭selinux --可以不关
  11. // 2.1 临时关闭
  12. setenforce 0
  13. // 2.2 永久关闭
  14. // sed 直接对文本文件进行操作 sed -i 's/原字符串/新字符串' 目标文件
  15. sed -i 's/enforcing/disabled' /etc/selinux/config
  17. // 3 关闭swap分区 --必须
  18. // 3.1 临时关闭
  19. swapoff -a
  20. // 3.2 永久关闭
  21. // sed 直接对文本文件进行操作 sed -i 's/原字符串/新字符串' 目标文件
  22. sed -ri 's/.*swap.*/#&/' /etc/fstab
  24. // 4 修改hostname
  25. // 4.1 设置hostname
  26. hostnamectl set-hostname 主机名
  27. // 4.2 查询hostname
  28. hostname
  30. // 5 修改host
  31. vim /etc/hosts;
  32. // 5.1 添加如下内容
  33. 192.168.203.166 master
  34. 192.168.203.167 node-167
  35. 192.168.203.168 node-168
  36. // 5.2 相互ping，测试是否设置成功
  38. // 6 将桥接的IPv4流量传递到iptables的链 ****本次学习未设置****
  39. vim /etc/sysctl.d/k8s.conf;
  40. // 6.1 添加如下内容
  41. net.bridge.bridge-nf-call-ip6tables = 1
  42. net.bridge.bridge-nf-call-iptables = 1
  43. // 6.2 使其生效
  44. sysctl --system

4.2 部署etcd集群

4.2.1 准备cfssl证书生成工具

  1. wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
  2. wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
  3. wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
  4. chmod +x /usr/local/bin/cfssl*

4.2.2 生成Etcd证书

  1. // 1 创建CA配置文件ca-config.json
  2. vim /opt/ssl/k8sca/ca-config.json
  3. {
  4.   "signing": {
  5.     "default": {
  6.       "expiry": "87600h"
  7.     },
  8.     "profiles": {
  9.       "www": {
  10.         "usages": [
  11.             "signing",
  12.             "key encipherment",
  13.             "server auth",
  14.             "client auth"
  15.         ],
  16.         "expiry": "87600h"
  17.       }
  18.     }
  19.   }
  20. }
  22. // 2 创建CA证书签名请求ca-csr.json
  23. vim /opt/ssl/k8sca/ca-csr.json
  24. {
  25.   "CN": "etcd CA",
  26.   "key": {
  27.       "algo": "rsa",
  28.       "size": 2048
  29.   },
  30.   "names": [{
  31.               "C": "CN",
  32.         "L": "GuangDong",
  33.         "ST": "ShenZhen"         
  34.   }]
  35. }
  37. // 3 生成ca证书和私钥(生成ca.csr、ca-key.pem、ca.pem)
  38. cfssl gencert -initca ca-csr.json | cfssljson -bare ca
  40. // 4 创建etcd证书申请文件server-csr.json
  41. {
  42.   "CN": "etcd",
  43.   "hosts": [
  44.       "192.168.203.166",
  45.       "192.168.203.167",
  46.       "192.168.203.168"
  47.   ],
  48.   "key": {
  49.       "algo": "rsa",
  50.       "size": 2048
  51.   },
  52.   "names": [{
  53.               "C": "CN",
  54.         "L": "GuangDong",
  55.         "ST": "ShenZhen"         
  56.   }]
  57. }
  59. // 5 使用自签CA生成etcd 的https证书和私钥
  60. cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server

4.2.3 部署etcd集群

  1. // master主机
  2. // 1 下载etcd
  3. wget https://storage.googleapis.com/etcd/v3.5.1/etcd-v3.5.1-linux-amd64.tar.gz
  4. // 2 解压安装etcd
  5. tar xzvf ./etcd-v3.5.1-linux-amd64.tar.gz  -C ./etcd --strip-components=1
  6. // 3 创建软链接
  7. ln -s  ./etcd /usr/local/bin/etcd
  8. ln -s  ./etcdctl /usr/local/bin/etcdctl
  9. // 4 验证安装
  10. etcd --version
  11. // 5 设置配置文件etcd.conf
  12. vim /usr/local/etcd/etcd.conf
  13. #[Member]
  14. # 节点名称，集群中唯一
  15. ETCD_NAME="etcd-1"
  16. # 数据目录
  17. ETCD_DATA_DIR="/usr/local/etcd/default.etcd"
  18. # 集群通信监听地址
  19. ETCD_LISTEN_PEER_URLS="https://192.168.203.166:2380"
  20. # 客户端访问监听地址
  21. ETCD_LISTEN_CLIENT_URLS="https://192.168.203.166:2379"
  23. #[Clustering]
  24. # 集群通告地址
  25. ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.203.166:2380"
  26. # 客户端通告地址
  27. ETCD_ADVERTISE_CLIENT_URLS="https://192.168.203.166:2379"
  28. # 集群节点地址
  29. ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.203.166:2380,etcd-2=https://192.168.203.167:2380,etcd-3=https://192.168.203.168:2380"
  30. # 集群 Token
  31. ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
  32. # 加入集群的当前状态，new 是新集群，existing 表示加入 已有集群
  33. ETCD_INITIAL_CLUSTER_STATE="new"
  36. // 6 设置服务etcd.service
  37. vim /usr/lib/systemd/system/etcd.service
  38. [Unit]
  39. Description=Etcd Server
  40. After=network.target
  41. After=network-online.target
  42. Wants=network-online.target
  44. [Service]
  45. Type=notify
  46. EnvironmentFile=/usr/local/etcd/etcd.conf
  47. ExecStart=etcd \
  48.         # 证书配置
  49.         --cert-file=/opt/ssl/etcd/server.pem \
  50.         --key-file=/opt/ssl/etcd/server-key.pem \
  51.         --peer-cert-file=/opt/ssl/etcd/server.pem \
  52.         --peer-key-file=/opt/ssl/etcd/server-key.pem \
  53.         --trusted-ca-file=/opt/ssl/etcd/ca.pem \
  54.         --peer-trusted-ca-file=/opt/ssl/etcd/ca.pem \
  55.         --logger=zap
  56. Restart=on-failure
  57. LimitNOFILE=65536
  59. [Install]
  60. WantedBy=multi-user.target
  62. // 7 拷贝上一步生成的证书到指定目录
  63. cp /opt/ssl/k8sca/{ca,server,server-key}.pem /opt/ssl/etcd/
  65. // 8 启动并设置开机启动
  66. systemctl daemon-reload
  67. systemctl start etcd
  68. systemctl enable etcd

4.2.4 部署etcd集群

  1. // 1 将上面节点 1 所有生成的文件拷贝到其他节点
  2. scp -r /usr/loca/etcd/ root@其他节点IP:/usr/local/
  3. scp /usr/lib/systemd/system/etcd.service root@192.168.31.72:/usr/lib/systemd/system/
  5. // 2 然后在节点 2 和节点 3 分别修改 etcd.conf 配置文件中的节点名称和当前服务器 IP
  6. ETCD_NAME="etcd-1" # 修改此处，节点 2 改为 etcd-2，节点 3 改为 etcd-3
  7. ETCD_LISTEN_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前服务器 IP
  8. ETCD_LISTEN_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器 IP
  9. ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前 服务器 IP
  10. ETCD_ADVERTISE_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器 IP
  12. // 3 最后启动 etcd 并设置开机启动，同上。
  13. // 4 查看集群状态
  14. ETCDCTL_API=3 etcdctl \
  15. --cacert=/opt/ssl/etcd/ca.pem \
  16. --cert=/opt/ssl/etcd/server.pem \
  17. --key=/opt/ssl/etcd/server-key.pem \
  18. --endpoints="https://192.168.203.166:2379,https://192.168.203.167:2379,https://192.168.203.168:2379" \
  19. endpoint health

4.3 部署Master Node

主要工作：

  1. 部署API server
  2. 部署scheduler
  3. 部署controller-manager

4.3.1 为apiserver自签证书

  1. // 1 创建CA配置文件ca-config.json
  2. vim /opt/ssl/k8s/ca-config.json
  3. {
  4.   "signing": {
  5.     "default": {
  6.       "expiry": "87600h"
  7.     },
  8.     "profiles": {
  9.       "www": {
  10.         "usages": [
  11.             "signing",
  12.             "key encipherment",
  13.             "server auth",
  14.             "client auth"
  15.         ],
  16.         "expiry": "87600h"
  17.       }
  18.     }
  19.   }
  20. }
  21. // 2 创建CA证书签名请求ca-csr.json
  22. vim /opt/ssl/k8s/ca-csr.json
  23. {
  24.         "CN": "kubernetes",
  25.         "key": {
  26.                 "algo": "rsa",
  27.                 "size": 2048
  28.         },
  29.         "names": [{
  30.                 "C": "CN",
  31.                 "L": "GuangDong",
  32.                 "ST": "ShenZhen",
  33.                 "O": "k8s",
  34.                 "OU": "System"
  35.         }]
  36. }
  37. // 3 生成ca证书和私钥
  38. cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
  40. // 4 创建kubernetes证书申请文件kubernetes-csr.json
  41. // 注意：可信任ip列表在此处添加hosts
  42. vim /opt/ssl/k8s/kubernetes-csr.json
  43. {
  44.   "CN": "kubernetes",
  45.   "hosts": [
  46.     "10.0.0.1",
  47.     "127.0.0.1",
  48.     "kubernetes",
  49.     "kubernetes.default",
  50.     "kubernetes.default.svc",
  51.     "kubernetes.default.svc.cluster",
  52.     "kubernetes.default.svc.cluster.local",
  53.     "192.168.203.166",
  54.     "192.168.203.167",
  55.     "192.168.203.168",
  56.     "192.168.203.2"
  57.   ],
  58.   "key": { "algo": "rsa", "size": 2048 },
  59.   "names": [
  60.     { "C": "CN", "L": "GuangDong", "ST": "ShenZhen", "O": "k8s", "OU": "System" }
  61.   ]
  62. }
  64. // 5 使用自签CA生成etcd 的https证书和私钥
  65. cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www kubernetes-csr.json | cfssljson -bare server


4.3.2 部署 kube-apiserver

  1. // 1 下载kubernetes-server二进制包（下载地址在本文最下端）
  2. // 注意：此教程不支持1.19以上的版本
  3. tar zxvf kubernetes-server-linux-amd64.tar.gz
  4. cp ./kubernetes/server/bin/{kube-apiserver,kube-scheduler,kube-controller-manager} /usr/local/bin
  6. // 2 部署 kube-apiserver
  7. // 2.1 创建配置文件
  8. vim /opt/kubernetes/kube-apiserver.conf
  9. KUBE_APISERVER_OPTS="--logtostderr=false \\ 
  10.                       --v=2 \\
  11.                       --log-dir=/opt/kubernetes/logs \\ 
  12.                       --etcd-servers=https://192.168.203.166:2379,https://192.168.203.167:2379,https://192.168.203.168:2379 \\ 
  13.                       --bind-address=192.168.203.166 \\ 
  14.                       --secure-port=6443 \\ 
  15.                       --advertise-address=192.168.203.166 \\ 
  16.                       --allow-privileged=true \\ 
  17.                       --service-cluster-ip-range=10.0.0.0/24 \\ 
  18.                       --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\ 
  19.                       --authorization-mode=RBAC,Node \\ 
  20.                       --enable-bootstrap-token-auth=true \\ 
  21.                       --token-auth-file=/opt/kubernetes/cfg/token.csv \\ 
  22.                       --service-node-port-range=30000-32767 \\ 
  23.                       --kubelet-client-certificate=/opt/ssl/k8s/server.pem \\ 
  24.                       --kubelet-client-key=/opt/ssl/k8s/server-key.pem \\ 
  25.                       --tls-cert-file=/opt/ssl/k8s/server.pem \\ 
  26.                       --tls-private-key-file=/opt/ssl/k8s/server-key.pem \\ 
  27.                       --client-ca-file=/opt/ssl/k8s/ca.pem \\ 
  28.                       --service-account-key-file=/opt/ssl/k8s/ca-key.pem \\ 
  29.                       --etcd-cafile=/opt/ssl/etcd/ca.pem \\ 
  30.                       --etcd-certfile=/opt/ssl/etcd/server.pem \\ 
  31.                       --etcd-keyfile=/opt/ssl/etcd/server-key.pem \\ 
  32.                       --audit-log-maxage=30 \\ 
  33.                       --audit-log-maxbackup=3 \\ 
  34.                       --audit-log-maxsize=100 \\ 
  35.                       --audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
  37. // 2.2 启用 TLS Bootstrapping 机制
  38. vim /opt/kubernetes/cfg/token.csv
  39. c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node- bootstrapper"
  41. // 3 systemd 管理 apiserver
  42. vim /usr/lib/systemd/system/kube-apiserver.service
  43. [Unit]
  44. Description=Kubernetes API Server
  45. Documentation=https://github.com/kubernetes/kubernetes
  47. [Service]
  48. EnvironmentFile=/opt/kubernetes/cfg/kube-apiserver.conf
  49. ExecStart=kube-apiserver $KUBE_APISERVER_OPTS
  50. Restart=on-failure
  52. [Install]
  53. WantedBy=multi-user.target
  55. // 4 启动并设置开机启动
  56. systemctl daemon-reload
  57. systemctl start kube-apiserver
  58. systemctl enable kube-apiserver
  59. systemctl status kube-apiserver
  60. // 查错
  61. cat /var/log/messages|grep kube-apiserver
  63. // 5 授权 kubelet-bootstrap 用户允许请求证书
  64. kubectl create clusterrolebinding kubelet-bootstrap \
  65.     --clusterrole=system:node-bootstrapper \
  66.   --user=kubelet-bootstrap

4.3.3 部署 kube-controller-manager

  1. // 1 创建配置文件
  2. vim /opt/kubernetes/kube-controller-manager.conf
  3. KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
  4.                               --v=2 \\
  5.                               --log-dir=/opt/kubernetes/logs \\
  6.                               --leader-elect=true \\
  7.                               --master=127.0.0.1:8080 \\
  8.                               --bind-address=127.0.0.1 \\
  9.                               --allocate-node-cidrs=true \\
  10.                               --cluster-cidr=10.244.0.0/16 \\
  11.                               --service-cluster-ip-range=10.0.0.0/24 \\
  12.                               --cluster-signing-cert-file=/opt/ssl/kubernetes/ca.pem \\
  13.                               --cluster-signing-key-file=/opt/ssl/kubernetes/ca-key.pem \\
  14.                               --root-ca-file=/opt/ssl/kubernetes/ca.pem \\
  15.                               --service-account-private-key-file=/opt/ssl/kubernetes/ca-key.pem \\
  16.                               --experimental-cluster-signing-duration=87600h0m0s"
  18. // 2 systemd 管理kube-controller-manager
  19. vim /usr/lib/systemd/system/kube-controller-manager.service
  20. [Unit]
  21. Description=Kubernetes Controller Manager
  22. Documentation=https://github.com/kubernetes/kubernetes
  24. [Service]
  25. EnvironmentFile=/opt/kubernetes/cfg/kube-controller-manager.conf
  26. ExecStart=kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
  27. Restart=on-failure
  29. [Install]
  30. WantedBy=multi-user.target
  32. // 3 启动并设置开机启动
  33. systemctl daemon-reload
  34. systemctl start kube-controller-manager
  35. systemctl enable kube-controller-manager
  36. systemctl status kube-controller-manager

4.3.4 部署 kube-scheduler

  1. // 1 创建配置文件
  2. vim /opt/kubernetes/kube-scheduler.conf
  3. KUBE_SCHEDULER_OPTS="--logtostderr=false \\
  4.                      --v=2 \\
  5.                      --log-dir=/opt/kubernetes/logs \\
  6.                      --leader-elect \\
  7.                      --master=127.0.0.1:8080 \\
  8.                      --bind-address=127.0.0.1"
  10. // 2 systemd 管理kube-scheduler
  11. vim /usr/lib/systemd/system/kube-scheduler.service
  12. [Unit]
  13. Description=Kubernetes Controller Manager
  14. Documentation=https://github.com/kubernetes/kubernetes
  16. [Service]
  17. EnvironmentFile=/opt/kubernetes/cfg/kube-scheduler.conf
  18. ExecStart=kube-scheduler $KUBE_SCHEDULER_OPTS
  19. Restart=on-failure
  21. [Install]
  22. WantedBy=multi-user.target
  24. // 3 启动并设置开机启动
  25. systemctl daemon-reload
  26. systemctl start kube-scheduler.service
  27. systemctl enable kube-scheduler.service
  28. systemctl status kube-scheduler.service

4.3.5 查看集群状态

  1. kubectl get cs

4.4 部署Worker Node

主要工作：

  1. 部署kubelet
  2. 部署kube-proxy

4.4.1 部署 kubelet

  1. // 1 创建配置文件
  2. vim /opt/kubernetes/cfg/kubelet.conf
  3. # –hostname-override：显示名称，集群中唯一 
  4. # –network-plugin：启用 CNI –kubeconfig：空路径，会自动生成，后面用于连接 apiserver
  5. # –bootstrap-kubeconfig：首次启动向 apiserver 申请证书 
  6. # –config：配置参数文件 
  7. # –cert-dir：kubelet 证书生成目录 
  8. # –pod-infra-container-image：管理 Pod 网络容器的镜像
  10. KUBELET_OPTS="--logtostderr=false \
  11.               --v=2 \
  12.               --log-dir=/opt/kubernetes/logs \
  13.               --hostname-override=k8s-master \
  14.               --network-plugin=cni \
  15.               --kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \
  16.               --bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \
  17.               --config=/opt/kubernetes/cfg/kubelet-config.yml \
  18.               --cert-dir=/opt/kubernetes/ssl \
  19.               --pod-infra-container-image=lizhenliang/pause-amd64:3.0"
  21. // 2 配置参数文件
  22. vim /opt/kubernetes/cfg/kubelet-config.yml
  23. kind: KubeletConfiguration
  24. apiVersion: kubelet.config.k8s.io/v1beta1
  25. address: 0.0.0.0
  26. port: 10250
  27. readOnlyPort: 10255
  28. cgroupDriver: cgroupfs
  29. clusterDNS:
  30. - 10.0.0.2
  31. clusterDomain: cluster.local
  32. failSwapOn: false
  33. authentication:
  34.   anonymous:
  35.     enabled: false
  36.   webhook:
  37.     cacheTTL: 2m0s
  38.     enabled: true
  39.   x509:
  40.     clientCAFile: /opt/ssl/k8s/ca.pem
  41. authorization:
  42.   mode: Webhook
  43.   webhook:
  44.     cacheAuthorizedTTL: 5m0s
  45.     cacheUnauthorizedTTL: 30s
  46. evictionHard:
  47.   imagefs.available: 15%
  48. memory.available: 100Mi
  49. nodefs.available: 10%
  50. nodefs.inodesFree: 5%
  51. maxOpenFiles: 1000000
  52. maxPods: 110
  54. // 3 生成 bootstrap.kubeconfig 文件
  55. vim /opt/kubernetes/cfg/bootstrap.kubeconfig
  56. KUBE_APISERVER="https://192.168.203.166:6443" # apiserver IP:PORT
  57. TOKEN="c47ffb939f5ca36231d9e3121a252940" # 与 token.csv 里保持一致
  59. # 生成 kubelet bootstrap kubeconfig 配置文件
  60. kubectl config set-cluster kubernetes \ 
  61.     --certificate-authority=/opt/kubernetes/ssl/ca.pem \
  62.     --embed-certs=true \
  63.     --server=${KUBE_APISERVER} \
  64.     --kubeconfig=bootstrap.kubeconfig
  66. kubectl config set-credentials "kubelet-bootstrap" \
  67.     --token=${TOKEN} \ 
  68.     --kubeconfig=bootstrap.kubeconfig kubectl config set-context default \ 
  69.     --cluster=kubernetes \ 
  70.     --user="kubelet-bootstrap" \
  71.     --kubeconfig=bootstrap.kubeconfig
  73. kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
  75. // 4 systemd 管理 kubelet
  77. systemctl daemon-reload
  78. systemctl start kubelet
  79. systemctl enable kubelet

5 使用官网推荐搭建

5.1 安装 kubeadm

5.1.1 允许 iptables 检查桥接流量

  1. // 1 查询br_netfilter是否被加载
  2. lsmod | grep br_netfilter
  3. // 2 如果未加载，执行如下命令
  4. // 2.1 临时启动
  5. sudo modprobe br_netfilter
  6. // 2.2 设置开机启动
  7. vi /etc/modules-load.d/k8s.conf
  8. br_netfilter
  10. // 3 为了让Linux节点的iptables能够正确地查看桥接流量，需要将sysctl配置中net.bridge.bridge-nf-call-iptables设置为1
  11. vi /etc/sysctl.d/k8s.conf
  12. net.bridge.bridge-nf-call-ip6tables = 1
  13. net.bridge.bridge-nf-call-iptables = 1
  14. // 3.1 使其生效
  15. sudo sysctl --system

5.1.2 检查所需端口

端口和协议

5.1.3 安装运行容器docker

5.1.4 安装 kubeadm、kubelet 和 kubectl

  1. //1 设置yum源
  2. vi /etc/yum.repos.d/kubernetes.repo
  3. [kubernetes]
  4. name=Kubernetes
  5. baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
  6. enabled=1
  7. gpgcheck=1
  8. repo_gpgcheck=1
  9. gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
  11. // 2 将 SELinux 设置为 permissive 模式（相当于将其禁用）
  12. // 2.1 临时关闭
  13. sudo setenforce 0
  14. // 2.2 永久关闭
  15. sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
  17. // 3 安装
  18. sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
  20. // 4 激活并启动 kubelet
  21. sudo systemctl enable --now kubelet

5.1.4 配置 cgroup 驱动程序

容器运行时和 kubelet 都具有名字为 “cgroup driver” 的属性，该属性对于在 Linux 机器上管理 CGroups 而言非常重要。

警告： 你需要确保容器运行时和 kubelet 所使用的是相同的 cgroup 驱动，否则 kubelet 进程会失败。 相关细节可参见配置 cgroup 驱动。

  1. // 1 配置容器运行时 cgroup 驱动(docker)
  2. mkdir /etc/docker
  3. vi /etc/docker/daemon.json
  4. {
  5.   "exec-opts": ["native.cgroupdriver=systemd"],
  6.   "log-driver": "json-file",
  7.   "log-opts": {
  8.     "max-size": "100m"
  9.   },
  10.   "storage-driver": "overlay2"
  11. }
  13. sudo systemctl enable docker
  14. sudo systemctl daemon-reload
  15. sudo systemctl restart docker
  16. // 2 配置 kubelet 的 cgroup 驱动

5.2 使用 kubeadm 创建集群

5.2.1 初始化（kubeadm init）

  1. // 1 关闭swap分区
  2. // 1.1 临时关闭
  3. swapoff -a
  4. // 1.2 永久关闭
  5. // sed 直接对文本文件进行操作 sed -i 's/原字符串/新字符串' 目标文件
  6. sed -ri 's/.*swap.*/#&/' /etc/fstab
  8. // 2 开启6443和10250端口
  9. firewall-cmd --zone=public --add-port=6443/tcp --permanent
  10. firewall-cmd --zone=public --add-port=10250/tcp --permanent
  11. firewall-cmd --reload
  13. // 3 初始化集群
  14. kubeadm init \
  15. --apiserver-advertise-address=本机ip \
  16. --image-repository registry.aliyuncs.com/google_containers \
  17. --pod-network-cidr=10.244.0.0/16

5.2.2 配置网络插件

  1. mkdir -p /etc/cni/net.d
  2. vim ptp.confist
  3. {
  4.         "cniVersion": "0.3.1",
  5.         "name": "mynet",
  6.         "plugins": [
  7.                 {
  8.                         "type": "ptp",
  9.                         "ipMasq": true,
  10.                         "ipam": {
  11.                                 "type": "host-local",
  12.                                 "subnet": "172.16.30.0/24",
  13.                                 "routes": [
  14.                                         {
  15.                                                 "dst": "0.0.0.0/0"
  16.                                         }
  17.                                 ]
  18.                         }
  19.                 },
  20.                 {
  21.                         "type": "portmap",
  22.                         "capabilities": {"portMappings": true},
  23.                         "externalSetMarkChain": "KUBE-MARK-MASQ"
  24.                 }
  25.         ]
  26. }

5.2.3 节点加入集群（kubeadm join）

  1. // 1 配置网络
  2. // 2 安装docker，复制deamon.json
  3. // 3 安装 kubeadm、kubelet 和 kubectl
  4. // 4 加入集群
  5. kubeadm join ip:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>
  6. // 5 开启10248端口
  7. firewall-cmd --zone=public --add-port=10248/tcp --permanent
  8. firewall-cmd --reload
  9. // 6 配置网络插件同5.2.2

其他