Kubernetes集群搭建(二进制方式)

注意：此文章是一篇关于单master节点集群搭建文章，如果需要了解多master节点集群的搭建，请转到：Kubernetes高可用集群搭建

1 安装要求

在开始安装之前，部署Kubernetes集群的机器需要满足以下条件：

• 一台或多台机器，操作系统CentOS7.x-x86_64
• 硬件配置：2G或更多ARM，2个CPU或更多CPU，硬盘20G及以上
• 集群中所有机器网络互通
• 可以访问外网，需要拉取镜像
• 禁止swap分区

2 环境准备

2.1 安装虚拟机

准备3台虚拟机，安装centos7.x操作系统。
CentOS-7.6.1810-x86_64下载:
https://pan.baidu.com/s/1-DgYThgkNbZ42QC5zKp84w 密码: mj9h

角色	IP
master	192.168.75.133
node1	192.168.75.134
node2	192.168.75.135

2.2 系统初始化

# 1、关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

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

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

# 4、根据规划设置主机名
hostnamectl set-hostname <主机名> #修改主机名
hostname #查看主机名

# 5、在master节点中添加hosts (IP后面跟的是hostname) 注：该命令只需要在master节点执行。
cat >> /etc/hosts << EOF
192.168.75.133 k8s-master
192.168.75.134 k8s-node1
192.168.75.135 k8s-node2
EOF

# 6、将桥接的IPv4流量传递到iptables的链
cat > /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge‐nf‐call‐ip6tables=1
net.bridge.bridge‐nf‐call‐iptables=1
EOF
sysctl --system #生效

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

3 为etcd和 apiserver自签证书

组件	使用的证书
etcd	ca.pem，server.pem，server-key.pem
kube-apiserver	ca.pem，server.pem，server-key.pem
kubelet	ca.pem，ca-key.pem
kube-proxy	ca.pem，kube-proxy.pem，kube-proxy-key.pem
kubectl	ca.pem，admin.pem，admin-key.pem

3.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

打包下载：
链接: https://pan.baidu.com/s/1aNwJRF1o9CQvmGClQKX8Pg 密码: iwh6

各个命令执行完成后，验证cfssl是否安装成功

cfssl version

3.2 生成初始证书

创建/u01/etcd文件夹，并在此文件夹下生成相关证书。

# 创建文件夹
mkdir -p /u01/etcd
# 进入文件夹
cd /u01/etcd

3.2.1 创建ca-csr.json文件

cat > ca-csr.json <<EOF
{
  "CN": "kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "Beijing",
      "ST": "Beijing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

3.2.2 通过cfssl初始化证书

cfssl gencert -initca ca-csr.json | cfssljson -bare ca -

3.3 为apiserver自签证书

3.3.1 创建ca-config.json文件

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

3.3.2 创建server-csr.json文件

此证书用户api、http加密使用。
注意修改hosts中的IP为自己集群的IP。其他的都不需要修改。

cat > server-csr.json <<EOF
{
  "CN": "kubernetes",
  "hosts": [
    "192.168.75.133",
    "192.168.75.134",
    "192.168.75.135"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "L": "Beijing",
      "ST": "Beijing",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

3.3.3 生成apiserver自签证书

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

3.4 生成admin证书

3.4.1 创建admin-csr.json文件

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

3.4.2 生成admin证书

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin

3.5 生成kube-proxy证书

3.5.1 创建kube-proxy-csr.json文件

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

3.5.2 生成kube-proxy证书

cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

4 部署etcd集群

为了便于管理，需要给etcd指定一个安装目录，此处指定安装目录为/opt/etcd，
并且在安装目录创建bin、cfg、ssl文件夹，分别用于存储二进制文件，配置文件，证书文件。

注意：复制ca.pem、server-key.pem、server.pem到/opt/etcd/ssl目录下。

# 创建文件夹命令
mkdir -p /opt/etcd/{bin,cfg,ssl}
#复制pem命令
cp /u01/etcd/ca.pem /opt/etcd/ssl
cp /u01/etcd/server.pem /opt/etcd/ssl
cp /u01/etcd/server-key.pem /opt/etcd/ssl

4.1 etcd安装包下载

下载地址：https://github.com/coreos/etcd/relxeases/tag/v3.2.12，可以根据实际需要下载各自的版本。

此博客的安装包版本下载：

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

下载完成并解压，将解压后的etcd和etcdctl文件移动到/opt/etcd/bin目录下。

4.2 创建etcd.conf文件

在/opt/etcd/cfg目录下创建etcd.conf文件。

cat > etcd.conf <<EOF
#[Member]
ETCD_NAME="etcd-1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://192.168.75.133:2380" 
ETCD_LISTEN_CLIENT_URLS="https://192.168.75.133:2379"

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

4.3 创建etcd.service文件

在/usr/lib/systemd/system目录下创建etcd.service文件

1.创建etcd.service文件
vi etcd.service
2.插入以下数据
[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=${ETCD_INITIAL_CLUSTER_STATE} \
--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
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

4.4 拷贝数据文件到其他节点

在k8s-master节点执行以下命令：

#拷贝etcd.service到192.168.75.134主机的/usr/lib/systemd/system目录下
scp -r /usr/lib/systemd/system/etcd.service root@192.168.75.134:/usr/lib/systemd/system
#拷贝etcd到192.168.75.134主机的/opt/目录下
scp -r /opt/etcd root@192.168.75.134:/opt/

#拷贝etcd.service到192.168.75.135主机的/usr/lib/systemd/system目录下
scp -r /usr/lib/systemd/system/etcd.service root@192.168.75.135:/usr/lib/systemd/system
#拷贝etcd到192.168.75.135主机的/opt/目录下
scp -r /opt/etcd root@192.168.75.135:/opt/

拷贝完成后，在其他节点上修改/opt/etcd/cfg/etcd.conf文件，主要修改的内容：
ETCD_NAME=etcd的名称
ETCD_LISTEN_PEER_URLS=“https://当前节点的IP:2380”
ETCD_LISTEN_CLIENT_URLS=“https://当前节点的IP:2379”
ETCD_INITIAL_ADVERTISE_PEER_URLS=“https://当前节点的IP:2380”
ETCD_ADVERTISE_CLIENT_URLS=“https://当前节点的IP:2379”

4.5 启动etcd

#重新加载配置文件
systemctl daemon-reload
#启动etcd
systemctl start etcd
#查看etcd状态
systemctl status etcd.service

设置开机启动：

#方式一：使用这个命令报错，不起作用，可以使用(方式二)来设置开机启动
systemctl enable etcd
#方式二
#1、修改/etc/rc.d/rc.local文件，在文件最后加入需要执行的命令：systemctl start etcd
#2、给/etc/rc.d/rc.local文件授予执行权限，完成后重启即可。
chmod +x /etc/rc.d/rc.local

查看集群状态：

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.75.133:2379,https://192.168.75.134:2379,https://192.168.75.135:2379" endpoint health

看到以下信息，则表示启动成功。

5 部署master组件

5.1 安装包下载

1、下载
v1.18.10版本：kubernetes-server-linux-amd64.tar.gz
其他版本下载：https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG
注意：只需要下载server包就行了，因为里面包含了k8s的所有组件。
下载完成后上传到k8s-master节点的/u01目录下，并解压。

#解压命令
tar -zxvf kubernetes-server-linux-amd64.tar.gz

2、在/opt/目录下创建 执行以下命令：

#创建目录命令
mkdir -p /opt/kubernetes/{bin,cfg,ssl,logs}

3、复制可执行文件到/opt/kubernetes/bin目录下，因为当前节点为master节点，只需要复制kubectl、kube-apiserver、kube-controller-manager、kube-scheduler即可。

#复制文件命令
cp /u01/kubernetes/server/bin/kubectl /opt/kubernetes/bin
cp /u01/kubernetes/server/bin/kube-apiserver /opt/kubernetes/bin
cp /u01/kubernetes/server/bin/kube-controller-manager /opt/kubernetes/bin
cp /u01/kubernetes/server/bin/kube-scheduler /opt/kubernetes/bin

4、复制ca-key.pem 、ca.pem、server-key.pem、server.pem到/opt/kubernetes/ssl目录下。

#复制pem命令
cp /u01/etcd/ca.pem /opt/kubernetes/ssl
cp /u01/etcd/ca-key.pem /opt/kubernetes/ssl
cp /u01/etcd/server.pem /opt/kubernetes/ssl
cp /u01/etcd/server-key.pem /opt/kubernetes/ssl

5.2 部署 kube-apiserver

在/opt/kubernetes/cfg文件夹中创建配置文件。

5.2.1 kube-apiserver.conf创建

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.75.133:2379,https://192.168.75.134:2379,https://192.168.75.135:2379 \\
 --bind-address=192.168.75.133 \\
 --secure-port=6443 \\
 --advertise-address=192.168.75.133 \\
 --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-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:审计日志

5.2.2 token.csv创建

cat > /opt/kubernetes/cfg/token.csv << EOF
c47ffb939f5ca36231d9e3121a252940,kubelet-bootstrap,10001,"system:node- bootstrapper"
EOF

格式:token，用户名，UID，用户组
token 也可自行生成替换:

# token生成命令
head -c 16 /dev/urandom | od -An -t x | tr -d ' '

5.2.3 systemd 管理 apiserver

在/usr/lib/systemd/system/目录下创建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.conf
ExecStart=/opt/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS 
Restart=on-failure
[Install]
WantedBy=multi-user.target 
EOF

5.2.4 启动并设置开机启动

# 加载配置文件
systemctl daemon-reload
# 启动kube-apiserver
systemctl start kube-apiserver
# 设置为开机启动
systemctl enable kube-apiserver
# 查看是否成功启动
ps -ef|grep apiserver

看到以下信息则表示成功启动：

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

为了方面使用，讲kubectl添加到/usr/local/bin目录下：

mv /opt/kubernetes/bin/kubectl /usr/local/bin

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

5.3 部署 kube-controller-manager

5.3.1 创建kube-controller-manager.conf配置文件

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 保持一致

5.3.2 systemd管理controller-manager

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

5.3.3 启动并设置开机启动

# 加载配置文件
systemctl daemon-reload
# 启动controller-manager
systemctl start kube-controller-manager
# 设置开机启动
systemctl enable kube-controller-manager

5.4 部署 kube-scheduler

5.4.1 创建kube-scheduler.conf文件

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

5.4.2 systemd管理scheduler

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

5.4.3 启动并设置开机启动

# 加载配置文件
systemctl daemon-reload
# 启动scheduler
systemctl start kube-scheduler
# 设置开机启动
systemctl enable kube-scheduler

5.5 查看集群状态

kubectl get cs

6 部署Worker Node

Worker Node节点需要安装Docker，Docker的安装移步：Docker for CentOS安装

6.1 在node节点上创建工作目录并拷贝二进制文件

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

拷贝kubelet、kube-proxy二进制文件到/opt/kubernetes/bin目录。由于之前在master节点的主机上面解压过我们的安装包，所有可以直接从master节点上拷贝过来，也可以自己在本地解压安装包，然后通过ftp工具上传也可以。
此处事例演示从master节点拷贝到node节点：

# 远程拷贝命令，在master节点执行
scp /u01/kubernetes/server/bin/kubelet root@192.168.75.134:/opt/kubernetes/bin
scp /u01/kubernetes/server/bin/kube-proxy root@192.168.75.134:/opt/kubernetes/bin

6.2 部署 kubelet

6.2.1 拷贝证书文件

复制ca.pem、 kube-proxy.pem、kube-proxy-key.pem证书文件到/opt/kubernetes/ssl文件夹。
之前我们的证书文件全部生成在master节点中的/u01/etcd目录中，此处只需要拷贝过来即可。

# 远程拷贝命令，在master节点上执行
scp /u01/etcd/ca.pem /u01/etcd/kube-proxy.pem /u01/etcd/kube-proxy-key.pem root@192.168.75.134:/opt/kubernetes/ssl

6.2.2 创建kubelet-config.yml文件

直接复制即可，不需要任何修改。

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

6.2.3 生成bootstrap.kubeconfig文件

此操作需要在maser节点的/opt/kubernetes/cfg目录下进行。

注意修改KUBE_APISERVER、TOKEN的信息。

1、创建可执行文件，并插入执行命令

vi generate.sh

执行命令：

# apiserver IP:PORT
KUBE_APISERVER="https://192.168.75.133:6443"
# 与token.csv里保持一致
TOKEN="c47ffb939f5ca36231d9e3121a252940"
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

2、授予执行权限并执行

# 授予执行执行权限
chmod +x generate.sh
# 执行
./generate.sh

执行完成后会在当前目录生成bootstrap.kubeconfig文件，最后拷贝到node节点上的/opt/kubernetes/cfg目录即可。

# 远程拷贝
scp bootstrap.kubeconfig root@192.168.75.134:/opt/kubernetes/cfg

6.2.4 创建kubelet.conf文件

注意修改`--hostname-override`的值，该值为当前主机名，在集群中需要保证唯一。

cat > /opt/kubernetes/cfg/kubelet.conf << EOF
KUBELET_OPTS="--logtostderr=false \\
--v=2 \\
--log-dir=/opt/kubernetes/logs \\
--hostname-override=k8s-node1 \\
--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 网络容器的镜像

6.2.5 创建kubelet.service文件

直接复制，无需修改。

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

6.2.6 启动kubelet

# 加载配置文件
systemctl daemon-reload
# 启动kubelet
systemctl start kubelet
# 查看启动状态
systemctl status kubelet
# 设置开机启动
systemctl enable kubelet

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

此操作在master节点执行。
1、查看kubelet 证书请求

kubectl get csr

2、批准申请

kubectl certificate approve node-csr-y2NCkLl8Hy-UX75Hn_haUGWKS39eQCMqS5C2TyVV2EI

3、查看节点，申请批准后需要等一段时间才能查询到节点信息

kubectl get nodes

注:由于网络插件还没有部署，节点呈现未就绪状态：NotReady

6.3 部署 kubelet-proxy

6.3.1 创建kube-proxy-config.yml文件

直接复制，无需更改。

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-node1
clusterCIDR: 10.0.0.0/24
EOF

6.3.2 生成生成 kube-proxy.kubeconfig文件

此操作需要在master节点的/opt/kubernetes/cfg目录下进行。
1、创建可执行文件，并插入执行命令

vi generate-proxy.sh

执行命令：

# apiserver IP:PORT，注意修改
KUBE_APISERVER="https://192.168.75.133: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=/u01/etcd/kube-proxy.pem \
--client-key=/u01/etcd/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

2、授予执行权限并执行

# 授予执行执行权限
chmod +x generate-proxy.sh
# 执行
./generate-proxy.sh

执行完成后会在当前目录生成kube-proxy.kubeconfig文件，最后拷贝到node节点上的/opt/kubernetes/cfg目录即可。

# 远程拷贝
scp kube-proxy.kubeconfig root@192.168.75.134:/opt/kubernetes/cfg

6.3.3 创建kube-proxy.conf文件

直接复制，无需更改。

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

6.3.4 创建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.conf
ExecStart=/opt/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
Restart=on-failure
LimitNOFILE=65536
[Install]
WantedBy=multi-user.target
EOF

6.3.5 启动kubelet

# 加载配置文件
systemctl daemon-reload
# 启动kube-proxy
systemctl start kube-proxy
# 查看启动状态
systemctl status kube-proxy
# 设置开机启动
systemctl enable kube-proxy

7 部署集群网络

7.1 Node 节点部署CNI

1、下载CNI安装包
下载地址：cni-plugins-linux-amd64-v0.8.6.tgz
如果这个地址下载不了就去百度云盘下载：
链接：https://pan.baidu.com/s/1mmuLHz1Lrdd5y9gHxKdrjg 提取码：vldm

2、创建/opt/cni/bin、/etc/cni/net.d文件夹

mkdir -p /opt/cni/bin /etc/cni/net.d

3、将cni-plugins-linux-amd64-v0.8.6.tgz解压到/opt/cni/bin文件夹中

7.2 Master节点部署CNI

方式一：

# 如果此地址无法访问，可以更改网络的DNS为8.8.8.8试试，如果还是不行就只能使用方式二
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

方式二：
kube-flannel.yml下载：
链接: https://pan.baidu.com/s/1ANoUdrexA6N_VVc5HOc3QA 密码: h11w

# 安装flannel
kubectl apply -f kube-flannel.yml

看到此消息这表示安装成功。

查看pod各个组件状态

# 查看pod组件状态
kubectl get pods -n kube-system
# 查看各节点状态
kubectl get node

8 集群测试

在Kubernetes集群中创建一个pod，验证是否正常运行。

# 创建镜像容器
kubectl create deployment nginx --image=nginx
# 对外暴露端口
kubectl expose deployment nginx --port=80 --type=NodePort
# 查看当前对外的端口
kubectl get pod,svc

通过浏览器访问nginx：http://节点IP:31730
如：http://192.168.75.130:31730