• 二进制部署k8集群（上）搭建单机matser和etcd集群

    一、单机matser预部署设计

    目前Kubernetes最新版本是v1.25，但大部分公司一般不会使用最新版本。

    目前公司使用比较多的：老版本是v1.15，因为v1.16改变了很多API接口版本，国内目前使用比较多的是v1.18、v1.20。

    组件部署：

    mater节点
    mater01192.168.73.105kube-apiserver kube-controller-manager kube-scheduler etcd
        node节点
    node01192.168.73.106kubelet kube-proxy docker （容器引擎）
    node02192.168.73.107kubelet kube-proxy docker （容器引擎）
         etcd  cluster集群
    etcd节点1192.168.73.105（mater01）etcd
    etcd节点2192.168.73.106（node01）etcd
    etcd节点3192.168.73.107（node02）etcd

     

    二、操作系统初始化配置  

     注：该操作在所有node节点上进行，为k8s集群提供适合的初始化部署环境

    1. #关闭防火墙
    2. systemctl stop firewalld
    3. systemctl disable firewalld
    4. iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X
    5.  
    6. #关闭selinux
    7. setenforce 0
    8. sed -i 's/enforcing/disabled/' /etc/selinux/config
    9.  
    10. #关闭swap
    11. swapoff -a
    12. sed -ri 's/.*swap.*/#&/' /etc/fstab 
    13.  
    14. #根据规划设置主机名
    15. hostnamectl set-hostname master01
    16. hostnamectl set-hostname node01
    17. hostnamectl set-hostname node02
    18.  
    19. #在master添加hosts
    20. cat >> /etc/hosts << EOF
    21. 192.168.73.105 master01
    22. 192.168.73.106 node01
    23. 192.168.73.107 node02
    24. EOF
    25.  
    26. #调整内核参数
    27. cat > /etc/sysctl.d/k8s.conf << EOF
    28. #开启网桥模式，可将网桥的流量传递给iptables链
    29. net.bridge.bridge-nf-call-ip6tables = 1
    30. net.bridge.bridge-nf-call-iptables = 1
    31. #关闭ipv6协议
    32. net.ipv6.conf.all.disable_ipv6=1
    33. net.ipv4.ip_forward=1
    34. EOF
    35.  
    36. sysctl --system

    #时间同步
    yum install ntpdate -y
    ntpdate ntp.aliyun.com
     
    #将时间同步的操作添加到计划性任务，确保所有节点保证时间的同步
    crontab -e
    */30 * * * * /usr/sbin/ntpdate  ntp.aliyun.com
    crontab -l 

     

    三、部署 etcd 集群  

    etcd是Coreos团队于2013年6月发起的开源项目，它的目标是构建一个 高可用的分布式键值(key-value) 数据库。etcd内 部采用raft协议作为一致性算法，etcd是go语言编写的。

    etcd作为服务发现系统，有以下的特点：

    • 简单：安装配置简单，而且提供了HTTP API进行交互，使用也很简单。
    • 安全：支持SSL证书验证。
    • 快速：单实例支持每秒2k+读操作。
    • 可靠：采用raft算法，实现分布式系统数据的可用性和一致性。

    etcd目前默认使用2379端口提供HTTP API服务，2380端口和peer通信（这两个端口已经被IANA（互联网数字分配机构）官方预留给etcd）。

    即etcd默认使用2379端口对外为客户端提供通讯，使用端口2380来进行服务器间内部通讯。 （etcd和api-server通信使用2379端口，etcd之间使用2380通信）

    etcd在生产环境中一般推荐集群方式部署。由于etcd的leader选举机制，要求至少为3台或以上的奇数台。

    准备签发证书环境：

    CFSSL是CloudFlare公司开源的一款PKI/TLS 工具。CFSSL包含一个命令行工具和一个用于签名、验证和捆绑TLS证书的HTTP API服务。使用Go语言编写。

    CFSSL使用配置文件生成证书，因此自签之前，需要生成它识别的json 格式的配置文件，CFSSL 提供了方便的命令行生成配置文件。

    CFSSL用来为etcd提供TLS证书，它支持签三种类型的证书：
    client证书，服务端连接客户端时携带的证书，用于客户端验证服务端身份，如kubeapiserver 访问etcd;
    server证书，客户端连接服务端时携带的证书，用于服务端验证客户端身份，如etcd对外提供服务；
    peer证书，相互之间连接时使用的证书，如etcd节点之间进行验证和通信。
     

    这里全部都使用同一套证书认证。

    1. //在 master01 节点上操作
    2.  
    3. #准备cfssl证书生成工具
    4. wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -O /usr/local/bin/cfssl
    5. wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -O /usr/local/bin/cfssljson
    6. wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -O /usr/local/bin/cfssl-certinfo
    7.  
    8. chmod +x /usr/local/bin/cfssl*
    9.  
    10. #生成Etcd证书
    11. mkdir /opt/k8s
    12. cd /opt/k8s/
    13.  
    14. #上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
    15. chmod +x etcd-cert.sh etcd.sh
    16.  
    17. #创建用于生成CA证书、etcd 服务器证书以及私钥的目录
    18. mkdir /opt/k8s/etcd-cert
    19. mv etcd-cert.sh etcd-cert/
    20. cd /opt/k8s/etcd-cert/
    21. ./etcd-cert.sh
    22.  
    23. #查看生成的证书文件
    24. ls
    25.  
    26.  
    27. #上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务
    28. cd /opt/k8s/
    29. tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
    30.  
    31. mkdir -p /opt/etcd/{cfg,bin,ssl}
    32.  
    33. cd /opt/k8s/etcd-v3.4.9-linux-amd64/
    34. mv etcd etcdctl /opt/etcd/bin/
    35. cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/
    36.  
    37. cd /opt/k8s/
    38. ./etcd.sh etcd01 192.168.73.105 etcd02=https://192.168.73.106:2380,etcd03=https://192.168.73.107:2380
    39.  
    40. ps -ef | grep etcd
    41.  
    42. scp -r /opt/etcd/ root@192.168.73.106:/opt/
    43. scp -r /opt/etcd/ root@192.168.73.107:/opt/
    44. scp /usr/lib/systemd/system/etcd.service root@192.168.73.106:/usr/lib/systemd/system/
    45. scp /usr/lib/systemd/system/etcd.service root@192.168.73.107:/usr/lib/systemd/system/
    46.  

    1. //在 node01 节点上操作
    2. vim /opt/etcd/cfg/etcd
    3. #[Member]
    4. ETCD_NAME="etcd02"											#修改
    5. ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    6. ETCD_LISTEN_PEER_URLS="https://192.168.73.106:2380"			#修改
    7. ETCD_LISTEN_CLIENT_URLS="https://192.168.73.106:2379"		#修改
    8.  
    9. #[Clustering]
    10. ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.73.106:2380"		#修改
    11. ETCD_ADVERTISE_CLIENT_URLS="https://192.168.73.106:2379"				#修改
    12. ETCD_INITIAL_CLUSTER="etcd01=https://192.168.73.105:2380,etcd02=https://192.168.73.106:2380,etcd03=https://192.168.73.107:2380"
    13. ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
    14. ETCD_INITIAL_CLUSTER_STATE="new"
    15.  
    16. systemctl start etcd
    17. systemctl enable etcd
    18. systemctl status etcd
    19.  
    20. //在 node02 节点上操作
    21. vim /opt/etcd/cfg/etcd
    22. #[Member]
    23. ETCD_NAME="etcd03"											#修改
    24. ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
    25. ETCD_LISTEN_PEER_URLS="https://192.168.73.107:2380"			#修改
    26. ETCD_LISTEN_CLIENT_URLS="https://192.168.73.107:2379"		#修改
    27.  
    28. #[Clustering]
    29. ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.73.107:2380"		#修改
    30. ETCD_ADVERTISE_CLIENT_URLS="https://192.168.73.107:2379"				#修改
    31. ETCD_INITIAL_CLUSTER="etcd01=https://192.168.73.105:2380,etcd02=https://192.168.73.106:2380,etcd03=https://192.168.73.107:2380"
    32. ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
    33. ETCD_INITIAL_CLUSTER_STATE="new"
    34.  
    35. systemctl start etcd
    36. systemctl enable etcd
    37. systemctl status etcd

    1. 再次运行启动脚本
    2. ./etcd.sh etcd01 192.168.73.105 etcd02=https://192.168.73.106:2380,etcd03=https://192.168.73.107:2380
    3.  
    4.  
    5.  
    6. #检查etcd群集状态
    7. ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379" endpoint health --write-out=table
    8.  
    9.  
    10.  #查看etcd集群成员列表
    11. ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379" --write-out=table member list
    12.  
    13.  
    14.  #查看etcd集群中哪个节点是leader，true表示leader
    15.  ETCDCTL_API=3 /opt/etcd/bin/etcdctl --cacert=/opt/etcd/ssl/ca.pem --cert=/opt/etcd/ssl/server.pem --key=/opt/etcd/ssl/server-key.pem --endpoints="https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379" endpoint status --write-out=table

    四、部署 docker引擎 

    //所有 node 节点部署docker引擎
    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 
    yum install -y docker-ce docker-ce-cli containerd.io
     
    systemctl start docker.service
    systemctl enable docker.service

    五、部署 Master 组件

    1. //在 master01 节点上操作
    2. #上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包
    3. cd /opt/k8s/
    4. unzip master.zip
    5. chmod +x *.sh
    6.  
    7. mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
    8.  
    9. #创建用于生成CA证书、相关组件的证书和私钥的目录
    10. mkdir /opt/k8s/k8s-cert
    11. mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
    12. cd /opt/k8s/k8s-cert/
    13. ./k8s-cert.sh
    14.  
    15. ls *pem
    16. admin-key.pem  apiserver-key.pem  ca-key.pem  kube-proxy-key.pem  
    17. admin.pem      apiserver.pem      ca.pem      kube-proxy.pem
    18.  
    19. cp ca*pem apiserver*pem /opt/kubernetes/ssl/

    1.  
    2. #上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
    3. cd /opt/k8s/
    4. tar zxvf kubernetes-server-linux-amd64.tar.gz
    5.  
    6. cd /opt/k8s/kubernetes/server/bin
    7. cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
    8. ln -s /opt/kubernetes/bin/* /usr/local/bin/
    9.  
    10. #创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，接下来就可以用 RBAC 给他授权
    11. cd /opt/k8s/
    12. vim token.sh
    13. #!/bin/bash
    14. #获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
    15. BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
    16. #生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
    17. cat > /opt/kubernetes/cfg/token.csv <<EOF
    18. ${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
    19. EOF
    20.  
    21. chmod +x token.sh
    22. ./token.sh
    23.  
    24. cat /opt/kubernetes/cfg/token.csv
    25.  
    26. cd /opt/k8s/
    27. ./apiserver.sh 192.168.73.105 https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379
    28.  
    29. ps aux | grep kube-apiserver
    30.  
    31. netstat -natp | grep 6443   #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
    32.  
    33. cd /opt/k8s/
    34.  
    35. #启动 scheduler 服务
    36. ./scheduler.sh
    37. ps aux | grep kube-scheduler
    38.  
    39. #启动 controller-manager 服务
    40. ./controller-manager.sh
    41. ps aux | grep kube-controller-manager
    42.  
    43. #生成kubectl连接集群的证书
    44. ./admin.sh
    45.  
    46. kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
    47.  
    48. #通过kubectl工具查看当前集群组件状态
    49. kubectl get cs
    50.  
    51.  
    52. #查看版本信息
    53. kubectl version

    六、本次部署中所涉及的脚本

    1）etcd-cert.sh 

    #!/bin/bash
    #配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
    cat > ca-config.json <     "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "www": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }
    EOF
     
    #ca-config.json：可以定义多个 profiles，分别指定不同的过期时间、使用场景等参数；
    #后续在签名证书时会使用某个 profile；此实例只有一个 www 模板。
    #expiry：指定了证书的有效期，87600h 为10年，如果用默认值一年的话，证书到期后集群会立即宕掉
    #signing：表示该证书可用于签名其它证书；生成的 ca.pem 证书中 CA=TRUE；
    #key encipherment：表示使用非对称密钥加密，如 RSA 加密；
    #server auth：表示client可以用该 CA 对 server 提供的证书进行验证；
    #client auth：表示server可以用该 CA 对 client 提供的证书进行验证；
    #注意标点符号，最后一个字段一般是没有逗号的。
     
     
    #-----------------------
    #生成CA证书和私钥（根证书和私钥）
    cat > ca-csr.json < {
        "CN": "etcd",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "Beijing",
                "ST": "Beijing"
            }
        ]
    }
    EOF
     
    #CN：Common Name，浏览器使用该字段验证网站或机构是否合法，一般写的是域名 
    #key：指定了加密算法，一般使用rsa（size：2048）
    #C：Country，国家
    #ST：State，州，省
    #L：Locality，地区,城市
    #O: Organization Name，组织名称，公司名称
    #OU: Organization Unit Name，组织单位名称，公司部门
     
    cfssl gencert -initca ca-csr.json | cfssljson -bare ca
     
    #生成的文件：
    #ca-key.pem：根证书私钥
    #ca.pem：根证书
    #ca.csr：根证书签发请求文件
     
    #cfssl gencert -initca ：使用 CSRJSON 文件生成生成新的证书和私钥。如果不添加管道符号，会直接把所有证书内容输出到屏幕。
    #注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
    #cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。
     
     
    #-----------------------
    #生成 etcd 服务器证书和私钥
    cat > server-csr.json < {
        "CN": "etcd",
        "hosts": [
        "192.168.73.105",
        "192.168.73.106",
        "192.168.73.107"
        ],
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "BeiJing",
                "ST": "BeiJing"
            }
        ]
    }
    EOF
     
    #hosts：将所有 etcd 集群节点添加到 host 列表，需要指定所有 etcd 集群的节点 ip 或主机名不能使用网段，新增 etcd 服务器需要重新签发证书。
     
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server
     
    #生成的文件：
    #server.csr：服务器的证书请求文件
    #server-key.pem：服务器的私钥
    #server.pem：服务器的数字签名证书
     
    #-config：引用证书生成策略文件 ca-config.json
    #-profile：指定证书生成策略文件中的的使用场景，比如 ca-config.json 中的 www

    2）k8s-cert.sh 

    #!/bin/bash
    #配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
    cat > ca-config.json < {
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "kubernetes": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }
    EOF
     
    #生成CA证书和私钥（根证书和私钥）
    cat > ca-csr.json < {
        "CN": "kubernetes",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "Beijing",
                "ST": "Beijing",
                "O": "k8s",
                "OU": "System"
            }
        ]
    }
    EOF
     
    cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
     
     
    #-----------------------
    #生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
    #hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
    cat > apiserver-csr.json < {
        "CN": "kubernetes",
        "hosts": [
          "10.0.0.1",
          "127.0.0.1",
          "192.168.73.105",         #master01
          "192.168.73.110",         #master02
          "192.168.73.66",          #vip，后面 keepalived 使用
          "192.168.73.106",         #load balancer01（master）
          "192.168.73.107",         #load balancer02（backup）
          "kubernetes",
          "kubernetes.default",
          "kubernetes.default.svc",
          "kubernetes.default.svc.cluster",
          "kubernetes.default.svc.cluster.local"
        ],
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "BeiJing",
                "ST": "BeiJing",
                "O": "k8s",
                "OU": "System"
            }
        ]
    }
    EOF
     
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes apiserver-csr.json | cfssljson -bare apiserver
     
     
    #-----------------------
    #生成 kubectl 连接集群的证书和私钥，具有admin权限
    cat > admin-csr.json < {
      "CN": "admin",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "BeiJing",
          "ST": "BeiJing",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF
     
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
     
     
    #-----------------------
    #生成 kube-proxy 的证书和私钥
    cat > kube-proxy-csr.json < {
      "CN": "system:kube-proxy",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "BeiJing",
          "ST": "BeiJing",
          "O": "k8s",
          "OU": "System"
        }
      ]
    }
    EOF
     
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

    3）admin.sh 

    #!/bin/bash
    mkdir /root/.kube
    KUBE_CONFIG="/root/.kube/config"
    KUBE_APISERVER="https://192.168.73.105:6443"
     
    cd /opt/k8s/k8s-cert/
     
    kubectl config set-cluster kubernetes \
      --certificate-authority=/opt/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-credentials cluster-admin \
      --client-certificate=./admin.pem \
      --client-key=./admin-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=cluster-admin \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

    4)  apiserver.sh

    #!/bin/bash
    #example: apiserver.sh 192.168.73.105 https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379
    #创建 kube-apiserver 启动参数配置文件
    MASTER_ADDRESS=$1
    ETCD_SERVERS=$2
     
    cat >/opt/kubernetes/cfg/kube-apiserver < KUBE_APISERVER_OPTS="--logtostderr=false  \\
    --v=2 \\
    --log-dir=/opt/kubernetes/logs \\
    --etcd-servers=${ETCD_SERVERS} \\
    --bind-address=${MASTER_ADDRESS} \\
    --secure-port=6443 \\
    --advertise-address=${MASTER_ADDRESS} \\
    --allow-privileged=true \\
    --service-cluster-ip-range=10.0.0.0/24 \\
    --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
    --authorization-mode=RBAC,Node \\
    --enable-bootstrap-token-auth=true \\
    --token-auth-file=/opt/kubernetes/cfg/token.csv \\
    --service-node-port-range=30000-50000 \\
    --kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
    --service-account-issuer=api \\
    --service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
    --etcd-cafile=/opt/etcd/ssl/ca.pem \\
    --etcd-certfile=/opt/etcd/ssl/server.pem \\
    --etcd-keyfile=/opt/etcd/ssl/server-key.pem \\
    --requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \\
    --proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem \\
    --proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
    --requestheader-group-headers=X-Remote-Group \\
    --requestheader-username-headers=X-Remote-User \\
    --enable-aggregator-routing=true \\
    --audit-log-maxage=30 \\
    --audit-log-maxbackup=3 \\
    --audit-log-maxsize=100 \\
    --audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
    EOF
     
    #--logtostderr=true：启用日志。输出日志到标准错误控制台，不输出到文件
    #--v=4：日志等级。指定输出日志的级别，v=4为调试级别详细输出
    #--etcd-servers：etcd集群地址。指定etcd服务器列表（格式：//ip:port），逗号分隔
    #--bind-address：监听地址。指定 HTTPS 安全接口的监听地址，默认值0.0.0.0
    #--secure-port：https安全端口。指定 HTTPS 安全接口的监听端口，默认值6443
    #--advertise-address：集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息，必须能够被其他节点访问
    #--allow-privileged=true：启用授权。允许拥有系统特权的容器运行，默认值false
    #--service-cluster-ip-range：Service虚拟IP地址段。指定 Service Cluster IP 地址段
    #!/bin/bash
    #example: apiserver.sh 192.168.73.105 https://192.168.73.105:2379,https://192.168.73.106:2379,https://192.168.73.107:2379
    #创建 kube-apiserver 启动参数配置文件
    MASTER_ADDRESS=$1
    ETCD_SERVERS=$2
     
    cat >/opt/kubernetes/cfg/kube-apiserver < KUBE_APISERVER_OPTS="--logtostderr=false  \\
    --v=2 \\
    --log-dir=/opt/kubernetes/logs \\
    --etcd-servers=${ETCD_SERVERS} \\
    --bind-address=${MASTER_ADDRESS} \\
    --secure-port=6443 \\
    --advertise-address=${MASTER_ADDRESS} \\
    --allow-privileged=true \\
    --service-cluster-ip-range=10.0.0.0/24 \\
    --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \\
    --authorization-mode=RBAC,Node \\
    --enable-bootstrap-token-auth=true \\
    --token-auth-file=/opt/kubernetes/cfg/token.csv \\
    --service-node-port-range=30000-50000 \\
    --kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem \\
    --service-account-issuer=api \\
    --service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
    --etcd-cafile=/opt/etcd/ssl/ca.pem \\
    --etcd-certfile=/opt/etcd/ssl/server.pem \\
    --etcd-keyfile=/opt/etcd/ssl/server-key.pem \\
    --requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem \\
    --proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem \\
    --proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
    --requestheader-group-headers=X-Remote-Group \\
    --requestheader-username-headers=X-Remote-User \\
    --enable-aggregator-routing=true \\
    --audit-log-maxage=30 \\
    --audit-log-maxbackup=3 \\
    --audit-log-maxsize=100 \\
    --audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
    EOF
     
    #--logtostderr=true：启用日志。输出日志到标准错误控制台，不输出到文件
    #--v=4：日志等级。指定输出日志的级别，v=4为调试级别详细输出
    #--etcd-servers：etcd集群地址。指定etcd服务器列表（格式：//ip:port），逗号分隔
    #--bind-address：监听地址。指定 HTTPS 安全接口的监听地址，默认值0.0.0.0
    #--secure-port：https安全端口。指定 HTTPS 安全接口的监听端口，默认值6443
    #--advertise-address：集群通告地址。通过该 ip 地址向集群其他节点公布 api server 的信息，必须能够被其他节点访问
    #--allow-privileged=true：启用授权。允许拥有系统特权的容器运行，默认值false
    #--service-cluster-ip-range：Service虚拟IP地址段。指定 Service Cluster IP 地址段
    #--enable-bootstrap-token-auth：启用TLS bootstrap机制。在apiserver上启用Bootstrap Token 认证
    #--token-auth-file=/opt/kubernetes/cfg/token.csv：指定bootstrap token认证文件路径
    #--service-node-port-range：指定 Service  NodePort 的端口范围，默认值30000-32767
    #–-kubelet-client-xxx：apiserver访问kubelet客户端证书
    #--tls-xxx-file：apiserver https证书
    #1.20版本必须加的参数：–-service-account-issuer，–-service-account-signing-key-file
    #--etcd-xxxfile：连接Etcd集群证书
    #–-audit-log-xxx：审计日志
    #启动聚合层相关配置：–requestheader-client-ca-file，–proxy-client-cert-file，–proxy-client-key-file，–requestheader-allowed-names，–requestheader-extra-headers-prefix，–requestheader-group-headers，–requestheader-username-headers，–enable-aggregator-routing
     
     
    #创建 kube-apiserver.service 服务管理文件
    cat >/usr/lib/systemd/system/kube-apiserver.service < [Unit]
    Description=Kubernetes API Server
    Documentation=https://github.com/kubernetes/kubernetes
     
    [Service]
    EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver
    ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
    Restart=on-failure
     
    [Install]
    WantedBy=multi-user.target
    EOF
     
    systemctl daemon-reload
    systemctl enable kube-apiserver
    systemctl restart kube-apiserver

    5) scheduler.sh

     
    #!/bin/bash
    ##创建 kube-scheduler 启动参数配置文件
    MASTER_ADDRESS=$1
     
    cat >/opt/kubernetes/cfg/kube-scheduler < KUBE_SCHEDULER_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/opt/kubernetes/logs \\
    --leader-elect=true \\
    --kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
    --bind-address=127.0.0.1"
    EOF
     
    #-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
    #--leader-elect=true：当该组件启动多个时，自动启动 leader 选举
     
     
    ##生成kube-scheduler证书
    cd /opt/k8s/k8s-cert/
    #创建证书请求文件
    cat > kube-scheduler-csr.json << EOF
    {
      "CN": "system:kube-scheduler",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "BeiJing",
          "ST": "BeiJing",
          "O": "system:masters",
    #!/bin/bash
    ##创建 kube-scheduler 启动参数配置文件
    MASTER_ADDRESS=$1
     
    cat >/opt/kubernetes/cfg/kube-scheduler < KUBE_SCHEDULER_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/opt/kubernetes/logs \\
    --leader-elect=true \\
    --kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig \\
    --bind-address=127.0.0.1"
    EOF
     
    #-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
    #--leader-elect=true：当该组件启动多个时，自动启动 leader 选举
     
     
    ##生成kube-scheduler证书
    cd /opt/k8s/k8s-cert/
    #创建证书请求文件
    cat > kube-scheduler-csr.json << EOF
    {
      "CN": "system:kube-scheduler",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "BeiJing",
          "ST": "BeiJing",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF
     
    #生成证书
     
    #生成kubeconfig文件
    KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
    KUBE_APISERVER="https://192.168.73.105:6443"
     
    kubectl config set-cluster kubernetes \
      --certificate-authority=/opt/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-credentials kube-scheduler \
      --client-certificate=./kube-scheduler.pem \
      --client-key=./kube-scheduler-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=kube-scheduler \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
     
     
    ##创建 kube-scheduler.service 服务管理文件
    cat >/usr/lib/systemd/system/kube-scheduler.service < [Unit]
    Description=Kubernetes Scheduler
    Documentation=https://github.com/kubernetes/kubernetes
     
    [Service]
    EnvironmentFile=-/opt/kubernetes/cfg/kube-scheduler
    ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
    Restart=on-failure
     
    [Install]
    WantedBy=multi-user.target
    EOF
     
    systemctl daemon-reload
    systemctl enable kube-scheduler
    systemctl restart kube-scheduler

    6）controller-manager.sh 

    #!/bin/bash
    ##创建 kube-controller-manager 启动参数配置文件
    MASTER_ADDRESS=$1
     
    cat >/opt/kubernetes/cfg/kube-controller-manager < KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/opt/kubernetes/logs \\
    --leader-elect=true \\
    --kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig \\
    --bind-address=127.0.0.1 \\
    --allocate-node-cidrs=true \\
    --cluster-cidr=10.244.0.0/16 \\
    --service-cluster-ip-range=10.0.0.0/24 \\
    --cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem \\
    --cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem  \\
    --root-ca-file=/opt/kubernetes/ssl/ca.pem \\
    --service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem \\
    --cluster-signing-duration=87600h0m0s"
    EOF
     
    #––leader-elect：当该组件启动多个时，自动选举（HA）
    #-–kubeconfig：连接 apiserver 用的配置文件，用于识别 k8s 集群
    #--experimental-cluster-signing-duration：设置为 TLS BootStrapping 签署的证书有效时间为10年，默认为1年
     
     
    ##生成kube-controller-manager证书
    cd /opt/k8s/k8s-cert/
    #创建证书请求文件
    cat > kube-controller-manager-csr.json << EOF
    {
      "CN": "system:kube-controller-manager",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "BeiJing", 
          "ST": "BeiJing",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF
     
    #生成证书
     
    #生成kubeconfig文件
    KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
    KUBE_APISERVER="https://192.168.73.105:6443"
     
    kubectl config set-cluster kubernetes \
      --certificate-authority=/opt/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-credentials kube-controller-manager \
      --client-certificate=./kube-controller-manager.pem \
      --client-key=./kube-controller-manager-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=kube-controller-manager \
      --kubeconfig=${KUBE_CONFIG}
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
     
     
    ##创建 kube-controller-manager.service 服务管理文件
    cat >/usr/lib/systemd/system/kube-controller-manager.service < [Unit]
    Description=Kubernetes Controller Manager
    Documentation=https://github.com/kubernetes/kubernetes
     
    [Service]
    EnvironmentFile=-/opt/kubernetes/cfg/kube-controller-manager
    ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
    Restart=on-failure
     
    [Install]
    WantedBy=multi-user.target
    EOF
     
    systemctl daemon-reload
    systemctl enable kube-controller-manager
    systemctl restart kube-controller-manager

  • 相关阅读:
    wordpress使用category order and taxonomy terms order插件实现分类目录的拖拽排序
    [Unity][VR]Passthrough2-创建一个基本的Passthrough应用
    数据库基础知识
    C#：委托与事件
    Go分布式缓存 使用 Protobuf 通信(day7)
    会议论文分析-CCS21-ML增强的符号执行方法
    GIT无效的源路径/URL
    HyperLynx（十六）PCI-E的设计与仿真
    supervisor无法杀死threading.Thread().start()创建的子线程
    谁说专科学历找不到测试工作？自学测试，北京第一份工作12K。
  • 原文地址：https://blog.csdn.net/weixin_42054864/article/details/134011261