K8S 二进制部署

下载所需要的安装包：

#可能需要FQ，下载server就可以了，里边包含了所有需要的模块
wget https://dl.k8s.io/v1.12.7/kubernetes-server-linux-amd64.tar.gz

生成TLS证书

#使用openssl创建CA证书，部署kubernetes服务使用的所需证书如下

#根证书公钥与私钥 
ca.pem与ca.key

#API Server公钥与私钥 
apiserver.pem与apiserver.key

#集群管理员公钥与私钥 
admin.pem与admin.key

#节点proxy公钥与私钥 
proxy.pem与proxy.key

#节点kubelet的公钥与私钥：是通过boostrap响应的方式，在启动kubelet自动会产生, 然后在master通过csr请求，就会产生。

创建根证书

cd /usr/local/src/tls
#生成RSA私钥(无加密)
openssl genrsa -out ca.key 2048 
  
#生成 RSA 私钥和自签名证书
openssl req -x509 -new -nodes -key ca.key -days 10000 -out ca.pem -subj "/CN=kubernetes/O=k8s"

# 参数说明：
-new 指生成证书请求
-x509 表示直接输出证书
-key 指定私钥文件
-days 指定证书过期时间为10000天
-out 导出结束后证书文件
-subj 输入证书拥有者信息，这里指定 CN 以及 O 的值

# 重要的CN以及0关键参数：
-subj 设置CN以及0的值很重要，kubernetes会从证书这两个值对应获取相关的用户名以及用户租的值，如下：
"CN"：Common Name，kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)；浏览器使用该字段验证网站是否合法；
"O"：Organization，kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)；

apiserver证书生成

master中需要证书如下:
根证书公钥(root CA public key, ca.key)、根证书(ca.pem)；
apiserver证书：apiserver.pem与其私钥apiserver-key.pem

1.创建openssl.cnf
openssl示例:
[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name
[req_distinguished_name]
[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster.local
IP.1 = ${K8S_SERVICE_IP}
IP.2 = ${MASTER_IPV4}

[^_^]:
使用有API被访问的Master的IP地址替换${MASTER_IPV4}，说白了就是apiserver所在的地址，使用自己规划作为kubernetes service IP端的首IP替换${K8S_SERVICE_IP}如：一般以10.100.0.0/16作为service的服务IP端，则此处以10.100.0.1替换${K8S_SERVICE_IP}
如果在高可用配置中部署多个Master节点，需要添加更多的TLS subjectAltNames (SANs)。每个证书合适的SANs配置依赖于从节点与kubectl用户是怎样与Master节点通讯的：直接通过IP地址、通过负载均衡、或者通过解析DNS名称。
DNS.5 = ${MASTER_DNS_NAME}
IP.3 = ${MASTER_IP}
IP.4 = ${MASTER_LOADBALANCER_IP}
从节点将通过${MASTER_DNS_NAME}访问到Loadbalancer。

根据上面的示例创建openssl的cnf文件
vim openssl.cnf 

[req]
req_extensions = v3_req
distinguished_name = req_distinguished_name
[req_distinguished_name]
[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster
DNS.5 = kubernetes.default.svc.cluster.local
DNS.6 = k8s_master
IP.1 = 10.10.10.1              # ClusterServiceIP 地址
IP.2 = 172.16.1.168           # master IP地址
IP.3 = 10.10.11.1                # docker IP地址
IP.4 = 10.10.10.1           # kubernetes DNS IP地址

说明：ClusterServiceIP和kubernetes DNS IP地址 需要在同一个网段，除了masterIP是你查看的，其他IP是需要提前规划的

#生成apiserver 证书对
openssl genrsa -out apiserver.key 2048

openssl req -new -key apiserver.key -out apiserver.csr -subj "/CN=kubernetes/O=k8s" -config openssl.cnf

openssl x509 -req -in apiserver.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out apiserver.pem -days 3650 -extensions v3_req -extfile openssl.cnf

一般生成的根证书(ca.key, ca.pem)与apiserver证书(apiserver.key,apiserver.pem)放置在Master节点的/etc/kubernetes/kubernetesTLS/路径下（这个路径是可以自定义修改的，不一定要用我这个）

证书配置相关说明

apiserver的配置中需要指定如下参数
## Kubernetes的访问证书配置：
--token-auth-file=/etc/kubernetes/token.csv   
--tls-cert-file=/etc/kubernetes/kubernetesTLS/apiserver.pem 
--tls-private-key-file=/etc/kubernetes/kubernetesTLS/apiserver.key  
--client-ca-file=/etc/kubernetes/kubernetesTLS/ca.pem  
--service-account-key-file=/etc/kubernetes/kubernetesTLS/ca.key  

## Etcd的访问证书配置：
--storage-backend=etcd3  
--etcd-cafile=/etc/etcd/etcdSSL/ca.pem  
--etcd-certfile=/etc/etcd/etcdSSL/etcd.pem  
--etcd-keyfile=/etc/etcd/etcdSSL/etcd-key.pem  

controller-manager的配置中需要指定如下参数：
## Kubernetes的访问证书配置：
--cluster-name=kubernetes  
--cluster-signing-cert-file=/etc/kubernetes/kubernetesTLS/ca.pem  
--cluster-signing-key-file=/etc/kubernetes/kubernetesTLS/ca.key  
--service-account-private-key-file=/etc/kubernetes/kubernetesTLS/ca.key  
--root-ca-file=/etc/kubernetes/kubernetesTLS/ca.pem

admin集群管理员证书生成

## 此证书用于kubectl，设置方式如下：
openssl genrsa -out admin.key 2048
openssl req -new -key admin.key -out admin.csr -subj "/CN=admin/O=system:masters/OU=System"
openssl x509 -req -in admin.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out admin.pem -days 3650

说明：

由于后续 kube-apiserver 在启用RBAC模式之后， 客户端(如 kubelet、kube-proxy、Pod)请求进行授权的时候会需要认证用户名、以及用户组；
那么所谓的用户名和用户组从哪里来定义呢？
我们来看看上面openssl创建证书的语句：
openssl req -new -key admin.key -out admin.csr -subj "/CN=admin/O=system:masters/OU=System"
其中这里的/CN=admin/O=system:masters/OU=System就是在CN定义用户为admin，O定义用户组为system:masters，OU 指定该证书的 Group 为 system:masters。

那么定义好之后，在kubernetes中是怎么使用的呢？
kube-apiserver 预定义了一些 RBAC 使用的 RoleBindings（角色），如 cluster-admin （角色）将 Group（组） system:masters与 Role（角色） cluster-admin 绑定，该 Role 授予了调用kube-apiserver 的所有 API的权限；
那么当然的，我们创建admin的证书的时候，就要按照该上面的说明定义好证书的组、用户。

另外当kubelet使用该证书访问kube-apiserver是什么样的过程呢？
在证书的签名中，OU 指定该证书的 Group 为 system:masters，kubelet 使用该证书访问 kube-apiserver 时 ，由于证书被 CA 签名，所以认证通过，同时由于证书用户组为经过预授权的 system:masters，所以被授予访问所有 API 的权限；
同理，如果你是使用CFSSL来签名证书也需要这样去配置好用户和用户组。在这里就不单独写CFSSL签kubernetes的相关证书了。
重要的是要好好理解证书签名与kubernetes的RBAC角色绑定的关系。

节点proxy证书生成

openssl genrsa -out proxy.key 2048
openssl req -new -key proxy.key -out proxy.csr -subj "/CN=system:kube-proxy"
openssl x509 -req -in proxy.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out proxy.pem -days 3650

说明：
从上面解析说明admin的CN签名与kubernetes角色绑定的关系中，这里简单一眼就看出CN是拿来定义proxy的用户的。

CN 指定该证书的请求 User（用户） 为 system:kube-proxy；
在kubernetes的RABC默认角色绑定中，kube-apiserver 预定义的 RoleBinding cluster-admin将User system:kube-proxy 与 Role system:node-proxier 绑定，该 Role 授予了调用 kube-apiserver Proxy 相关 API 的权限；

将生成的ca证书拷贝至准备部署的指定目录

mkdir /etc/kubernetes/kubernetesTLS
cp admin.key admin.pem apiserver.key apiserver.pem ca.key ca.pem proxy.key proxy.pem /etc/kubernetes/kubernetesTLS/

ll /etc/kubernetes/kubernetesTLS/
-rw-r--r--. 1 root root 1675 6月  20 14:55 admin.key
-rw-r--r--. 1 root root 1050 6月  20 14:55 admin.pem
-rw-r--r--. 1 root root 1675 6月  20 14:55 apiserver.key
-rw-r--r--. 1 root root 1302 6月  20 14:55 apiserver.pem
-rw-r--r--. 1 root root 1679 6月  20 14:55 ca.key
-rw-r--r--. 1 root root 1135 6月  20 14:55 ca.pem
-rw-r--r--. 1 root root 1675 6月  20 14:56 proxy.key
-rw-r--r--. 1 root root 1009 6月  20 14:56 proxy.pem

以上就是部署master节点所需要的证书文件了

部署master

将master所需的二进制执行文件拷贝至/user/bin目录下
解压刚开始下载的server那个tar包
cp kube-apiserver kube-scheduler kube-controller-manager kubectl /usr/bin/

#API Server权限控制方式介绍

API Server权限控制分为三种：
Authentication（身份认证）、Authorization(授权)、AdmissionControl(准入控制)。
身份认证：
当客户端向Kubernetes非只读端口发起API请求时，Kubernetes通过三种方式来认证用户的合法性。kubernetes中，验证用户是否有权限操作api的方式有三种：证书认证，token认证，基本信息认证。

①　证书认证
设置apiserver的启动参数：--client_ca_file=SOMEFILE ，这个被引用的文件中包含的验证client的证书，如果被验证通过，那么这个验证记录中的主体对象将会作为请求的username。

②　Token认证（本次使用token认证的方式）

设置apiserver的启动参数：--token_auth_file=SOMEFILE。 token file的格式包含三列：token，username，userid。当使用token作为验证方式时，在对apiserver的http请求中，增加 一个Header字段：Authorization ，将它的值设置为：Bearer SOMETOKEN。

③　基本信息认证
设置apiserver的启动参数：--basic_auth_file=SOMEFILE，如果更改了文件中的密码，只有重新启动apiserver使 其重新生效。其文件的基本格式包含三列：password，username，userid。当使用此作为认证方式时，在对apiserver的http 请求中，增加一个Header字段：Authorization，将它的值设置为： Basic BASE64ENCODEDUSER:PASSWORD。

#创建 TLS Bootstrapping Token
Token auth file
Token可以是任意的包涵128 bit的字符串，可以使用安全的随机数发生器生成。

vim create_token.sh
#!/bin/bash
basedir=$(cd `dirname $0`;pwd)

## set param 
BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')

## function and implments
function save_BOOTSTRAP_TOKEN(){
cat > $configConfDir/BOOTSTRAP_TOKEN < $kubernetesDir/token.csv <

创建admin用户的集群参数

在前面使用openssl创建TLS证书的时候已经对证书的用户以及组签名至证书之中，那么下一步就是定义admin用户在集群中的参数了。
vim create_admin.sh
#!/bin/bash
kubernetesTLSDir=/etc/kubernetes/kubernetesTLS


## set param 
MASTER_IP='172.16.1.168'
KUBE_APISERVER="https://$MASTER_IP:6443"

# 设置集群参数
function config_cluster_param(){
  kubectl config set-cluster kubernetes \
    --certificate-authority=$kubernetesTLSDir/ca.pem \
    --embed-certs=true \
    --server=$KUBE_APISERVER
}

config_cluster_param

# 设置管理员认证参数
function config_admin_credentials(){
  kubectl config set-credentials admin \
    --client-certificate=$kubernetesTLSDir/admin.pem \
    --client-key=$kubernetesTLSDir/admin.key \
    --embed-certs=true
}

config_admin_credentials

# 设置管理员上下文参数
function config_admin_context(){
  kubectl config set-context kubernetes --cluster=kubernetes --user=admin
}

config_admin_context

# 设置集群默认上下文参数
function config_default_context(){
  kubectl config use-context kubernetes
}

config_default_context

值得注意的采用token认证的方式，kubernetes在后续是需要创建bootstrap.kubeconfig的文件的，那么我们需要将admin相关的TLS证书文件写入这个bootstrap.kubeconfig文件。
该如何将admin的TLS文件参数写入bootstrap.kubeconfig呢？

这时候就要借助这个--embed-certs 的参数了，当该参数为 true 时表示将 certificate-authority 证书写入到生成的 bootstrap.kubeconfig文件中。
在指定了参数之后，后续由 kube-apiserver 自动生成；

安装kube-apiserver

编写kube-apiserver.service（/usr/lib/systemd/system）
vim /usr/lib/systemd/system/kube-apiserver.service
[Unit]
Description=Kube-apiserver Service
Documentation=https://github.com/GoogleCloudPlatform/kubernetes

After=network.target
[Service]
Type=notify
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/apiserver
ExecStart=/usr/bin/kube-apiserver \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_ETCD_SERVERS \
        $KUBE_API_ADDRESS \
        $KUBE_API_PORT \
        $KUBELET_PORT \
        $KUBE_ALLOW_PRIV \
        $KUBE_SERVICE_ADDRESSES \
        $KUBE_ADMISSION_CONTROL \
        $KUBE_API_ARGS
Restart=always
LimitNOFILE=65536

[Install]
WantedBy=default.target

#设置config
vim /etc/kubernetes/config
###
# kubernetes system config
#
# The following values are used to configure various aspects of all
# kubernetes services, including
#
#   kube-apiserver.service
#   kube-controller-manager.service
#   kube-scheduler.service
#   kubelet.service
#   kube-proxy.service
# logging to stderr means we get it in the systemd journal
# 表示错误日志记录到文件还是输出到stderr。
KUBE_LOGTOSTDERR="--logtostderr=true"

# journal message level, 0 is debug
# 日志等级。设置0则是debug等级
KUBE_LOG_LEVEL="--v=0"

# Should this cluster be allowed to run privileged docker containers
# 允许运行特权容器。
KUBE_ALLOW_PRIV="--allow-privileged=true"

# How the controller-manager, scheduler, and proxy find the apiserver
# 设置master服务器的访问
KUBE_MASTER="--master=http://172.16.1.168:8080"

#设置apiserver
vim /etc/kubernetes/apiserver
###
## kubernetes system config
##
## The following values are used to configure the kube-apiserver
##
#
## The address on the local server to listen to.
KUBE_API_ADDRESS="--advertise-address=172.16.1.168 --bind-address=172.16.1.168 --insecure-bind-address=172.16.1.168"
#
## The port on the local server to listen on.
#KUBE_API_PORT="--port=8080"
#
## Port minions listen on
#KUBELET_PORT="--kubelet-port=10250"
#
## Comma separated list of nodes in the etcd cluster
KUBE_ETCD_SERVERS="--etcd-servers=https://172.16.1.168:2379"
#
## Address range to use for services
#services负载均衡的ip分配
#cat /root/openssl/openssl.cnf中第一个ip 就是该网段内
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.10.10.0/24"
#
## default admission control policies
KUBE_ADMISSION_CONTROL="--admission-control=ServiceAccount,NamespaceLifecycle,NamespaceExists,LimitRanger,ResourceQuota,NodeRestriction"

## Add your own!
KUBE_API_ARGS="--authorization-mode=Node,RBAC \
--kubelet-https=true  \
--token-auth-file=/etc/kubernetes/token.csv \
--service-node-port-range=30000-52767  \
--tls-cert-file=/etc/kubernetes/kubernetesTLS/apiserver.pem  \
--tls-private-key-file=/etc/kubernetes/kubernetesTLS/apiserver.key \
--client-ca-file=/etc/kubernetes/kubernetesTLS/ca.pem  \
--service-account-key-file=/etc/kubernetes/kubernetesTLS/ca.key  \
--etcd-cafile=/etc/etcd/etcdSSL/ca.pem  \
--etcd-certfile=/etc/etcd/etcdSSL/etcd.pem  \
--etcd-keyfile=/etc/etcd/etcdSSL/etcd-key.pem"

参数说明
--authorization-mode=Node,RBAC
启用Node RBAC插件


--runtime-config=rbac.authorization.k8s.io/v1beta1
运行的rabc配置文件


--kubelet-https=true
启用https


--token-auth-file=$kubernetesDir/token.csv
指定生成token文件


--service-node-port-range=30000-32767
设置node port端口号范围30000~32767


--tls-cert-file=$kubernetesTLSDir/apiserver.pem
指定apiserver的tls公钥证书


--tls-private-key-file=$kubernetesTLSDir/apiserver.key
指定apiserver的tls私钥证书


--client-ca-file=$kubernetesTLSDir/ca.pem
指定TLS证书的ca根证书公钥


--service-account-key-file=$kubernetesTLSDir/ca.key
指定apiserver的tls证书


--storage-backend=etcd3
指定etcd存储为version 3系列


--etcd-cafile=$etcdCaPem
指定etcd访问的ca根证书公钥


--etcd-certfile=$etcdPem
指定etcd访问的TLS证书公钥


--etcd-keyfile=$etcdKeyPem
指定etcd访问的TLS证书私钥


--enable-swagger-ui=true
启用 swagger-ui 功能，Kubernetes使用了swagger-ui提供API在线查询功能


--apiserver-count=3
设置集群中运行的API Sever数量，这种使用单个也没关系


--event-ttl=1h
API Server 对于各种审计时间保存1小时

#启动api
systemctl daemon-reload
systemctl enable kube-apiserver
systemctl start kube-apiserver
systemctl status kube-apiserver
#发现有报错Apr 27 02:07:34 k8s-master kube-apiserver[13217]: E0427 02:07:34.984980   13217 repair.go:171] the cluster IP 10.0.6.1 for service kubernetes/default is not within the service CIDR 10.244.6.0/24; please recreate

#解决方案
如果中途修改过--service-cluster-ip-range地址，则必须将default命名空间的kubernetes的service给删除，使用命令：kubectl delete service kubernetes，然后系统会自动用新的ip重建这个service，不然apiserver的log有报错the cluster IP x.x.x.x for service kubernetes/default is not within the service CIDR x.x.x.x/16; please recreate


kubectl delete service
systemctl restart kube-apiserver
systemctl status kube-apiserver
#查看没有报错了

安装kube-controller-manager

vim /usr/lib/systemd/system/kube-controller-manager.service
[Unit]
Description=Kube-controller-manager Service
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=network.target
After=kube-apiserver.service
Requires=kube-apiserver.service
[Service]
Type=simple
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/controller-manager
ExecStart=/usr/bin/kube-controller-manager \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_CONTROLLER_MANAGER_ARGS
Restart=always
LimitNOFILE=65536

[Install]
WantedBy=default.target

vim /etc/kubernetes/controller-manager           
###
# The following values are used to configure the kubernetes controller-manager

# defaults from config and apiserver should be adequate

# Add your own!
KUBE_CONTROLLER_MANAGER_ARGS="--master=http://172.16.1.168:8080  \
--address=127.0.0.1  \
--service-cluster-ip-range=10.10.10.0/24 \
--cluster-name=kubernetes  \
--cluster-signing-cert-file=/etc/kubernetes/kubernetesTLS/ca.pem  \
--cluster-signing-key-file=/etc/kubernetes/kubernetesTLS/ca.key  \
--service-account-private-key-file=/etc/kubernetes/kubernetesTLS/ca.key  \
--root-ca-file=/etc/kubernetes/kubernetesTLS/ca.pem  \
--leader-elect=true \
--experimental-cluster-signing-duration=87600h0m0s"
#证书有效期10年

#参数说明
master=http://172.16.5.81:8080
配置master访问地址

--address=127.0.0.1
配置监听本地IP地址，address 值必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器

--service-cluster-ip-range=10.0.6.0/24
设置kubernetes的service的网段

--cluster-name=kubernetes
设置集群的域名为kubernetes

--cluster-signing-cert-file=$kubernetesTLSDir/ca.pem
设置集群签署TLS的ca根证书公钥 。指定的证书和私钥文件用来签名为 TLS BootStrap 创建的证书和私钥；

--cluster-signing-key-file=$kubernetesTLSDir/ca.key
设置集群签署TLS的ca根证书私钥 ；指定的证书和私钥文件用来签名为 TLS BootStrap 创建的证书和私钥；

--service-account-private-key-file=$kubernetesTLSDir/ca.key
设置集群安全账号签署TLS的ca根证书私钥

--root-ca-file=$kubernetesTLSDir/ca.pem
设置集群root用户签署TLS的ca根证书公钥；用来对 kube-apiserver 证书进行校验，指定该参数后，才会在Pod 容器的 ServiceAccount 中放置该 CA 证书文件；

--leader-elect=true
设置启动选举，但是目前只启动一个，也没地方要选择，主要在于API Sever有多个的时候

--cluster-cidr=$podClusterIP
设置集群pod的IP网段


#启动controller-manager
systemctl daemon-reload
systemctl enable kube-controller-manager
systemctl start kube-controller-manager
systemctl status kube-controller-manager

安装kube-scheduler

vim /usr/lib/systemd/system/kube-scheduler.service
[Unit]
Description=Kube-scheduler Service
After=network.target

[Service]
Type=simple
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/scheduler
ExecStart=/usr/bin/kube-scheduler \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_SCHEDULER_ARGS

Restart=always
LimitNOFILE=65536

[Install]
WantedBy=default.target

vim /etc/kubernetes/scheduler
###
# The following values are used to configure the kubernetes scheduler

# defaults from config and scheduler should be adequate

# Add your own!
KUBE_SCHEDULER_ARGS="--master=http://172.16.1.168:8080 --leader-elect=true --address=127.0.0.1"

#参数说明
--master=http://172.16.5.81:8080
定义配置master的apiserver访问地址


--leader-elect=true
设置启动选举，但是目前只启动一个，也没地方要选择，主要在于API Sever有多个的时候


--address=127.0.0.1
配置监听本地IP地址，address 值必须为 127.0.0.1，因为当前 kube-apiserver 期望 scheduler 和 controller-manager 在同一台机器


#启动scheduler
systemctl daemon-reload
systemctl enable kube-scheduler
systemctl restart kube-scheduler
systemctl status kube-scheduler

查看集群健康

kubectl get cs

创建 kube-proxy kubeconfig 文件以及相关集群参数

cat create_kubeconfig_file.sh 
#!/bin/bash
basedir=$(cd `dirname $0`;pwd)
serviceDir=/usr/lib/systemd/system
binDir=/usr/bin

kubernetesDir=/etc/kubernetes
kubernetesTLSDir=/etc/kubernetes/kubernetesTLS

configdir=$basedir/configDir
configServiceDir=$configdir/service
configConfDir=$configdir/conf

## set param 
MASTER_IP='172.16.1.168'

BOOTSTRAP_TOKEN=7d4b6fad6efc458d77a11113fa625c88

#echo $BOOTSTRAP_TOKEN

## function and implments
# set proxy
function create_proxy_kubeconfig(){
  kubectl config set-cluster kubernetes \
   --certificate-authority=$kubernetesTLSDir/ca.pem \
   --embed-certs=true \
   --server=https://$MASTER_IP:6443 \
   --kubeconfig=$kubernetesDir/kube-proxy.kubeconfig
}

create_proxy_kubeconfig

function config_proxy_credentials(){
  kubectl config set-credentials kube-proxy \
   --client-certificate=$kubernetesTLSDir/proxy.pem \
   --client-key=$kubernetesTLSDir/proxy.key \
   --embed-certs=true \
   --kubeconfig=$kubernetesDir/kube-proxy.kubeconfig
}

config_proxy_credentials

function config_proxy_context(){
  kubectl config set-context default \
   --cluster=kubernetes \
   --user=kube-proxy \
   --kubeconfig=$kubernetesDir/kube-proxy.kubeconfig
}

config_proxy_context

function set_proxy_context(){
  kubectl config use-context default --kubeconfig=$kubernetesDir/kube-proxy.kubeconfig
}

set_proxy_context

## set bootstrapping
function create_kubelet_bootstrapping_kubeconfig(){
  kubectl config set-cluster kubernetes \
   --certificate-authority=$kubernetesTLSDir/ca.pem \
   --embed-certs=true \
   --server=https://$MASTER_IP:6443 \
   --kubeconfig=$kubernetesDir/bootstrap.kubeconfig
}

create_kubelet_bootstrapping_kubeconfig

function config_kubelet_bootstrapping_credentials(){
  kubectl config set-credentials kubelet-bootstrap \
   --token=$BOOTSTRAP_TOKEN \
   --kubeconfig=$kubernetesDir/bootstrap.kubeconfig
}

config_kubelet_bootstrapping_credentials

function config_kubernetes_bootstrap_kubeconfig(){
  kubectl config set-context default \
   --cluster=kubernetes \
   --user=kubelet-bootstrap \
   --kubeconfig=$kubernetesDir/bootstrap.kubeconfig
}

config_kubernetes_bootstrap_kubeconfig

function set_bootstrap_context(){
  kubectl config use-context default \
   --kubeconfig=$kubernetesDir/bootstrap.kubeconfig
}

set_bootstrap_context

## create rolebinding
function create_cluster_rolebinding(){
  kubectl create --insecure-skip-tls-verify clusterrolebinding kubelet-bootstrap \
   --clusterrole=system:node-bootstrapper \
   --user=kubelet-bootstrap
}

create_cluster_rolebinding

#查看生成的内容
cat /etc/kubernetes/kube-proxy.kubeconfig
cat /etc/kubernetes/bootstrap.kubeconfig

将所需文件拷贝到node节点上面

确认后续master需要拷贝到node的相关证书文件
因为node部署的时候，proxy和kubelet是需要拷贝上面生成的证书以及kubeconfig文件的，这里罗列如下：
[root@k8s-master ~]# tree /etc/kubernetes/
/etc/kubernetes/
├── apiserver
├── bootstrap.kubeconfig
├── config
├── controller-manager
├── kube-proxy.kubeconfig
├── kubernetesTLS
│   ├── admin.key
│   ├── admin.pem
│   ├── apiserver.key
│   ├── apiserver.pem
│   ├── ca.key
│   ├── ca.pem
│   ├── proxy.key
│   └── proxy.pem
├── scheduler
└── token.csv

部署Node节点服务(记得关闭防火墙、swap、selinux)

#拷贝Master节点创建的TLS以及kubeconfig文件至Node节点服务
scp -r -i /root/.ssh/all_Server_key /etc/kubernetes/ [email protected]:/etc/
scp -r -i /root/.ssh/all_Server_key /etc/kubernetes/ [email protected]:/etc/

#拷贝访问etcd集群的TLS证书文件至Node节点服务
 scp -r -i /root/.ssh/all_Server_key /etc/etcd/ [email protected]:/etc/
 scp -r -i /root/.ssh/all_Server_key /etc/etcd/ [email protected]:/etc/

因为每台Node都需要访问Etcd集群服务，在后面部署Calico或者flanneld网络的时候都是需要证书访问etcd集群的，该部分就会在后面的部署中说明了。
可是，如果新增一台服务器想要加入Node的话，这时候该台服务器就需要单独将证书拷贝至相应的文件目录了。

#拷贝二进制可执行文件至Node服务器（/usr/bin）
scp -i /root/.ssh/all_Server_key kubelet kubectl kube-proxy 172.16.1.166:/usr/bin/
scp -i /root/.ssh/all_Server_key kubelet kubectl kube-proxy 172.16.1.167:/usr/bin/

部署kubelet服务

vim /usr/lib/systemd/system/kubelet.service
[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service

[Service]
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/kubelet
ExecStart=/usr/bin/kubelet \
            $KUBE_LOGTOSTDERR \
            $KUBE_LOG_LEVEL \
            $KUBELET_CONFIG\
            $KUBELET_ADDRESS \
            $KUBELET_PORT \
            $KUBELET_HOSTNAME \
            $KUBELET_POD_INFRA_CONTAINER \
            $KUBELET_ARGS
Restart=on-failure

[Install]
WantedBy=multi-user.target

vim /etc/kubernetes/kubelet
###
## kubernetes kubelet (minion) config
#
## The address for the info server to serve on (set to 0.0.0.0 or "" for all interfaces)
#KUBELET_ADDRESS="--address=0.0.0.0"
#
## The port for the info server to serve on
#KUBELET_PORT="--port=10250"
#
## You may leave this blank to use the actual hostname
#这个ip改成node本机ip
KUBELET_HOSTNAME="--hostname-override=172.16.1.167"
#
## location of the api-server
KUBELET_CONFIG="--kubeconfig=/etc/kubernetes/kubelet.kubeconfig"
#
## pod infrastructure container
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=reg.kt007.com/library/pause-amd64:3.1"
#
## Add your own!
KUBELET_ARGS="--cluster-dns=10.10.10.2  \
--serialize-image-pulls=false  \
--bootstrap-kubeconfig=/etc/kubernetes/bootstrap.kubeconfig  \
--kubeconfig=/etc/kubernetes/kubelet.kubeconfig  \
--cert-dir=/etc/kubernetes/kubernetesTLS  \
--cluster-domain=cluster.local."

#参数说明
--cluster-dns=10.0.6.200
设置kubernetes集群网络中内部DNS的IP地址，后续用于CoreDNS

--serialize-image-pulls=false
设置kubernetes集群允许使用http非安全镜像拉取

--bootstrap-kubeconfig=/etc/kubernetes/bootstrap.kubeconfig
设置bootstrap.kubeconfig的文件路径

--cert-dir=/etc/kubernetes/kubernetesTLS
设置kubernetes的TLS文件路径，后续kubelet服务启动之后，会在该文件夹自动创建kubelet相关公钥和私钥文件

--cluster-domain=cluster.local.
设置kubernetes集群的DNS域名

--hairpin-mode promiscuous-bridge
设置pod桥接网络模式

--network-plugin=cni
设置启用CNI网络插件，因为后续是使用Calico网络，所以需要配置

#启动kubelet服务
systemctl daemon-reload
systemctl enable kubelet
systemctl start kubelet
systemctl status kubelet

部署kube-proxy服务

vim /usr/lib/systemd/system/kube-proxy.service
[Unit]
Description=Kube Proxy Service
After=network.target

[Service]
Type=simple
EnvironmentFile=-/etc/kubernetes/config
EnvironmentFile=-/etc/kubernetes/proxy
ExecStart=/usr/bin/kube-proxy \
        $KUBE_LOGTOSTDERR \
        $KUBE_LOG_LEVEL \
        $KUBE_MASTER \
        $KUBE_PROXY_ARGS

Restart=always
LimitNOFILE=65536

[Install]
WantedBy=default.target

vim /etc/kubernetes/proxy
###
# kubernetes proxy config

# defaults from config and proxy should be adequate

# Add your own!
KUBE_PROXY_ARGS="--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig"

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

#
ls -l /etc/kubernetes/kubernetesTLS/
可以从文件夹中看出，kubelet服务启动之后，自动响应生成了这三个文件：kubelet-client.key.tmp kubelet.crt kubelet.key。
如果需要重新部署kubelet服务，那么就需要删除这三个文件即可。不然会提示过期，服务启动异常。
另外，可以看到kubelet-client.key.tmp该文件还没有亮色，不可以运行起来，原因是kubelet向apiserver发出CSR认证的请求，此时apiserver还没有认证通过。
那么下一步就需要回到master服务认证csr。

转载于:https://www.cnblogs.com/yuhuLin/p/11058532.html