2、搭建k8s集群 - 2.2、二进制包方式部署k8集群 - 《Linux》

1、安装要求
2、准备环境
- 2.1、软件环境
- 2.2、服务器规划
3、开始搭建

1、安装要求

在开始之前，部署 Kubernetes 集群机器需要满足以下几个条件：
（1）一台或多台机器，操作系统 CentOS7.x-86_x64
（2）硬件配置：2GB 或更多 RAM，2 个 CPU 或更多 CPU，硬盘 30GB 或更多
（3）集群中所有机器之间网络互通
（4）可以访问外网，需要拉取镜像，如果服务器不能上网，需要提前下载镜像并导入节点
（5）禁止 swap

2、准备环境

2.1、软件环境

软件	版本
操作系统	CentOS7.8_x64 （mini）
Docker	19-ce
Kubernetes	1.19

2.2、服务器规划

角色	IP	组件
k8s-master	192.168.31.71	kube-apiserver，kube-controller-manager，kube -scheduler，etcd
k8s-node1	192.168.31.72	kubelet，kube-proxy，docker etcd
k8s-node2	192.168.31.73	kubelet，kube-proxy，docker，etcd

2.2、二进制包方式部署k8集群 - 图1

3、开始搭建

3.1、系统初始化

3.1.5、在master添加hosts

cat >> /etc/hosts << EOF 
192.168.44.147 m1 
192.168.44.148 n1
EOF

3.1.6、将桥接的 IPv4 流量传递到 iptables 的链

3.2、部署 Etcd 集群

Etcd 是一个分布式键值存储系统，Kubernetes 使用 Etcd 进行数据存储，所以先准备一个 Etcd 数据库，为解决 Etcd 单点故障，应采用集群方式部署，这里使用 3 台组建集群，可容忍 1 台机器故障，当然，你也可以使用 5 台组建集群，可容忍 2 台机器故障。

节点名称	IP
etcd-1	192.168.31.71
etcd-2	192.168.31.72
etcd-3	192.168.31.73

注：为了节省机器，这里与 K8s 节点机器复用。也可以独立于 k8s 集群之外部署，只要 apiserver 能连接到就行。

3.2.1、准备 cfssl 证书生成工具

cfssl 是一个开源的证书管理工具，使用 json 文件生成证书，相比 openssl 更方便使用。
找任意一台服务器操作，这里用 Master 节点。

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 
chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64 
mv cfssl_linux-amd64 /usr/local/bin/cfssl 
mv cfssljson_linux-amd64 /usr/local/bin/cfssljson 
mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo

3.2.2、生成 Etcd 证书

（1）自签证书颁发机构（CA）

创建工作目录：

mkdir -p ~/TLS/{etcd,k8s} 
cd TLS/etcd

自签 CA：

cat > ca-config.json<< EOF
{
  "signing": { 
      "default": { 
          "expiry": "87600h" 
       },
       "profiles": { 
           "www": { 
               expiry": "87600h", 
               "usages": [ 
                   "signing",
                   "key encipherment", 
                   "server auth", 
                   "client auth"
                ]
            }
         }
    }
}
EOF

cat > ca-csr.json<< EOF
{
    "CN": "etcd CA", 
    "key": { 
        "algo": "rsa", 
        "size": 2048 
     },
    "names": [
        { 
            "C": "CN", 
            "L": "Beijing", 
            "ST": "Beijing" 
        } 
     ]
}
EOF

生成证书：

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
ls *pem

可以看到：

ca-key.pem ca.pem

（2）使用自签 CA 签发 Etcd HTTPS 证书

创建证书申请文件：

cat > server-csr.json<< EOF
{
    "CN": "etcd", 
    "hosts": [ 
        "192.168.31.71", 
        "192.168.31.72", 
        "192.168.31.73" 
    ],
    "key": { 
        "algo": "rsa", 
        "size": 2048 
    },
    "names": [ 
         { 
             "C": "CN", 
             "L": "BeiJing", 
             "ST": "BeiJing" 
         } 
    ]
}
EOF

注：上述文件 hosts 字段中 IP 为所有 etcd 节点的集群内部通信 IP，一个都不能少！为了方便后期扩容可以多写几个预留的 IP。
生成证书：

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server 
ls server*pem

可以看到：

server-key.pem server.pem

3.2.3、部署 Etcd 集群

注意：不同版本的Etcd集群部署可能不一样，请依所使用的版本为准

以下在节点 1 上操作，为简化操作，待会将节点 1 生成的所有文件拷贝到节点 2 和节点 3.

（1）创建工作目录并解压二进制包

mkdir /opt/etcd/{bin,cfg,ssl} –p
# 从 Github 下载二进制文件,下载地址：https://github.com/etcd-io/etcd/releases/tag/v3.5.4
wget https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz
tar zxvf etcd-v3.4.9-linux-amd64.tar.gz
mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/

解压后，可以看到三个目录：

etcd.service：这个是etcd的自启动文件，通过查看该文件的内容，可以知道etcd启动需要哪些配置，具体内容如下： ```bash [Unit] Description=Etcd Server After=network.target After=network-online.target Wants=network-online.target

[Service] Type=notify EnvironmentFile=/opt/etcd/cfg/etcd.conf ExecStart=/opt/etcd/bin/etcd \ —name=${ETCD_NAME} \ —data-dir=${ETCD_DATA_DIR} \ —listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \ —listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \ —advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \ —initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \ —initial-cluster=${ETCD_INITIAL_CLUSTER} \ —initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \ —initial-cluster-state=new \ —cert-file=/opt/etcd/ssl/server.pem \ —key-file=/opt/etcd/ssl/server-key.pem \ —peer-cert-file=/opt/etcd/ssl/server.pem \ —peer-key-file=/opt/etcd/ssl/server-key.pem \ —trusted-ca-file=/opt/etcd/ssl/ca.pem \ —peer-trusted-ca-file=/opt/etcd/ssl/ca.pem \ —logger=zap Restart=on-failure LimitNOFILE=65536

[Install] WantedBy=multi-user.target


- etcd
   - bin
      - etcd
      - etcdctl
   - cfg
      - etcd.conf
   - ssl：这里需要删除原有的，替换成我们自己上一步生成的
      - ca.pem
      - server-key.pem
      - server.pem
<a name="C0ZAs"></a>
##### （2）创建 etcd 配置文件
```bash
cat > /opt/etcd/cfg/etcd.conf << EOF
#[Member] 
ETCD_NAME="etcd-1" 
ETCD_DATA_DIR="/var/lib/etcd/default.etcd" 
ETCD_LISTEN_PEER_URLS="https://192.168.31.71:2380" ETCD_LISTEN_CLIENT_URLS="https://192.168.31.71:2379" 
#[Clustering] 
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.31.71:2380" 
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.31.71:2379" 
ETCD_INITIAL_CLUSTER="etcd-1=https://192.168.31.71:2380,etcd- 2=https://192.168.31.72:2380,etcd-3=https://192.168.31.73:2380" 
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster" 
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

参数如下：

ETCD_NAME：节点名称，集群中唯一
ETCD_DATA_DIR：数据目录
ETCD_LISTEN_PEER_URLS：集群通信监听地址
ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEER_URLS：集群通告地址
ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址
ETCD_INITIAL_CLUSTER：集群节点地址
ETCD_INITIAL_CLUSTER_TOKEN：集群 Token
ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new 是新集群，existing 表示加入已有集群
（3）systemd 管理 etcd
```bash cat > /usr/lib/systemd/system/etcd.service << EOF

[Unit] Description=Etcd Server After=network.target After=network-online.target Wants=network-online.target

[Service] Type=notify EnvironmentFile=/opt/etcd/cfg/etcd.conf ExecStart=/opt/etcd/bin/etcd \ —cert-file=/opt/etcd/ssl/server.pem \ —key-file=/opt/etcd/ssl/server-key.pem \ —peer-cert-file=/opt/etcd/ssl/server.pem \ —peer-key-file=/opt/etcd/ssl/server-key.pem \ —trusted-ca-file=/opt/etcd/ssl/ca.pem \ —peer-trusted-ca-file=/opt/etcd/ssl/ca.pem \ —logger=zap Restart=on-failure LimitNOFILE=65536

[Install] WantedBy=multi-user.target

EOF

<a name="xD3uK"></a>
##### （4）拷贝刚才生成的证书
把刚才生成的证书拷贝到配置文件中的路径：
```bash
cp ~/TLS/etcd/ca*pem ~/TLS/etcd/server*pem /opt/etcd/ssl/

（5）启动并设置开机启动

systemctl daemon-reload 
systemctl start etcd 
systemctl enable etcd

（6）将上面节点 1 所有生成的文件拷贝到节点 2 和节点 3

scp -r /opt/etcd/ root@192.168.31.72:/opt/ 
scp /usr/lib/systemd/system/etcd.service root@192.168.31.72:/usr/lib/systemd/system/
scp -r /opt/etcd/ root@192.168.31.73:/opt/ 
scp /usr/lib/systemd/system/etcd.service root@192.168.31.73:/usr/lib/systemd/system/

然后在节点 2 和节点 3 分别修改 etcd.conf 配置文件中的节点名称和当前服务器 IP：

vi /opt/etcd/cfg/etcd.conf

#[Member] 
ETCD_NAME="etcd-1" # 修改此处，节点 2 改为 etcd-2，节点 3 改为 etcd-3
ETCD_DATA_DIR="/var/lib/etcd/default.etcd" 
ETCD_LISTEN_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前服务器 IP 
ETCD_LISTEN_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器 IP 
#[Clustering] 
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://192.168.31.71:2380" # 修改此处为当前服务器 IP 
ETCD_ADVERTISE_CLIENT_URLS="https://192.168.31.71:2379" # 修改此处为当前服务器 
IPETCD_INITIAL_CLUSTER="etcd-1=https://192.168.31.71:2380,etcd- 2=https://192.168.31.72:2380,etcd-3=https://192.168.31.73:2380" 
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster" 
ETCD_INITIAL_CLUSTER_STATE="new"

最后启动 etcd 并设置开机启动，同上。

systemctl daemon-reload 
systemctl start etcd 
systemctl enable 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.31.71:2379,https://192.168.31.72:2379,https://192.16 8.31.73:2379" endpoint health

结果如下：

https://192.168.31.71:2379 is healthy: successfully committed proposal: took = 8.154404ms https://192.168.31.73:2379 is healthy: successfully committed proposal: took = 9.044117ms https://192.168.31.72:2379 is healthy: successfully committed proposal: took = 10.000825ms

如果输出上面信息，就说明集群部署成功。如果有问题第一步先看日志：

vi /var/log/message 
# 或 
journalctl -u etcd

3.3、安装 Docker

在所有节点操作。这里采用二进制安装Docker，用 yum 安装Docker也一样。

3.4、部署 Master Node

3.4.1、生成 kube-apiserver 证书

（1）自签证书颁发机构（CA）

cat > ca-config.json<< EOF
{
    "signing": { 
          "default": { 
                "expiry": "87600h" 
           },
           "profiles": { 
                 "kubernetes": { 
                       "expiry": "87600h", 
                       "usages": [ 
                             "signing", 
                             "key encipherment", 
                             "server auth", 
                             "client auth" 
                         ] 
                   } 
            }
     }
}
EOF

cat > ca-csr.json<< EOF
{
    "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 - 
ls *pem

结果如下：

ca-key.pem ca.pem

（2）使用自签 CA 签发 kube-apiserver HTTPS 证书

创建证书申请文件：

cd TLS/k8s 
cat > server-csr.json<< EOF
{
     "CN": "kubernetes", 
     "hosts": [ 
         "10.0.0.1", 
         "127.0.0.1", 
         "192.168.31.71", 
         "192.168.31.72", 
         "192.168.31.73", 
         "192.168.31.74", 
         "192.168.31.81", 
         "192.168.31.82", 
         "192.168.31.88", 
         "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 server-csr.json | cfssljson -bare server 
ls server*pem

结果如下：

server-key.pem server.pem

3.4.2、下载解压二进制包

（1）从 Github 下载二进制文件

下载地址： https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-
1.18.md#v1183
注：打开链接你会发现里面有很多包，下载一个 server 包就够了，包含了 Master 和 Worker Node 二进制文件。

（2）解压二进制包

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs} 
tar zxvf kubernetes-server-linux-amd64.tar.gz 
cd kubernetes/server/bin 
cp kube-apiserver kube-scheduler kube-controller-manager /opt/kubernetes/bin 
cp kubectl /usr/bin/

3.4.3、部署 kube-apiserver

1. 创建配置文件

cat > /opt/kubernetes/cfg/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--logtostderr=false \\
--v=2 \\ 
--log-dir=/opt/kubernetes/logs \\ 
--etcd- servers=https://192.168.31.71:2379,https://192.168.31.72:2379,https://192.168.3 1.73:2379 \\ 
--bind-address=192.168.31.71 \\ 
--secure-port=6443 \\ 
--advertise-address=192.168.31.71 \\ 
--allow-privileged=true \\ 
--service-cluster-ip-range=10.0.0.0/24 \\ 
--enable-admission- plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestric tion \\ 
--authorization-mode=RBAC,Node \\ 
--enable-bootstrap-token-auth=true \\ 
--token-auth-file=/opt/kubernetes/cfg/token.csv \\ 
--service-node-port-range=30000-32767 \\ 
--kubelet-client-certificate=/opt/kubernetes/ssl/server.pem \\ 
--kubelet-client-key=/opt/kubernetes/ssl/server-key.pem \\ 
--tls-cert-file=/opt/kubernetes/ssl/server.pem \\ 
--tls-private-key-file=/opt/kubernetes/ssl/server-key.pem \\ 
--client-ca-file=/opt/kubernetes/ssl/ca.pem \\ 
--service-account-key-file=/opt/kubernetes/ssl/ca-key.pem \\ 
--etcd-cafile=/opt/etcd/ssl/ca.pem \\ 
--etcd-certfile=/opt/etcd/ssl/server.pem \\ 
--etcd-keyfile=/opt/etcd/ssl/server-key.pem \\ 
--audit-log-maxage=30 \\ 
--audit-log-maxbackup=3 \\ 
--audit-log-maxsize=100 \\ 
--audit-log-path=/opt/kubernetes/logs/k8s-audit.log"
EOF

注：上面两个\ \ 第一个是转义符，第二个是换行符，使用转义符是为了使用 EOF 保留换行符。
参数详情如下：

–logtostderr：启用日志
—v：日志等级
–log-dir：日志目录
–etcd-servers：etcd 集群地址
–bind-address：监听地址
–secure-port：https 安全端口
–advertise-address：集群通告地址
–allow-privileged：启用授权
–service-cluster-ip-range：Service 虚拟 IP 地址段
–enable-admission-plugins：准入控制模块
–authorization-mode：认证授权，启用 RBAC 授权和节点自管理
–enable-bootstrap-token-auth：启用 TLS bootstrap 机制
–token-auth-file：bootstrap token 文件
–service-node-port-range：Service nodeport 类型默认分配端口范围
–kubelet-client-xxx：apiserver 访问 kubelet 客户端证书
–tls-xxx-file：apiserver https 证书
–etcd-xxxfile：连接 Etcd 集群证书
–audit-log-xxx：审计日志
2. 拷贝刚才生成的证书
把刚才生成的证书拷贝到配置文件中的路径：
```
cp ~/TLS/k8s/ca*pem ~/TLS/k8s/server*pem /opt/kubernetes/ssl/
```
3. 启用 TLS Bootstrapping 机制
TLS Bootstraping：Master apiserver 启用 TLS 认证后，Node 节点 kubelet 和 kube-proxy 要与 kube-apiserver 进行通信，必须使用 CA 签发的有效证书才可以，当 Node 节点很多时，这种客户端证书颁发需要大量工作，同样也会增加集群扩展复杂度。为了简化流程，Kubernetes 引入了 TLS bootstraping 机制来自动颁发客户端证书，kubelet 会以一个低权限用户自动向 apiserver 申请证书，kubelet 的证书由 apiserver 动态签署。
所以强烈建议在 Node 上使用这种方式，目前主要用于 kubelet，kube-proxy 还是由我们统一颁发一个证书。
TLS bootstraping 工作流程：

创建上述配置文件中 token 文件：
```
cat > /opt/kubernetes/cfg/token.csv << EOF
c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node-bootstrapper" 
EOF
```
格式：token，用户名，UID，用户组
token 也可自行生成替换：
```
head -c 16 /dev/urandom | od -An -t x | tr -d ' '
```
4. systemd 管理 apiserver
```bash cat > /usr/lib/systemd/system/kube-apiserver.service << EOF

[Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes

[Service] EnvironmentFile=/opt/kubernetes/cfg/kube-apiserver.conf ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS Restart=on-failure

[Install] WantedBy=multi-user.target

EOF

<a name="G027Z"></a>
##### 5. 启动并设置开机启动
```bash
systemctl daemon-reload 
systemctl start kube-apiserver 
systemctl enable kube-apiserver

6. 授权 kubelet-bootstrap 用户允许请求证书

kubectl create clusterrolebinding kubelet-bootstrap \ 
--clusterrole=system:node-bootstrapper \ 
--user=kubelet-bootstrap

3.4.4、部署 kube-controller-manager

1. 创建配置文件

cat > /opt/kubernetes/cfg/kube-controller-manager.conf << EOF
KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\ 
--v=2 \\ 
--log-dir=/opt/kubernetes/logs \\ 
--leader-elect=true \\ 
--master=127.0.0.1:8080 \\ 
--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 \\ 
--experimental-cluster-signing-duration=87600h0m0s" 
EOF

参数详情如下：

–master：通过本地非安全本地端口 8080 连接 apiserver。
–leader-elect：当该组件启动多个时，自动选举（HA）
–cluster-signing-cert-file/–cluster-signing-key-file：自动为 kubelet 颁发证书的 CA，与 apiserver 保持一致
2. systemd 管理 controller-manager
```bash cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF

[Unit] Description=Kubernetes Controller Manager Documentation=https://github.com/kubernetes/kubernetes

[Service] EnvironmentFile=/opt/kubernetes/cfg/kube-controller-manager.conf ExecStart=/opt/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS Restart=on-failure

[Install] WantedBy=multi-user.target

EOF

<a name="J8Pey"></a>
##### 3. 启动并设置开机启动
```bash
systemctl daemon-reload 
systemctl start kube-controller-manager 
systemctl enable kube-controller-manager

3.4.5、部署 kube-scheduler

1. 创建配置文件

cat > /opt/kubernetes/cfg/kube-scheduler.conf << EOF 
KUBE_SCHEDULER_OPTS="--logtostderr=false \ 
--v=2 \ 
--log-dir=/opt/kubernetes/logs \ 
--leader-elect \ 
--master=127.0.0.1:8080 \ 
--bind-address=127.0.0.1" 
EOF

参数详情如下：

–master：通过本地非安全本地端口 8080 连接 apiserver。
–leader-elect：当该组件启动多个时，自动选举（HA）
2. systemd 管理 scheduler
```bash cat > /usr/lib/systemd/system/kube-scheduler.service << EOF

[Unit] Description=Kubernetes Scheduler Documentation=https://github.com/kubernetes/kubernetes

[Service] EnvironmentFile=/opt/kubernetes/cfg/kube-scheduler.conf ExecStart=/opt/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS Restart=on-failure

[Install] WantedBy=multi-user.target

EOF

<a name="mYEdQ"></a>
##### 3. 启动并设置开机启动
```bash
systemctl daemon-reload 
systemctl start kube-scheduler 
systemctl enable kube-scheduler

3.4.6、查看集群状态

所有组件都已经启动成功，通过 kubectl 工具查看当前集群组件状态：

kubectl get cs

结果如下：

NAME STATUS MESSAGE ERROR scheduler Healthy ok controller-manager Healthy ok etcd-2 Healthy {“health”:”true”} etcd-1 Healthy {“health”:”true”} etcd-0 Healthy {“health”:”true”}

如上输出说明 Master 节点组件运行正常。

3.5、部署 Worker Node

下面还是在 Master Node 上操作，即同时作为 Worker Node.

3.5.1、创建工作目录并拷贝二进制文件

在所有 worker node 创建工作目录：

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

从 master 节点拷贝：

cd kubernetes/server/bin 
cp kubelet kube-proxy /opt/kubernetes/bin # 本地拷贝

3.5.2、部署 kubelet

1. 创建配置文件

cat > /opt/kubernetes/cfg/kubelet.conf << EOF 
KUBELET_OPTS="--logtostderr=false \\ 
--v=2 \\ 
--log-dir=/opt/kubernetes/logs \\ 
--hostname-override=k8s-master \\ 
--network-plugin=cni \\ 
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\ 
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\ 
--config=/opt/kubernetes/cfg/kubelet-config.yml \\ 
--cert-dir=/opt/kubernetes/ssl \\ 
--pod-infra-container-image=lizhenliang/pause-amd64:3.0" 
EOF

参数情况如下：

–hostname-override：显示名称，集群中唯一
–network-plugin：启用 CNI
–kubeconfig：空路径，会自动生成，后面用于连接 apiserver
–bootstrap-kubeconfig：首次启动向 apiserver 申请证书
–config：配置参数文件
–cert-dir：kubelet 证书生成目录
–pod-infra-container-image：管理 Pod 网络容器的镜像
2. 配置参数文件
```bash cat > /opt/kubernetes/cfg/kubelet-config.yml << EOF kind: KubeletConfiguration apiVersion: kubelet.config.k8s.io/v1beta1 address: 0.0.0.0 port: 10250 readOnlyPort: 10255 cgroupDriver: cgroupfs clusterDNS:
- 10.0.0.2 clusterDomain: cluster.local failSwapOn: false authentication: anonymous:
```
enabled: false 
```
  webhook:
```
cacheTTL: 2m0s 
enabled: true 
```
  x509:
```
clientCAFile: /opt/kubernetes/ssl/ca.pem
```
  authorization: mode: Webhook webhook:
```
cacheAuthorizedTTL: 5m0s 
cacheUnauthorizedTTL: 30s
```
  evictionHard: imagefs.available: 15% memory.available: 100Mi nodefs.available: 10% nodefs.inodesFree: 5% maxOpenFiles: 1000000 maxPods: 110

EOF

<a name="xrRcl"></a>
##### 3. 生成 bootstrap.kubeconfig 文件
```bash
KUBE_APISERVER="https://192.168.31.71:6443" # apiserver IP:PORT 
TOKEN="c47ffb939f5ca36231d9e3121a252940" # 与 token.csv 里保持一致 
# 生成 kubelet bootstrap kubeconfig 配置文件 
kubectl config set-cluster kubernetes \ 
--certificate-authority=/opt/kubernetes/ssl/ca.pem \ 
--embed-certs=true \ 
--server=${KUBE_APISERVER} \ 
--kubeconfig=bootstrap.kubeconfig 
kubectl config set-credentials "kubelet-bootstrap" \ 
--token=${TOKEN} \ 
--kubeconfig=bootstrap.kubeconfig 
kubectl config set-context default \ 
--cluster=kubernetes \ 
--user="kubelet-bootstrap" \ 
--kubeconfig=bootstrap.kubeconfig 
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

拷贝到配置文件路径：

cp bootstrap.kubeconfig /opt/kubernetes/cfg

4. systemd 管理 kubelet

cat > /usr/lib/systemd/system/kubelet.service << EOF 
[Unit] 
Description=Kubernetes Kubelet 
After=docker.service 
[Service] 
EnvironmentFile=/opt/kubernetes/cfg/kubelet.conf
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS 
Restart=on-failure 
LimitNOFILE=65536 
[Install] 
WantedBy=multi-user.target 
EOF

5. 启动并设置开机启动

systemctl daemon-reload 
systemctl start kubelet 
systemctl enable kubelet

3.5.3、批准 kubelet 证书申请并加入集群

1、查看 kubelet 证书请求

kubectl get csr

结果如下：

NAME AGE SIGNERNAME REQUESTOR CONDITION node-csr-uCEGPOIiDdlLODKts8J658HrFq9CZ—K6M4G7bjhk8A 6m3s kubernetes.io/kube apiserver-client-kubelet kubelet-bootstrap Pending

2、批准申请

kubectl certificate approve node-csr-uCEGPOIiDdlLODKts8J658HrFq9CZ--K6M4G7bjhk8A

3、查看节点

kubectl get node

注：由于网络插件还没有部署，节点会没有准备就绪 NotReady

3.5.4、部署 kube-proxy

1. 创建配置文件

cat > /opt/kubernetes/cfg/kube-proxy.conf << EOF 
KUBE_PROXY_OPTS="--logtostderr=false \\ 
--v=2 \\ 
--log-dir=/opt/kubernetes/logs \\ 
--config=/opt/kubernetes/cfg/kube-proxy-config.yml" 
EOF

2. 配置参数文件

cat > /opt/kubernetes/cfg/kube-proxy-config.yml << EOF 
kind: KubeProxyConfiguration 
apiVersion: kubeproxy.config.k8s.io/v1alpha1 
bindAddress: 0.0.0.0 
metricsBindAddress: 0.0.0.0:10249 
clientConnection: 
    kubeconfig: /opt/kubernetes/cfg/kube-proxy.kubeconfig 
hostnameOverride: k8s-master 
clusterCIDR: 10.0.0.0/24 
EOF

3. 生成 kube-proxy.kubeconfig 文件

（1）生成 kube-proxy 证书：

# 切换工作目录 
cd TLS/k8s 
# 创建证书请求文件 
cat > kube-proxy-csr.json<< EOF 
{ 
    "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
ls kube-proxy*pem
# kube-proxy-key.pem kube-proxy.pem

（2）生成 kubeconfig 文件：

KUBE_APISERVER="https://192.168.31.71:6443" 
kubectl config set-cluster kubernetes \ 
--certificate-authority=/opt/kubernetes/ssl/ca.pem \ 
--embed-certs=true \ 
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig 
kubectl config set-credentials kube-proxy \ 
--client-certificate=./kube-proxy.pem \ 
--client-key=./kube-proxy-key.pem \ 
--embed-certs=true \ 
--kubeconfig=kube-proxy.kubeconfig 
kubectl config set-context default \ 
--cluster=kubernetes \ 
--user=kube-proxy \ 
--kubeconfig=kube-proxy.kubeconfig 
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

（3）拷贝到配置文件指定路径：

cp kube-proxy.kubeconfig /opt/kubernetes/cfg/

4. systemd 管理 kube-proxy

cat > /usr/lib/systemd/system/kube-proxy.service << EOF 
[Unit] 
Description=Kubernetes Proxy 
After=network.target 
[Service] 
EnvironmentFile=/opt/kubernetes/cfg/kube-proxy.conf 
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS 
Restart=on-failure 
LimitNOFILE=65536 
[Install] 
WantedBy=multi-user.target 
EOF

5. 启动并设置开机启动

systemctl daemon-reload 
systemctl start kube-proxy 
systemctl enable kube-proxy

3.6、部署 CNI 网络

3.6.1、下载解压二进制文件

下载地址： https://github.com/containernetworking/plugins/releases/download/v0.8.6/cni- plugins-linux-amd64-v0.8.6.tgz
解压二进制包并移动到默认工作目录：

mkdir /opt/cni/bin 
tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin

3.6.2、部署 CNI 网络

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube- flannel.yml 
sed -i -r "s#quay.io/coreos/flannel:.*-amd64#lizhenliang/flannel:v0.12.0- amd64#g" kube-flannel.yml

默认镜像地址无法访问，修改为 docker hub 镜像仓库。

kubectl apply -f kube-flannel.yml 
kubectl get pods -n kube-system 
kubectl get node

部署好网络插件，Node 准备就绪。

3.7、授权 apiserver 访问 kubelet

cat > apiserver-to-kubelet-rbac.yaml<< EOF 
apiVersion: rbac.authorization.k8s.io/v1 
kind: ClusterRole
metadata: 
    annotations: 
        rbac.authorization.kubernetes.io/autoupdate: "true" 
    labels: 
        kubernetes.io/bootstrapping: rbac-defaults 
    name: system:kube-apiserver-to-kubelet
rules: 
    - apiGroups: 
        - "" 
      resources: 
          - nodes/proxy 
          - nodes/stats 
          - nodes/log 
          - nodes/spec 
          - nodes/metrics 
          - pods/log 
      verbs: 
          - "*" 
---
apiVersion: rbac.authorization.k8s.io/v1 
kind: ClusterRoleBinding 
metadata: 
    name: system:kube-apiserver 
    namespace: ""
roleRef: 
    apiGroup: rbac.authorization.k8s.io 
    kind: ClusterRole 
    name: system:kube-apiserver-to-kubelet 
subjects:
    - apiGroup: rbac.authorization.k8s.io 
      kind: User 
      name: kubernetes
EOF
kubectl apply -f apiserver-to-kubelet-rbac.yaml

3.8、新增加 Worker Node

3.8.1、拷贝已部署好的 Node 相关文件到新节点

在 master 节点将 Worker Node 涉及文件拷贝到新节点 192.168.31.72/73

scp -r /opt/kubernetes root@192.168.31.72:/opt/ 
scp -r /usr/lib/systemd/system/{kubelet,kube-proxy}.service root@192.168.31.72:/usr/lib/systemd/system
scp -r /opt/cni/ root@192.168.31.72:/opt/ 
scp /opt/kubernetes/ssl/ca.pem root@192.168.31.72:/opt/kubernetes/ssl

3.8.2、删除 kubelet 证书和 kubeconfig 文件

rm /opt/kubernetes/cfg/kubelet.kubeconfig 
rm -f /opt/kubernetes/ssl/kubelet*

注：这几个文件是证书申请审批后自动生成的，每个 Node 不同，必须删除重新生成。

3.8.3、修改主机名

vi /opt/kubernetes/cfg/kubelet.conf 
--hostname-override=k8s-node1
vi /opt/kubernetes/cfg/kube-proxy-config.yml
hostnameOverride: k8s-node1

3.8.4、启动并设置开机启动

systemctl daemon-reload 
systemctl start kubelet 
systemctl enable kubelet 
systemctl start kube-proxy 
systemctl enable kube-proxy

3.8.5、在 Master 上批准新 Node kubelet 证书申请

kubectl get csr

结果如下：

NAME AGE SIGNERNAME REQUESTOR CONDITION node-csr-4zTjsaVSrhuyhIGqsefxzVoZDCNKei-aE2jyTP81Uro 89s kubernetes.io/kube-apiserver-client-kubelet kubelet-bootstrap Pending

批准：

kubectl certificate approve node-csr-4zTjsaVSrhuyhIGqsefxzVoZDCNKei-aE2jyTP81Uro

3.8.6、.查看 Node 状态

kubectl get node

Node2（192.168.31.73 ）节点同上。记得修改主机名！

2.2、二进制包方式部署k8集群

1、安装要求

2、准备环境

2.1、软件环境

2.2、服务器规划

3、开始搭建

3.1、系统初始化

3.1.1、关闭防火墙

3.1.2、关闭 selinux

3.1.3、关闭 swap

3.1.4、设置主机名

3.1.5、在master添加hosts

3.1.6、将桥接的 IPv4 流量传递到 iptables 的链

3.1.7、时间同步

3.2、部署 Etcd 集群

3.2.1、准备 cfssl 证书生成工具

3.2.2、生成 Etcd 证书

（1）自签证书颁发机构（CA）

（2）使用自签 CA 签发 Etcd HTTPS 证书

3.2.3、部署 Etcd 集群

（1）创建工作目录并解压二进制包

（3）systemd 管理 etcd

（5）启动并设置开机启动

（6）将上面节点 1 所有生成的文件拷贝到节点 2 和节点 3

（7）查看集群状态

3.3、安装 Docker

3.4、部署 Master Node

3.4.1、生成 kube-apiserver 证书

（1）自签证书颁发机构（CA）

（2）使用自签 CA 签发 kube-apiserver HTTPS 证书

3.4.2、下载解压二进制包

（1）从 Github 下载二进制文件

（2）解压二进制包

3.4.3、部署 kube-apiserver

1. 创建配置文件

2. 拷贝刚才生成的证书

3. 启用 TLS Bootstrapping 机制

4. systemd 管理 apiserver

6. 授权 kubelet-bootstrap 用户允许请求证书

3.4.4、部署 kube-controller-manager

1. 创建配置文件

2. systemd 管理 controller-manager

3.4.5、部署 kube-scheduler

1. 创建配置文件

2. systemd 管理 scheduler

3.4.6、 查看集群状态

3.5、部署 Worker Node

3.5.1、创建工作目录并拷贝二进制文件

3.5.2、部署 kubelet

1. 创建配置文件

2. 配置参数文件

4. systemd 管理 kubelet

5. 启动并设置开机启动

3.5.3、批准 kubelet 证书申请并加入集群

3.5.4、部署 kube-proxy

1. 创建配置文件

2. 配置参数文件

3. 生成 kube-proxy.kubeconfig 文件

（1）生成 kube-proxy 证书：

（2）生成 kubeconfig 文件：

（3）拷贝到配置文件指定路径：

4. systemd 管理 kube-proxy

5. 启动并设置开机启动

3.6、部署 CNI 网络

3.6.1、下载解压二进制文件

3.6.2、部署 CNI 网络

3.7、授权 apiserver 访问 kubelet

3.8、新增加 Worker Node

3.8.1、 拷贝已部署好的 Node 相关文件到新节点

3.8.2、删除 kubelet 证书和 kubeconfig 文件

3.8.3、修改主机名

3.8.4、启动并设置开机启动

3.8.5、在 Master 上批准新 Node kubelet 证书申请

3.8.6、.查看 Node 状态

3.4.6、查看集群状态

3.8.1、拷贝已部署好的 Node 相关文件到新节点