【k8s】2、二进制安装k8s

前期概要

常见的K8S按照部署方式

minikube

• 是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习，预习K8S的一些特性使用。

Kubeadmin

• kubeadmin也是一个工具，特工kubeadm init 和kubedm join，用于快速部署k8s。相对简单。

二进制安装部署

• 生产首选，从官方下载发行版的二进制包，手动部署每个组件的和自签TLS证书，组成K8S集群。

一、环境准备

端口介绍

链接：https://pan.baidu.com/s/10gREJwP4JIN_tTxNv6YU-Q
提取码：yudq

VIP：20.0.0.100

二、操作系统的初始化

一键部署环境脚本。

#!/bin/bash
# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -t nat -F && iptables -t mangle -F && iptables -X

# 关闭selinux
# 永久关闭
sed -i 's/enforcing/disabled/' /etc/selinux/config  
# 临时关闭
setenforce 0  

# 关闭swap
# 临时
swapoff -a 
# 永久关闭
sed -ri 's/.*swap.*/#&/' /etc/fstab


# 在master添加hosts
cat >> /etc/hosts << EOF
20.0.0.55 master01
20.0.0.56 node01
20.0.0.57 node02
EOF


# 将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf << EOF
#开启网桥模式，可将网桥的流量传递给iptables链
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
#关闭ipv6协议
net.ipv6.conf.all.disable_ipv6=1
net.ipv4.ip_forward=1
EOF


# 生效
sysctl --system  

# 时间同步
yum install ntpdate -y
ntpdate time.windows.com

crontab -e 
*/10 * * * * /usr/sbin/ntpdate/ntpdate time.windows.com
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

手动修改各个节点的主机名

# 根据规划设置主机名【master01节点上操作】
hostnamectl set-hostname master01

# 根据规划设置主机名【node01节点操作】
hostnamectl set-hostname node01

# 根据规划设置主机名【node02节点操作】
hostnamectl set-hostname node02
1
2
3
4
5
6
7
8

三、部署Etcd集群

etcd是一个分布式键值存储系统，Kubernetes使用Etcd进行数据存储，所以先准备一个Etcd进行数据存储，为了解决Etcd单点故障，应采用集群方式部署。

• 这里使用3台组组件集群，可以容忍一台机器故障，当然也可以使用5台组件集群，可以容忍2台机器故障，

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

1、 准备cfssl证书生成工具

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

cd /usr/local/bin

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 
#获取生成证书的工具
---------------------------------------------------------------
cfssl: 证书签发的工具命令
cfssljson: 将cfssl生成的证书(json格式)变成文件承载式证书
cfssl-certinfo: 验证证书的信息
cfssl-certinfo -cert <证书名称>   #查看证书的信息
---------------------------------------------------------------
    
chmod +x *
#给予执行权限

mv cfssl-certinfo_linux-amd64 cfssl
mv cfssljson_linux-amd64 cfssljson
mv cfssl_linux-amd64 cfssl-certinfo
#修改为简单的名称，好识别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、生成etcd证书

自签证书颁发机构CA

mkdir -p /opt/k8s/etcd-cert
#创建存放etcd证书的目录

cd /opt/k8s/etcd-cert
#############自签CA，包含证书的过期时间10年 ###############
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 -
##当前目录下会生成 ca.pem和ca-key.pem文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

使用自签CA签发Etcd HTTPS证书

cat > server-csr.json <<EOF
{
    "CN": "etcd",
    "hosts": [
    "20.0.0.55",
    "20.0.0.56",
    "20.0.0.57"
    ],
    "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
#当前目录下会生成server.pem 和 server-key.pem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3、部署Etcd集群

因为咱们证书是在master01节点上操作的证书，先以master为例演示，然后将所有文件拷贝到node01和node02节点上操作。

创建工作目录并下载二进制包

wget https://github.com/etcd-io/etcd/releases/download/v3.4.9/etcd-v3.4.9-linux-amd64.tar.gz

mkdir -p /opt/etcd/{bin,cfg,ssl}
#创建etcd集群的工作目录，【bin里面存放的是可执行文件,cfg配置文件,ssl证书】

tar -zxvf etcd-v3.4.9-linux-amd64.tar.gz 
#将下载的包解压

mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /opt/etcd/bin/
#将解压后的文件中，两个执行文件剪切到，前面创建集群目录中的bin目录下
1
2
3
4
5
6
7
8
9
10

创建etcd配置文件

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://20.0.0.55:2380" 
ETCD_LISTEN_CLIENT_URLS="https://20.0.0.55:2379" 
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.55:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.55:2379"
ETCD_INITIAL_CLUSTER="etcd-1=https://20.0.0.55:2380,etcd-2=https://20.0.0.56:2380,etcd-3=https://20.0.0.57: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表示加入已有集群

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

systemd管理etcd

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

将刚才生成的证书拷贝到配置文件中

cp /opt/k8s/etcd-cert/ca*pem /opt/k8s/etcd-cert/server*pem /opt/etcd/ssl/
#在存放证书的目录中将需要的证书拷贝到etcd的工作目录中去
1
2

将上面master01生成所有文件拷贝到node01和node02

# 拷贝到node01
scp -r /opt/etcd/ root@20.0.0.56:/opt/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.56:/usr/lib/systemd/system/

#拷贝到node02
scp -r /opt/etcd/ root@20.0.0.57:/opt/
scp /usr/lib/systemd/system/etcd.service root@20.0.0.57:/usr/lib/systemd/system/
1
2
3
4
5
6
7

然后修改node01和node02上面etcd.conf配置文件中的节点名称和ip地址

• 下面仅演示模板

vim /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://20.0.0.56:2380" # 修改此处为当前服务器 IP ETCD_LISTEN_CLIENT_URLS="https://20.0.0.56:2379" # 修改此处为当前服务器 IP
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://20.0.0.56:2380" # 修改此处为当前服务器 IP
ETCD_ADVERTISE_CLIENT_URLS="https://20.0.0.56:2379" # 修改此处为当前服务器IP
ETCD_INITIAL_CLUSTER="etcd-1=https://20.0.0.55:2380,etcd-2=https://20.0.0.56:2380,etcd-3=https://:20.0.0.56::2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

1
2
3
4
5
6
7
8
9
10
11
12

启动并设置开机启动（3个节点都要）

systemctl daemon-reload 
systemctl start etcd 
systemctl enable etcd

systemctl status etcd

####注意！启动的时候，需要至少启动两个，才会正常完成启动，不然会卡出。
1
2
3
4
5
6
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://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379" endpoint health

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.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379" endpoint status --write-out=table

####任意节点都可
1
2
3
4
5

四、安装docker(所有node节点)

//所有 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 clean all && yum makecache

yum install -y docker-ce docker-ce-cli containerd.io

systemctl start docker.service
systemctl enable docker.service 

1
2
3
4
5
6
7
8
9
10
11
12

五、部署master组件

1、 准备证书

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

mkdir /opt/k8s/k8s-cert
#创建k8s证书、脚本存储的目录

cd /opt/k8s/k8s-cert
1
2
3
4
5
6
7

生成CA证书、相关组件的证书和私钥的脚本

vim /opt/k8s/k8s-cert/k8s-cert.sh

#!/bin/bash
#配置证书生成策略，让 CA 软件知道颁发有什么功能的证书，生成用来签发其他组件证书的根证书
cat > ca-config.json <<EOF
{
  "signing": {
    "default": {
      "expiry": "87600h"
    },
    "profiles": {
      "kubernetes": {
         "expiry": "87600h",
         "usages": [
            "signing",
            "key encipherment",
            "server auth",
            "client auth"
        ]
      }
    }
  }
}
EOF

#生成CA证书和私钥（根证书和私钥）
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 -


#-----------------------
#生成 apiserver 的证书和私钥（apiserver和其它k8s组件通信使用）
#hosts中将所有可能作为 apiserver 的 ip 添加进去，后面 keepalived 使用的 VIP 也要加入
cat > apiserver-csr.json <<EOF
{
    "CN": "kubernetes",
    "hosts": [
      "10.0.0.1",
      "127.0.0.1",
      "20.0.0.55",		
      "20.0.0.58",		
      "20.0.0.100",		
      "20.0.0.56",		
      "20.0.0.57",		
      "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 <<EOF
{
  "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 <<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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

此处一定要检查生成的证书配置文件是否到位

2、 准备二进制文件、token

准备二进制文件

cd /opt/k8s/k8s-cert

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

#然后再上传kubernetes-server-linux-amd64.tar.gz压缩包

tar zxvf kubernetes-server-linux-amd64.tar.gz
#将上传的压缩包解压

cd  kubernetes/server/bin
#进入到压缩后的目录中

cp kube-apiserver kubectl kube-controller-manager kube-scheduler /opt/kubernetes/bin/
#将三个master的组件和一个kubectl命令拷贝到k8s的工作目录中的bin目录下
    
ln -s /opt/kubernetes/bin/* /usr/local/bin/
#创建master组件的关键命令文件到 kubernetes工作目录的 bin 子目录中(此处需要使用绝对路径创建软连接，不然软连接找不到源文件)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

准备token令牌

#创建 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

chmod +x token.sh
./token.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、 启动kube-apiserver服务

准备启动脚本

vim /opt/k8s/k8s-cert/apiserver.sh

#!/bin/bash
#例子: apiserver.sh 20.0.0.55 https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379
#创建 kube-apiserver 启动参数配置文件
MASTER_ADDRESS=$1
ETCD_SERVERS=$2

cat >/opt/kubernetes/cfg/kube-apiserver <<EOF
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 \\
--kubelet-client-key=/opt/kubernetes/ssl/apiserver-key.pem \\
--tls-cert-file=/opt/kubernetes/ssl/apiserver.pem  \\
--tls-private-key-file=/opt/kubernetes/ssl/apiserver-key.pem \\
--client-ca-file=/opt/kubernetes/ssl/ca.pem \\
--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-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-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"
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-admission-plugins：准入控制模块。kuberneres集群的准入控制机制，各控制模块以插件的形式依次生效，集群时必须包含ServiceAccount，运行在认证（Authentication）、授权（Authorization）之后，Admission Control是权限认证链上的最后一环， 对请求API资源对象进行修改和校验
#--authorization-mode：认证授权，启用RBAC授权和节点自管理。在安全端口使用RBAC,Node授权模式，未通过授权的请求拒绝，默认值AlwaysAllow。RBAC是用户通过角色与权限进行关联的模式；Node模式（节点授权）是一种特殊用途的授权模式，专门授权由kubelet发出的API请求，在进行认证时，先通过用户名、用户分组验证是否是集群中的Node节点，只有是Node节点的请求才能使用Node模式授权
#--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 <<EOF
[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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert
./apiserver.sh 20.0.0.55 https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379
#执行创建的脚本，注意有两个位置变量，一个是确定本机的IP地址，一个是etcd集群的IP和端口

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

netstat -natp | grep 6443   
#安全端口6443用于接收HTTPS请求，用于基于Token文件或客户端证书等认证

1
2
3
4
5
6
7
8
9
10

4、启动scheduler服务

准备启动脚本，脚本放在 /opt/k8s 中

vim /opt/k8s/k8s-cert/scheduler.sh

#!/bin/bash
##创建 kube-scheduler 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-scheduler <<EOF
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 选举
#k8s中Controller-Manager和Scheduler的选主逻辑：k8s中的etcd是整个集群所有状态信息的存储，涉及数据的读写和多个etcd之间数据的同步，对数据的一致性要求严格，所以使用较复杂的 raft 算法来选择用于提交数据的主节点。而 apiserver 作为集群入口，本身是无状态的web服务器，多个 apiserver 服务之间直接负载请求并不需要做选主。Controller-Manager 和 Scheduler 作为任务类型的组件，比如 controller-manager 内置的 k8s 各种资源对象的控制器实时的 watch apiserver 获取对象最新的变化事件做期望状态和实际状态调整，调度器watch未绑定节点的pod做节点选择，显然多个这些任务同时工作是完全没有必要的，所以 controller-manager 和 scheduler 也是需要选主的，但是选主逻辑和 etcd 不一样的，这里只需要保证从多个 controller-manager 和 scheduler 之间选出一个 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

#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-scheduler.kubeconfig"
KUBE_APISERVER="https://$MASTER_ADDRESS: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 <<EOF
[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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert

./scheduler.sh 20.0.0.55
#执行脚本,主要位置变量，需要写入本机的IP地址

ps aux | grep kube-scheduler
1
2
3
4
5
6

5、启动controller-manager 服务

准备启动脚本

vim /opt/k8s/k8s-cert/controller-manager.sh

#!/bin/bash
##创建 kube-controller-manager 启动参数配置文件
MASTER_ADDRESS=$1

cat >/opt/kubernetes/cfg/kube-controller-manager <<EOF
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 集群
#--cluster-cidr=10.244.0.0/16：pod资源的网段，需与pod网络插件的值设置一致。通常，Flannel网络插件的默认为10.244.0.0/16，Calico插件的默认值为192.168.0.0/16
#--cluster-signing-cert-file/–-cluster-signing-key-file：自动为kubelet颁发证书的CA，与apiserver保持一致。指定签名的CA机构根证书，用来签名为 TLS BootStrapping 创建的证书和私钥
#--root-ca-file：指定根CA证书文件路径，用来对 kube-apiserver 证书进行校验，指定该参数后，才会在 Pod 容器的 ServiceAccount 中放置该 CA 证书文件
#--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

#生成证书
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

#生成kubeconfig文件
KUBE_CONFIG="/opt/kubernetes/cfg/kube-controller-manager.kubeconfig"
KUBE_APISERVER="https://$1: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 <<EOF
[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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

执行脚本、验证是否启动成功

cd /opt/k8s/k8s-cert

./controller-manager.sh 20.0.0.55
#启动脚本，并带上位置变量,位置变量为本机IP

ps aux | grep kube-controller-manager
1
2
3
4
5
6

6、生成kubectl连接集群的kubeconfig文件

准备执行脚本

vim /opt/k8s/k8s-cert/admin.sh

#!/bin/bash
mkdir /root/.kube
KUBE_CONFIG="/root/.kube/config"
KUBE_APISERVER="https://20.0.0.55: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}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

执行脚本

7、通过kubectl工具查看当前集群组件状态

kubectl get cs
#查看当前集群组件状态(都为健康状态即可，如果不健康，需要排错)

kubectl version
#查看版本信息(显示客户端和服务端的版本信息)
1
2
3
4
5

六、部署worker node组件

理论部分描述

kubelet 采用TLS Bootstapping 机制，自动完成到kube-apiserver的注册，在node节点量较大或后期自动扩容时非常有用。

• master apiserver 启用TLS认证后，node节点kubelet组件想要加入集群，必须使用CA签发的有效证书才能于apiserver通信，当node节点很多时，**签署证书是一件很繁琐的事情，因此kubernetes引入了 TLS bootstraping 机制来自动颁发客户端证书，**kubelet会以一个低权限的用户自动向api server申请证书，kuubelet的证书由apiserver动态签署。
• kuubelet首次启动通过加载bootstrap.kubeconfig 中的用户 Token 和 apiserver CA 证书发起首次CSR 请求， 这个Token被预先内置在apiserver节点的token.csv中，其身份为 kubelet-bootstrap 用户和system:kubelet-bootstrap 用户组，想要首次CSR请求成功（就是不会被apiserver 401拒绝），则需要先创建一个 ClusterRoleBinding，将kubelet-bootstrap用户和system:node-bootstrapper内置 ClusterRole绑定（通过kubelet get clustterroles 可查询），使其能够发起CSR认证请求。
• TLS bootstrapping 时的证书实际是由 kube-controller-manager 组件来签署的，也就是说证书有效期是 kube-controller-manager 组件控制的； kube-controller-manager 组件提供了一个 --experimental-cluster-signing-duration 参数来设置签署的证书有效时间；默认为 8760h0m0s，将其改为 87600h0m0s，即 10 年后再进行 TLS bootstrapping 签署证书即可。
• 也就是说 kubelet 首次访问 API Server 时，是使用 token 做认证，通过后，Controller Manager 会为 kubelet 生成一个证书，以后的访问都是用证书做认证了。

1、在所有 node 节点上操作

mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}
#创建kubernetes的工作目录(提前创建号两个node的k8s的工作目录)
1
2

2、在master01上生成文件scp到node01

cd /opt/k8s/k8s-cert/kubernetes/server/bin
#在master01中进入到前面解压的用压缩文件，里面有node节点需要用到的两个组件，一个kubelet、一个lube-proxy组件

scp kubelet kube-proxy root@20.0.0.56:/opt/kubernetes/bin/
scp kubelet kube-proxy root@20.0.0.57:/opt/kubernetes/bin/
#把kubelet、kube-proxy 拷贝到 node 节点的工作目录中(因为是执行文件所以拷贝到bin目录下)
1
2
3
4
5
6

准备kubeconfig脚本文件

vim /opt/k8s/k8s-cert/kubeconfig.sh

#!/bin/bash
#example: kubeconfig 20.0.0.55 /opt/k8s/k8s-cert/
#创建bootstrap.kubeconfig文件
#该文件中内置了 token.csv 中用户的 Token，以及 apiserver CA 证书；kubelet 首次启动会加载此文件，使用 apiserver CA 证书建立与 apiserver 的 TLS 通讯，使用其中的用户 Token 作为身份标识向 apiserver 发起 CSR 请求

BOOTSTRAP_TOKEN=$(awk -F ',' '{print $1}' /opt/kubernetes/cfg/token.csv)
#获取token令牌

APISERVER=$1   #位置变量，获取本机ip
SSL_DIR=$2     #获取存放路径。

export KUBE_APISERVER="https://$APISERVER:6443"

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=bootstrap.kubeconfig
#--embed-certs=true：表示将ca.pem证书写入到生成的bootstrap.kubeconfig文件中

# 设置客户端认证参数，kubelet 使用 bootstrap token 认证
kubectl config set-credentials kubelet-bootstrap \
  --token=${BOOTSTRAP_TOKEN} \
  --kubeconfig=bootstrap.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=kubelet-bootstrap \
  --kubeconfig=bootstrap.kubeconfig

# 使用上下文参数生成 bootstrap.kubeconfig 文件
kubectl config use-context default --kubeconfig=bootstrap.kubeconfig

#----------------------

#创建kube-proxy.kubeconfig文件
# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=$SSL_DIR/ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=kube-proxy.kubeconfig

# 设置客户端认证参数，kube-proxy 使用 TLS 证书认证
kubectl config set-credentials kube-proxy \
  --client-certificate=$SSL_DIR/kube-proxy.pem \
  --client-key=$SSL_DIR/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

# 使用上下文参数生成 kube-proxy.kubeconfig 文件
kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

执行脚本文件

cd /opt/k8s/k8s-cert/

chmod +x kubeconfig.sh

./kubeconfig.sh 20.0.0.55 /opt/k8s/k8s-cert/
#执行脚本，需要添加两个位置变量，一个本机IP，一个生成的文件所在的目录
1
2
3
4
5
6

cd /opt/k8s/k8s-cert/
    
scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.56:/opt/kubernetes/cfg/

scp bootstrap.kubeconfig kube-proxy.kubeconfig root@20.0.0.57:/opt/kubernetes/cfg/
#把配置文件 bootstrap.kubeconfig、kube-proxy.kubeconfig 拷贝到 node 节点

kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
#RBAC授权，使用户 kubelet-bootstrap 能够有权限发起 CSR 请求证书

kubectl create clusterrolebinding cluster-system-anonymous --clusterrole=cluster-admin --user=system:anonymous
#给kubectl绑定默认cluster-admin管理员集群角色，授权集群操作权限

1
2
3
4
5
6
7
8
9
10
11
12
13

3、node01安装kubelet服务

准备kubelet服务的执行脚本文件

mkdir /opt/k8s-cert/
#创建一个目录用来存储脚本文件

vim /opt/k8s-cert/kubelet.sh

#!/bin/bash
#例子:./kubelet.sh 20.0.0.56
NODE_ADDRESS=$1
DNS_SERVER_IP=${2:-"10.0.0.2"}

#创建 kubelet 启动参数配置文件
cat >/opt/kubernetes/cfg/kubelet <<EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=${NODE_ADDRESS} \\
--network-plugin=cni \\
--kubeconfig=/opt/kubernetes/cfg/kubelet.kubeconfig \\
--bootstrap-kubeconfig=/opt/kubernetes/cfg/bootstrap.kubeconfig \\
--config=/opt/kubernetes/cfg/kubelet.config \\
--cert-dir=/opt/kubernetes/ssl \\
--pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0"
EOF

#--hostname-override：指定kubelet节点在集群中显示的主机名或IP地址，默认使用主机hostname；kube-proxy和kubelet的此项参数设置必须完全一致
#--network-plugin：启用CNI
#--kubeconfig：指定kubelet.kubeconfig文件位置，当前为空路径，会自动生成，用于如何连接到apiserver，里面含有kubelet证书，master授权完成后会在node节点上生成 kubelet.kubeconfig 文件
#--bootstrap-kubeconfig：指定连接 apiserver 的 bootstrap.kubeconfig 文件
#--config：指定kubelet配置文件的路径，启动kubelet时将从此文件加载其配置
#--cert-dir：指定master颁发的kubelet证书生成目录
#--pod-infra-container-image：指定Pod基础容器（Pause容器）的镜像。Pod启动的时候都会启动一个这样的容器，每个pod之间相互通信需要Pause的支持，启动Pause需要Pause基础镜像


#----------------------
#创建kubelet配置文件（该文件实际上就是一个yml文件，语法非常严格，不能出现tab键，冒号后面必须要有空格，每行结尾也不能有空格）
cat >/opt/kubernetes/cfg/kubelet.config <<EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: ${NODE_ADDRESS}
port: 10250
readOnlyPort: 10255
cgroupDriver: cgroupfs
clusterDNS:
- ${DNS_SERVER_IP} 
clusterDomain: cluster.local
failSwapOn: false
authentication:
  anonymous:
    enabled: true
EOF

#PS：当命令行参数与此配置文件（kubelet.config）有相同的值时，就会覆盖配置文件中的该值。


#----------------------
#创建 kubelet.service 服务管理文件
cat >/usr/lib/systemd/system/kubelet.service <<EOF
[Unit]
Description=Kubernetes Kubelet
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=/opt/kubernetes/cfg/kubelet
ExecStart=/opt/kubernetes/bin/kubelet \$KUBELET_OPTS
Restart=on-failure
KillMode=process

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kubelet
systemctl restart kubelet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

执行脚本

cd /opt
chmod +x kubelet.sh
./kubelet.sh 20.0.0.56
#执行脚本，需要带上本机node节点的IP，此脚本，主要时出啊关键kubelet的配置文件，启动kubelet的时候，也相当于给master01发送了CSR认证请求。

ps aux|grep kubelet
#查看是否启动
1
2
3
4
5
6
7

4、master01验证CSR请求

kubectl get csr
#检查到 node01 节点的 kubelet 发起的 CSR 请求，Pending 表示等待集群给该节点签发证书

kubectl certificate approve 【node-csr-duiobEzQ0R93HsULoS9NT9JaQylMmid_nBF3Ei3NtFE(这里面的根据实际的来)】
#通过CSR请求

kubectl get csr
#Approved,Issued 表示已授权 CSR 请求并签发证书

kubectl get node
#查看节点，由于网络插件还没有部署，节点会没有准备就绪，就会显示NotReady
1
2
3
4
5
6
7
8
9
10
11

5、node01安装proxy服务

准备执行脚本

for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
#使用一个for循环，加载ip_vs模块
-------------------------------------------------------------------------------
vim /opt/k8s-cert/proxy.sh 

#!/bin/bash
#例子: ./proxy.sh 20.0.0.56
NODE_ADDRESS=$1

#创建 kube-proxy 启动参数配置文件
cat >/opt/kubernetes/cfg/kube-proxy <<EOF
KUBE_PROXY_OPTS="--logtostderr=true \\
--v=4 \\
--hostname-override=${NODE_ADDRESS} \\
--cluster-cidr=172.17.0.0/16 \\
--proxy-mode=ipvs \\
--kubeconfig=/opt/kubernetes/cfg/kube-proxy.kubeconfig"
EOF

#--hostnameOverride: 参数值必须与 kubelet 的值一致，否则 kube-proxy 启动后会找不到该 Node，从而不会创建任何 ipvs 规则
#--cluster-cidr：指定 Pod 网络使用的聚合网段，Pod 使用的网段和 apiserver 中指定的 service 的 cluster ip 网段不是同一个网段。 kube-proxy 根据 --cluster-cidr 判断集群内部和外部流量，指定 --cluster-cidr 选项后 kube-proxy 才会对访问 Service IP 的请求做 SNAT，即来自非 Pod 网络的流量被当成外部流量，访问 Service 时需要做 SNAT。
#--proxy-mode：指定流量调度模式为ipvs模式，可添加--ipvs-scheduler选项指定ipvs调度算法（rr|wrr|lc|wlc|lblc|lblcr|dh|sh|sed|nq）
#--kubeconfig: 指定连接 apiserver 的 kubeconfig 文件	


#----------------------
#创建 kube-proxy.service 服务管理文件
cat >/usr/lib/systemd/system/kube-proxy.service <<EOF
[Unit]
Description=Kubernetes Proxy
After=network.target

[Service]
EnvironmentFile=-/opt/kubernetes/cfg/kube-proxy
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable kube-proxy
systemctl restart kube-proxy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

执行脚本

cd /opt
chmod +x proxy.sh
./proxy.sh 20.0.0.56
#指向脚本，注意需要带入位置参数，为本机的IP地址，此脚本主要时配置proxy的配置文件，并启动它

ps aux |grep kube-proxy
1
2
3
4
5
6

七、部署CNI网络组建

1、部署flannel

在node01节点上操作

cd /opt/k8s-cert
#上传 cni-plugins-linux-amd64-v0.8.6.tgz 和 flannel.tar 到 /opt 目录中
//一个为cni的各种执行文件，一个为docker镜像

docker load -i flannel.tar
#将镜像上传到容器本地中

mkdir  -p /opt/cni/bin
#创建一个存放cni插件的执行工作目录

tar zxvf cni-plugins-linux-amd64-v0.8.6.tgz -C /opt/cni/bin
#将有压缩包解压到cni的工作目录
1
2
3
4
5
6
7
8
9
10
11
12

在master01节点上操作

cd /opt/k8s/k8s-cert
#上传 kube-flannel.yml 文件到 /opt/k8s 目录中，部署 CNI 网络

kubectl apply -f kube-flannel.yml 
#基于yml文件创建pod。

kubectl get pods -n kube-system
#查看此pod是否正常运行(runing即可)

kubectl get nodes
#再次查看node节点的状态是否为就绪状态(ready即可)
------------------------------------------------------------
此步骤如果pod一直无法变成runing状态
可以使用 kubectl delete -f kube-flannel.yml  #删除然后重新创建，大部分原因是镜像问题，需要重新下
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、部署calico

在master01节点上操作

cd /opt/k8s/k8s-cert/
#上传 calico.yaml 文件到 /opt/k8s 目录中，部署 CNI 网络

vim calico.yaml
//修改里面定义 Pod 的网络（CALICO_IPV4POOL_CIDR），需与前面 kube-controller-manager 配置文件指定的 cluster-cidr 网段一样
    - name: CALICO_IPV4POOL_CIDR
      value: "10.244.0.0/16"      #(3878行)Calico 默认使用的网段为 192.168.0.0/16
      
kubectl apply -f calico.yaml
#基于calico.yml文件创建pod

kubectl get pods -n kube-system
#查看状态

kubectl get nodes
##等 Calico Pod 都 Running，节点也会准备就绪

--------------------------------------------------------------
此步骤如果pod一直无法变成runing状态
可以使用 kubectl delete -f calico.yml  #删除然后重新创建，大部分原因是镜像问题，需要重新下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3、node02节点部署

• 在 node01 节点上操作

cd /opt/k8s-cert/
scp kubelet.sh proxy.sh root@20.0.0.57:/opt/
#将node01上面的两个组件的安装脚本拷贝到node02上面进行安装组件

scp -r /opt/cni root@20.0.0.57:/opt/
#将node01的cni里面的插件拷贝到node02上面
1
2
3
4
5
6

• 在 node02节点上操作

cd /opt/
    
chmod +x kubelet.sh
./kubelet.sh 20.0.0.57
#执行kubelet.sh脚本，带入本机的IP地址，进行安装kubelet组件，这里也是相当于申请了CSR认证，需要在master01上进行认证。

systemctl status  kubelet
#查看kube组件是否启动
1
2
3
4
5
6
7
8

• 在master01节点上操作

kubectl get csr

kubectl certificate approve 【node-csr-BbqEh6LvhD4R6YdDUeEPthkb6T_CJDcpVsmdvnh81y0】
#通过请求(两台都要通过，前面node01的已经通过)

kubectl get csr
1
2
3
4
5
6

• 在node02 节点操作

for i in $(ls /usr/lib/modules/$(uname -r)/kernel/net/netfilter/ipvs|grep -o "^[^.]*");do echo $i; /sbin/modinfo -F filename $i >/dev/null 2>&1 && /sbin/modprobe $i;done
#使用for循环，加载 ipvs 模块

cd /opt
chmod +x proxy.sh

./proxy.sh 20.0.0.57
##使用proxy.sh脚本启动proxy服务，位置变量为本机IP地址。

systemctl status kube-proxy
#查看kube-proxy组件服务是否启动
1
2
3
4
5
6
7
8
9
10
11

• 在master节点操作

kubectl get nodes
#查看群集中的节点状态

kubectl get pods -n kube-system
#需要等里面的几个pod都启动起来，变成running(显示init可以稍微等下，或者PodInitializing，如果显示pullimage失败，可以安装上述办法重新创建)
1
2
3
4
5

八、部署core DNS

• 在所有node节点上操作

cd /opt/
#上传coredns.tar 到/opt目录上

docker load -i coredns.tar
#上传到docker中
1
2
3
4
5

• 在master01 节点上操作

cd /opt/k8s
#上传 coredns.yaml 文件到 /opt/k8s 目录中，部署 CoreDNS

kubectl apply -f coredns.yaml
#根据coredns.yml文件创建pod

kubectl get pods -n kube-system 
#再次查看创建的dns的pod是否运行成功

kubectl run -it --rm dns-test --image=busybox:1.28.4 sh
#运行一个容器，镜像为busybos：1.28.4，并且直接运行(网不好就多等会)，然后解析kubernetes成功即可
1
2
3
4
5
6
7
8
9
10
11

九、master02 节点部署

需要安装步骤一的系统初始化脚本，并且更名为master02

• 在master01上操作

scp -r /opt/etcd/ root@20.0.0.58:/opt/
#拷贝matser01上面的etcd证书到master02上面

scp -r /opt/kubernetes/ root@20.0.0.58:/opt
#拷贝master01上的整个kubernetes工作目录

scp -r /root/.kube root@20.0.0.58:/root
#拷贝运行master01上面的.kube运行文件kubect命令文件到master02上面

scp /usr/lib/systemd/system/{kube-apiserver,kube-controller-manager,kube-scheduler}.service root@20.0.0.58:/usr/lib/systemd/system/
#从 master01 节点上拷贝三大组件到master02上面
1
2
3
4
5
6
7
8
9
10
11

master02节点查看

master02节点修改

vim /opt/kubernetes/cfg/kube-apiserver

KUBE_APISERVER_OPTS="--logtostderr=true \
--v=4 \
--etcd-servers=https://20.0.0.55:2379,https://20.0.0.56:2379,https://20.0.0.57:2379 \
--bind-address=20.0.0.58 \				#修改
--secure-port=6443 \
--advertise-address=20.0.0.58 \			#修改
......

###修改apiserver组件指向的IP地址，修改监听地址为本即IP地址
1
2
3
4
5
6
7
8
9
10
11

systemctl start kube-apiserver.service
systemctl enable kube-apiserver.service
systemctl start kube-controller-manager.service
systemctl enable kube-controller-manager.service
systemctl start kube-scheduler.service
systemctl enable kube-scheduler.service
#在 master02 节点上启动各服务并设置开机自启

ln -s /opt/kubernetes/bin/* /usr/local/bin/


kubectl get nodes
kubectl get nodes -o wide			#-o=wide：输出额外信息；对于Pod，将输出Pod所在的Node名

##此时在master02节点查到的node节点状态仅是从etcd查询到的信息，而此时node节点实际上并未与master02节点建立通信连接，因此需要使用一个VIP把node节点与master节点都关联起来
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

至此，以上的两主两从，已安装完成，下面将配置负载均衡，通过nginx将负载均衡到两台master主机上。

十、负载均衡部署（lb01、lb02）

1、部署nginx服务、配置四层负载均衡

systemctl stop firewalld
systemctl disable firewalld
setenforce 0
#关闭防火墙

cat > /etc/yum.repos.d/nginx.repo << 'EOF'
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=0
EOF
#配置nginx的官方在线源，配置本地nginx的yum源

yum -y install nginx
#下载nginx

-----#修改nginx配置文件，配置四层反向代理负载均衡，指定k8s群集2台master的节点ip和6443端口-----
vim /etc/nginx/nginx.conf
events {
    worker_connections  1024;
}
#添加
stream {
    log_format  main  '$remote_addr $upstream_addr - [$time_local] $status $upstream_bytes_sent';
    
	access_log  /var/log/nginx/k8s-access.log  main;

    upstream k8s-apiserver {
        server 20.0.0.55:6443;
        server 20.0.0.58:6443;
    }
    server {
        listen 6443;
        proxy_pass k8s-apiserver;
    }
}

http {
......
---------------------------------------------------------------------
nginx -t
#检查语法

systemctl start nginx.service 
systemctl enable nginx.service
netstat -natp |grep nginx
#启动nginx服务，查看自己的监听6443端口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

2、部署keepalived服务

yum install keepalived -y
#下载keepalived服务

#修改配置文件
vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived

global_defs {
   # 接收邮件地址
   notification_email {
     acassen@firewall.loc
     failover@firewall.loc
     sysadmin@firewall.loc
   }
   # 邮件发送地址
   notification_email_from Alexandre.Cassen@firewall.loc
   smtp_server 127.0.0.1
   smtp_connect_timeout 30
   router_id NGINX_MASTER	#lb01节点的为 NGINX_MASTER，lb02节点的为 NGINX_BACKUP
}

#添加一个周期性执行的脚本
vrrp_script check_nginx {
    script "/etc/nginx/check_nginx.sh"	#指定检查nginx存活的脚本路径
}

vrrp_instance VI_1 {
    state MASTER			#lb01节点的为 MASTER，lb02节点的为 BACKUP
    interface ens33			#指定网卡名称 ens33
    virtual_router_id 51	#指定vrid，两个节点要一致
    priority 100			#lb01节点的为 100，lb02节点的为 90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        20.0.0.100/24	#指定 VIP
    }
    track_script {
        check_nginx			#指定vrrp_script配置的脚本
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

配置lb01的配置文件

配置lb02 的 keepailved文件

启动keepalived服务

#创建nginx状态检查脚本
vim /etc/nginx/check_nginx.sh
#!/bin/bash
#egrep -cv "grep|$$" 用于过滤掉包含grep 或者 $$ 表示的当前Shell进程ID，即脚本运行的当前进程ID号
count=$(ps -ef | grep nginx | egrep -cv "grep|$$")

if [ "$count" -eq 0 ];then
    systemctl stop keepalived
fi

chmod +x /etc/nginx/check_nginx.sh

systemctl start keepalived
systemctl enable keepalived
#启动keepalived服务（一定要先启动了nginx服务，再启动keepalived服务）
//这里使用ip a 查看VIP是否已生成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

lb01的启动

lb02的keepalived服务启动

修改node节点上的bootstrap.kubeconfig,kubelet.kubeconfig配置文件为VIP

cd /opt/kubernetes/cfg/
vim bootstrap.kubeconfig 
server: https://20.0.0.100：6443
                      
vim kubelet.kubeconfig
server: https://20.0.0.100:6443
                        
vim kube-proxy.kubeconfig
server: https://20.0.0.100:6443

systemctl restart kubelet.service 
systemctl restart kube-proxy.service
#重启kubelet和kube-proxy服务
1
2
3
4
5
6
7
8
9
10
11
12
13

在 lb01 上查看 nginx 和 node 、 master 节点的连接状态

netstat -natp |grep nginx
1

在master01节点操作

kubectl run nginx --image=nginx
#测试创建pod

kubectl get pods
#查看pod的状态信息
--------------------------------------
kubectl get pods
NAME                    READY   STATUS              RESTARTS   AGE
nginx-dbddb74b8-nf9sk   0/1     ContainerCreating   0          33s   #正在创建中

kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
nginx-dbddb74b8-nf9sk   1/1     Running   0          80s  			#创建完成，运行中
---------------------------------

kubectl get pods -o wide
#READY为1/1，表示这个Pod中有1个容器,-o wide 表示查看详细信息，主要是可以查看到IP地址
#显示的IP地址，就是为pod 的IP地址
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在任意node节点上执行验证操作

curl 10.244.33.197

#在对应网段的node节点上操作，可以直接使用浏览器或者curl命令访问
1
2
3

在master01节点上查看nginx日志

kubectl logs nginx
#后面的时候pod的名称，在前面可查看到
1
2

十一、部署Dashboard(master01)

Dashboard 介绍
仪表板是基于Web的Kubernetes用户界面。您可以使用仪表板将容器化应用程序部署到Kubernetes集群，对容器化应用程序进行故障排除，并管理集群本身及其伴随资源。您可以使用仪表板来概述群集上运行的应用程序，以及创建或修改单个Kubernetes资源（例如deployment，job，daemonset等）。例如，您可以使用部署向导扩展部署，启动滚动更新，重新启动Pod或部署新应用程序。仪表板还提供有关群集中Kubernetes资源状态以及可能发生的任何错误的信息。

上传文件并进行暴露端口

cd /opt/k8s/k8s-cert/
#上传 recommended.yaml 文件到 /opt/k8s 目录中

------------------------------------------------------------
vim recommended.yaml
#默认Dashboard只能集群内部访问，修改Service为NodePort类型，暴露到外部：
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001     #添加
  type: NodePort          #添加
  selector:
    k8s-app: kubernetes-dashboard
------------------------------------------------------------------

kubectl apply -f recommended.yaml
#基于yml文件创建pod

kubectl get pods -n kubernetes-dashboard
#查看是否创建成功
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

创建service account并绑定默认cluster-admin管理员集群角色

kubectl create serviceaccount dashboard-admin -n kube-system
#创建资源，并指定账号

kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
#

kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')
#查看信息
eyJhbGciOiJSUzI1NiIsImtpZCI6ImRyOUpLNnZNaUxfbHAySGpiV0xKdHlZaTJGU192V3VUX2RieXdqT1RRb2MifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJkYXNoYm9hcmQtYWRtaW4tdG9rZW4tOWNodjciLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoiZGFzaGJvYXJkLWFkbWluIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiZTE2ZWIwYzUtMDg2NC00MGIyLTg4MzAtZjAyODYxOTQxMTFiIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmRhc2hib2FyZC1hZG1pbiJ9.HV7CM-5NFqzz99250Pou_qXrpDdzNbA7kUmYnl3gdcXHSLeUpAQXbrEH_JEkS5LTwp62Q_QCZlrYkO_wKXIzUpQI9_3Th3zZUec76SWlIVXf6rqEh2VZj45jdYXVqpZzwhI-FJ6NQ5H5sIxOQlyP1wKqwtb8XNB6Oj2uQsWEHuJFnKfm7wzF5n8-4WKQ0RVHWPcrCkScgY_POYv1utK55kVgrPk2dFH97eUDOuOv7ZaqiYJqupOluRpoVAqeks0z0i4BZNoZL_nxvuRlN-KBvuTkeWrr5Fb3WyI-BUZNurYFuIDhM6vNjSHuDyTQL2LQbkK2DRPepBFbniZWjMiu-w


1
2
3
4
5
6
7
8
9
10
11

最后网页进行登录

https://NodeIP:30001

例子：https://20.0.0.56:30001
1
2
3