k8s的二进制部署master 和 etcd

k8s的基本架构

k8smaster01： 20.0.0.70 kube-apiserver kube-controller-manager kube-scheduler etcd

k8smaster02：20.0.0.71 kube-apiserver kube-controller-manager kube-scheduler

node节点01：20.0.0.72 kubelet kube-proxy etcd

node节点02：20.0.0.73 kubelet kube-proxy etcd

负载均衡：nginx+keepalive：master 20.0.0.74

backup 20.0.0.75

先配置etcd（20.0.0.70 20.0.0.72 20.0.0.73 ）

复制代码

关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

iptables -F：清除默认的 iptables 规则链（如 INPUT、FORWARD、OUTPUT）中的所有规则。
iptables -t nat -F：清除 "nat" 表中的所有规则，这通常包含用于网络地址转换（NAT）的规则。
iptables -t mangle -F：清除 "mangle" 表中的所有规则，这通常包含用于修改数据包头部的规则。
iptables -X：删除用户自定义的链。它将删除你可能在 iptables 中创建的任何自定义链。

关闭selinux

复制代码

setenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

关闭swap

关闭交换分区，提升性能

swap交换分区，如果机器内存不够，就会使用swap交换分区，但是swap交换分区的性能较低，

k8s设计的时候为了提升性能，默认是不允许使用交换分区的。kubeadm初始化的时候会检测swap是否关闭，

如果没关闭就会初始化失败。如果不想关闭交换分区，

安装k8s的时候可以指定-ignore-preflight-errors=Swap来解决。

复制代码

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

根据规划设置主机名

复制代码

hostnamectl set-hostname master01
hostnamectl set-hostname node01
hostnamectl set-hostname node02

做映射（在master添加hosts）

复制代码

cat >> /etc/hosts << EOF
20.0.0.70 master01
20.0.0.72 node01
20.0.0.73 node02
EOF

调整内核参数

复制代码

vim   /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1


#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
#看实际的生产情况，需要开启ipv6流量，可以不关。
net.ipv4.ip_forward=1

使配置内核参数生效

复制代码

sysctl --system

时间同步（3台etcd都需要做）

复制代码

yum install ntpdate -y
ntpdate ntp.aliyun.com

部署 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

部署 etcd 集群

存储k8s的集群信息和用户配置组件etcd

etcd 是一个高可用----分布式的键值对存储数据库

采用raft算法保证节点的信息一致性，etcd是go语言写的

etcd的端口：2379 api接口，对外为客户端提供通信

2380 内部服务的通信端口

etc一般都是集群部署，由于etcd也有选举机制leader，至少yao3台或者奇数台

k8s的内部通信依靠证书认证，密钥认证：证书的签发环境

复制代码

把证书拖到master01 的opt目录下
mv cfssl cfssl-certinfo  cfssljson  /usr/local/bin
chmod 777 /usr/local/bin/cfssl cfssl-certinfo  cfssljson

vim 

cfssl：证书签发的命令工具
cfssl-certinfo：查看证书信息的工具
cfssljson：把证书的格式转化成json格式，变成文件的承载式证书 

生成Etcd证书

mkdir /opt/k8s
cd /opt/k8s/

上传 etcd-cert.sh 和 etcd.sh 到 /opt/k8s/ 目录中
chmod 777 etcd-cert.sh etcd.sh

vim etcd-cert.sh

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "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证书和私钥（根证书和私钥）
#特别说明： cfssl和openssl有一些区别，openssl需要先生成私钥，然后用私钥生成请求文件，最后生成签名的证书和私钥等，但是cfssl可以直接得到请求文件。
cat > ca-csr.json <<EOF
{
    "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 文件生成生成新的证书和私钥。如果不添加管道符号，会直接把所有证书内容输出到屏幕。
#注意：CSRJSON 文件用的是相对路径，所以 cfssl 的时候需要 csr 文件的路径下执行，也可以指定为绝对路径。
#cfssljson 将 cfssl 生成的证书（json格式）变为文件承载式证书，-bare 用于命名生成的证书文件。


#-----------------------
#生成 etcd 服务器证书和私钥
cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "20.0.0.70",
    "20.0.0.72",
    "20.0.0.73"
    ],
    "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

创建用于生成CA证书、etcd 服务器证书以及私钥的目录

复制代码

mkdir /opt/k8s/etcd-cert
mv etcd-cert.sh etcd-cert/
cd /opt/k8s/etcd-cert/
./etcd-cert.sh            #生成CA证书、etcd 服务器证书以及私钥

[root@k8s1 etcd-cert]# ls
ca-config.json  ca.csr  ca-csr.json  ca-key.pem  ca.pem  etcd-cert.sh  server.csr  server-csr.json  server-key.pem  server.pem
ca-config.json  证书颁发机构的配置文件，定义了证书生成的策略，默认过期时间和模板
ca-csr.json		根证书文件，用于给其他组件签发证书
ca.pem		根证书文件，用于签发其他组件的证书。
ca.csr		根证书签发请求文件。
ca-key.pem  根证书的私钥文件
server-csr.json:
用于生成 etcd 服务器证书和私钥的签名请求文件。包括Common Name（CN）、主机地址列表和一些组织信息。
server.pem  etcd 服务器证书文件，用于加密和认证 etcd 节点之间的通信。
server.csr  etcd 服务器证书签发请求文件。
server-key.pem  etcd 服务器证书私钥文件。

上传 etcd-v3.4.9-linux-amd64.tar.gz 到 /opt/k8s 目录中，启动etcd服务
https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz

cd /opt/k8s/
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
ls etcd-v3.4.9-linux-amd64
Documentation  etcd  etcdctl  README-etcdctl.md  README.md  READMEv2-etcdctl.md

创建用于存放 etcd 配置文件，命令文件，证书的目录

复制代码

mkdir -p /opt/etcd/{cfg,bin,ssl}

cd /opt/k8s/etcd-v3.4.9-linux-amd64/
mv etcd etcdctl /opt/etcd/bin/
cp /opt/k8s/etcd-cert/*.pem /opt/etcd/ssl/

cd /opt/k8s/
./etcd.sh etcd01 20.0.0.70 etcd02=https://20.0.0.72:2380,etcd03=https://20.0.0.73:2380

把etcd相关证书文件、命令文件和服务管理文件全部拷贝到另外两个etcd集群节点

复制代码

scp -r /opt/etcd/ root@20.0.0.72:/opt/
scp -r /opt/etcd/ root@20.0.0.73:/opt/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.72:/usr/lib/systemd/system/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.73:/usr/lib/systemd/system/

在 node01 节点上操作

复制代码

vim /opt/etcd/cfg/etcd

#[Member]
ETCD_NAME="etcd02"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://20.0.0.72:2380"
ETCD_LISTEN_CLIENT_URLS="https://20.0.0.72:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.72:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.72:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://20.0.0.70:2380,etcd02=https://20.0.0.72:2380,etcd03=https://20.0.0.73:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"


启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd


在 node02 节点上操作
#[Member]
ETCD_NAME="etcd03"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://20.0.0.73:2380"
ETCD_LISTEN_CLIENT_URLS="https://20.0.0.73:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.73:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.73:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://20.0.0.70:2380,etcd02=https://20.0.0.72:2380,etcd03=https://20.0.0.73:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

启动etcd服务
systemctl start etcd
systemctl enable etcd
systemctl status etcd


检查etcd群集状态
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://20.0.0.70:2379,https://20.0.0.72:2379,https://20.0.0.73:2379" endpoint health --write-out=table

+-----------------------------+--------+-------------+-------+
|          ENDPOINT           | HEALTH |    TOOK     | ERROR |
+-----------------------------+--------+-------------+-------+
| https://20.0.0.70:2379      |   true | 56.973943ms |       |
| https://20.0.0.72:2379      |   true | 68.752723ms |       |
| https://20.0.0.73:2379      |   true | 69.001616ms |       |
+-----------------------------+--------+-------------+-------+
查看etcd集群成员列表

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://20.0.0.70:2379,https://20.0.0.72:2379,https://20.0.0.73:2379" --write-out=table member list
+------------------+---------+--------+-----------------------------+-----------------------------+------------+
|        ID        | STATUS  |  NAME  |         PEER ADDRS     |       CLIENT ADDRS     | IS LEARNER |
+------------------+---------+--------+-----------------------------+-------------------
| 742c86b504254313 | started | etcd01 | https://20.0.0.70:2380 | https://20.0.0.70:2379 |      false |
| a11e45cdfa809632 | started | etcd02 | https://20.0.0.72:2380 | https://20.0.0.72:2379 |      false |
| aeec4d911853abc5 | started | etcd03 | https://20.0.0.73:2380 | https://20.0.0.73:2379 |      false |
+------------------+---------+--------+------------------------+------------------------+------------+

部署 Master 组件

在 master01 节点上操作

复制代码

上传 master.zip 和 k8s-cert.sh 到 /opt/k8s 目录中，解压 master.zip 压缩包
cd /opt/k8s/
unzip master.zip
chmod 777 *.sh

admin.sh：
这个脚本的目的是为 Kubernetes 集群创建一个管理员用户，并配置 kubectl 工具以使用这个用户的身份连接到集群。以下是脚本的主要部分：
创建 kubeconfig 文件:
使用 kubectl config set-cluster、kubectl config set-credentials 和 kubectl config set-context 命令，
以及 kubectl config use-context 命令创建 kubeconfig 文件。kubeconfig 包含了连接到 Kubernetes 集群所需的配置信息。
设置集群信息 (set-cluster):
使用 kubectl config set-cluster 命令，配置了一个名为 "kubernetes" 的集群，
指定了 CA 证书路径、API Server 地址和一些其他参数。
设置用户凭据 (set-credentials):
使用 kubectl config set-credentials 命令，配置了一个名为 "cluster-admin" 的用户，指定了用户证书路径和私钥路径。
设置上下文 (set-context):
使用 kubectl config set-context 命令，配置了一个名为 "default" 的上下文，关联了之前设置的集群和用户。
上下文（Context）： 主要用于定义连接到哪个 Kubernetes 集群（Cluster）、以及使用哪个用户（User）身份进行操作。
一个上下文包含了集群、用户和可选的命名空间信息。
上下文的主要目的是帮助你在不同的 Kubernetes 环境之间切换，比如在开发、测试和生产环境之间切换。
使用上下文 (use-context):
使用 kubectl config use-context 命令，将当前上下文设置为 "default"。
这样，当你运行 kubectl 命令时，它将使用指定的 kubeconfig 文件连接到 Kubernetes 集群，并使用管理员用户的身份进行操作


apiserver.sh:
--logtostderr=false: 禁用将日志输出到控制台的选项，将日志写入文件。
--v=2: 设置日志的详细级别，此处为 2。
--log-dir=/opt/kubernetes/logs: 指定日志文件的目录。
--etcd-servers=${ETCD_SERVERS}: 指定 etcd 服务器的地址，使用逗号分隔多个地址。
--bind-address=${MASTER_ADDRESS}: 指定 API Server 监听的地址。
--secure-port=6443: 指定 API Server 监听的端口。
--advertise-address=${MASTER_ADDRESS}: 通过该地址向集群其他节点公布 api server 的信息。
--allow-privileged=true: 允许拥有系统特权的容器运行。
--service-cluster-ip-range=10.0.0.0/24: 指定 Service Cluster IP 地址段。
--enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction: 
启用准入控制插件，包括命名空间生命周期、限制器、服务账户、资源配额和节点限制等。
--authorization-mode=RBAC,Node: 启用 RBAC 和节点授权模式。
--enable-bootstrap-token-auth=true: 启用 TLS Bootstrap 机制。
--token-auth-file=/opt/kubernetes/cfg/token.csv: 指定 Bootstrap Token 认证文件路径。
--service-node-port-range=30000-50000: 指定 Service NodePort 的端口范围。
--kubelet-client-certificate=/opt/kubernetes/ssl/apiserver.pem: 指定 API Server 访问 kubelet 的客户端证书。
--kubelet-client-key=/opt/kubernetes/ssl/apiserver-key.pem: 指定 API Server 访问 kubelet 的客户端私钥。
--tls-cert-file=/opt/kubernetes/ssl/apiserver.pem: 指定 API Server 的 HTTPS 证书。
--tls-private-key-file=/opt/kubernetes/ssl/apiserver-key.pem: 指定 API Server 的 HTTPS 私钥。
--client-ca-file=/opt/kubernetes/ssl/ca.pem: 指定客户端证书的 CA 文件。
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem: 指定服务账户的密钥文件。
--service-account-issuer=api: 指定服务账户的发行者。
--service-account-signing-key-file=/opt/kubernetes/ssl/apiserver-key.pem: 指定服务账户的签名密钥文件。
--etcd-cafile=/opt/etcd/ssl/ca.pem: 指定连接 etcd 集群的 CA 文件。
--etcd-certfile=/opt/etcd/ssl/server.pem: 指定连接 etcd 集群的证书文件。
--etcd-keyfile=/opt/etcd/ssl/server-key.pem: 指定连接 etcd 集群的密钥文件。
--requestheader-client-ca-file=/opt/kubernetes/ssl/ca.pem: 指定用于验证请求头的 CA 文件。
--proxy-client-cert-file=/opt/kubernetes/ssl/apiserver.pem: 指定用于代理客户端的证书文件。
--proxy-client-key-file=/opt/kubernetes/ssl/apiserver-key.pem: 指定用于代理客户端的私钥文件。
--requestheader-allowed-names=kubernetes: 允许的请求头名称。
--requestheader-extra-headers-prefix=X-Remote-Extra-: 请求头中额外的头部前缀。
--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: 审计日志文件路径。

controller-manager.sh:
--logtostderr=false: 禁用将日志输出到控制台的选项，将日志写入文件。
--v=2: 设置日志的详细级别，此处为 2。
--log-dir=/opt/kubernetes/logs: 指定日志文件的目录。
--leader-elect=true: 启用 leader 选举，当该组件启动多个实例时，自动选举一个为 leader，其余为 follower。
--kubeconfig=/opt/kubernetes/cfg/kube-controller-manager.kubeconfig: 指定连接 kube-apiserver 的配置文件路径，用
于识别 Kubernetes 集群。
--bind-address=127.0.0.1: 指定监听地址。
--allocate-node-cidrs=true: 自动为每个节点分配 CIDR，用于分配 Pod 的 IP 地址。
--cluster-cidr=10.244.0.0/16: 指定 Pod 资源的网段，需与 Pod 网络插件的设置一致。
pod资源的网段，需与pod网络插件的值设置一致。
Flannel网络插件的默认为10.244.0.0/16，
Calico插件的默认值为20.0.0.0/16
--service-cluster-ip-range=10.0.0.0/24: 指定 Service Cluster IP 地址段。
--cluster-signing-cert-file=/opt/kubernetes/ssl/ca.pem 和 --cluster-signing-key-file=/opt/kubernetes/ssl/ca-key.pem: 
自动为 kubelet 颁发证书的 CA，与 kube-apiserver 保持一致。
--root-ca-file=/opt/kubernetes/ssl/ca.pem: 指定根 CA 证书文件路径，用于对 kube-apiserver 证书进行校验。
--service-account-private-key-file=/opt/kubernetes/ssl/ca-key.pem: 用于签署 ServiceAccount 的私钥文件。
--cluster-signing-duration=87600h0m0s: 设置为 TLS Bootstrapping 签署的证书有效时间为 10 年，默认为 1 年。

scheduler.sh:
--logtostderr=false：禁用输出到标准错误的日志。
--v=2：日志的详细级别，设置为 2。
--log-dir=/opt/kubernetes/logs：指定日志文件的存储路径。
--leader-elect=true：启用 leader 选举机制，确保只有一个 kube-scheduler 实例成为 leader。
--kubeconfig=/opt/kubernetes/cfg/kube-scheduler.kubeconfig：连接到 Kubernetes API Server 的配置文件路径。
--bind-address=127.0.0.1：kube-scheduler 监听的地址。


创建kubernetes工作目录
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

创建用于生成CA证书、相关组件的证书和私钥的目录
mkdir /opt/k8s/k8s-cert
mv /opt/k8s/k8s-cert.sh /opt/k8s/k8s-cert
cd /opt/k8s/k8s-cert/
./k8s-cert.sh				#生成CA证书、相关组件的证书和私钥

复制CA证书、apiserver相关证书和私钥到 kubernetes工作目录的 ssl 子目录中
cp ca*pem apiserver*pem /opt/kubernetes/ssl/

上传 kubernetes-server-linux-amd64.tar.gz 到 /opt/k8s/ 目录中，解压 kubernetes 压缩包
载地址：https://github.com/kubernetes/kubernetes/blob/release-1.20/CHANGELOG/CHANGELOG-1.20.md

cd /opt/k8s/
tar zxvf kubernetes-server-linux-amd64.tar.gz

复制master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中
cd /opt/k8s/kubernetes/server/bin
cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
ln -s /opt/kubernetes/bin/* /usr/local/bin/

创建 bootstrap token 认证文件，apiserver 启动时会调用，然后就相当于在集群内创建了一个这个用户，
接下来就可以用 RBAC 进行授权
cd /opt/k8s/
vim token.sh
#!/bin/bash
#获取随机数前16个字节内容，以十六进制格式输出，并删除其中空格
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')

#生成 token.csv 文件，按照 Token序列号,用户名,UID,用户组 的格式生成
cat > /opt/kubernetes/cfg/token.csv <<EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

hmod +x token.sh
./token.sh

cat /opt/kubernetes/cfg/token.csv
二进制文件、token、证书都准备好后，开启 apiserver 服务
cd /opt/k8s/
./apiserver.sh 20.0.0.70 https://20.0.0.70:2379,https://20.0.0.72:2379,https://20.0.0.73:2379

检查进程是否启动成功
ps aux | grep kube-apiserver

netstat -natp | grep 6443   #安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证
启动 scheduler 服务
cd /opt/k8s/
./scheduler.sh
ps aux | grep kube-scheduler

启动 controller-manager 服务
./controller-manager.sh
ps aux | grep kube-controller-manager

生成kubectl连接集群的kubeconfig文件
./admin.sh

通过kubectl工具查看当前集群组件状态
kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
controller-manager   Healthy   ok                  
scheduler            Healthy   ok                  
etcd-2               Healthy   {"health":"true"}   
etcd-1               Healthy   {"health":"true"}   
etcd-0               Healthy   {"health":"true"}  

查看版本信息
kubectl version