FedoraServer28全手动安装Kubernetes v1.10.x HA

2018-05-19 2058点热度 0人点赞 0条评论

用此方案安装失败，启动master节点的时候好多服务无法启动，不知道如何排查原因，放弃此方案

参考文章

Kubernetes v1.10.x HA 全手动安装教程

准备环境

操作环境：DSM916+8G，创建虚拟机，虚拟机配置1核1G内存200G硬盘
操作系统：FedoraServer28
全部使用root操作

节点信息

内网环境，全部使用192.168.2.x 网段IP

编辑/etc/hosts添加如下内容

192.168.2.186 k8s-m1
192.168.2.187 k8s-m2
192.168.2.188 k8s-m3
192.168.2.189 k8s-n1
192.168.2.190 k8s-n2
192.168.2.191 k8s-n3

关闭防火墙与SELinux

#systemctl stop firewalld && systemctl disable firewalld
#setenforce 0
#vi /etc/selinux/config
SELINUX=disabled

FedoraServer dnf配置

编辑/etc/resolv.conf文件，添加如下内容：

nameserver 180.76.76.76
这里使用百度的DNS。

然后修改/etc/dnf/dnf.conf文件，添加如下内容：
fastestmirror=true

然后执行dnf upgrade更新最新的内核版本和软件版本

docker版本

docker使用fedoraserver28默认的版本
设置开机启动docker并开启docker服务

systemctl enable docker && systemctl start docker

使用docker version命令查看docker版本

[root@k8s-m1 wangxianfeng]# docker version
Client:
 Version:         1.13.1
 API version:     1.26
 Package version: docker-1.13.1-51.git4032bd5.fc28.x86_64
 Go version:      go1.10
 Git commit:      c301b04-unsupported
 Built:           Wed Mar 28 13:53:29 2018
 OS/Arch:         linux/amd64

Server:
 Version:         1.13.1
 API version:     1.26 (minimum version 1.12)
 Package version: docker-1.13.1-51.git4032bd5.fc28.x86_64
 Go version:      go1.10
 Git commit:      c301b04-unsupported
 Built:           Wed Mar 28 13:53:29 2018
 OS/Arch:         linux/amd64
 Experimental:    false

所有节点需要设定/etc/sysctl.d/k8s.conf的系统参数

cat <<EOF > /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

sysctl -p /etc/sysctl.d/k8s.conf

关闭系统Swap

Kubernetes v1.8+ 要求关闭系统 Swap，若不关闭则需要修改 kubelet 设定参数，在所有节点利用以下指令关闭：

swapoff -a && sysctl -w vm.swappiness=0

记得/etc/fstab也要注解掉SWAP挂载,以下部分注释掉

#/dev/mapper/fedora-swap swap                    swap    defaults        0 0

所有节点下载Kubernetes

#export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.10.0/bin/linux/amd64"
#wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet
#chmod +x /usr/local/bin/kubelet
# node 忽略下载 kubectl 暂时未下载，等待虚拟机克隆完成之后再下载
#wget "${KUBE_URL}/kubectl" -O /usr/local/bin/kubectl
#chmod +x /usr/local/bin/kubectl

在所有节点下载 Kubernetes CNI 二进制文件

#mkdir -p /opt/cni/bin && cd /opt/cni/bin
#export CNI_URL="https://github.com/containernetworking/plugins/releases/download"
#wget -qO- --show-progress "${CNI_URL}/v0.7.1/cni-plugins-amd64-v0.7.1.tgz" | tar -zx

关闭第一个节点，克隆虚拟机

目前节点为k8s-m1，需要克隆出来5台虚拟机，克隆之前先拍摄快照，以便恢复。
分别需要修改如下内容
1. 主机名称,修改/etc/hostname
2. 主机IP，修改/etc/sysconfig/network-scripts/ifcfg-ens3中的IPADDR项

8G内存也不能支持6台1G的虚拟运行，内存全部改成768M了，这样才能同时运行。
全部启动起来之后，把上一步master节点的kubectl装上。
即执行如下几个命令：

export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.10.0/bin/linux/amd64"
wget "${KUBE_URL}/kubectl" -O /usr/local/bin/kubectl
chmod +x /usr/local/bin/kubectl

在k8s-m1需要安装CFSSL工具

这将会用来建立 TLS Certificates

export CFSSL_URL="https://pkg.cfssl.org/R1.2"
wget "${CFSSL_URL}/cfssl_linux-amd64" -O /usr/local/bin/cfssl
wget "${CFSSL_URL}/cfssljson_linux-amd64" -O /usr/local/bin/cfssljson
chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson

建立集群 CA keys 与 Certificates

在这个部分，将需要产生多个元件的 Certificates，这包含 Etcd、Kubernetes 元件等，并且每个集群都会有一个根数位凭证认证机构(Root Certificate Authority)被用在认证 API Server 与 Kubelet 端的凭证。
P.S. 这边要注意 CA JSON 档的CN(Common Name)与O(Organization)等内容是会影响 Kubernetes 元件认证的。

Etcd

首先在k8s-m1建立/etc/etcd/ssl资料夹，然后进入目录完成以下操作。

mkdir -p /etc/etcd/ssl && cd /etc/etcd/ssl
export PKI_URL="https://kairen.github.io/files/manual-v1.10/pki"

下载ca-config.json与etcd-ca-csr.json文件，并从 CSR json 产生 CA keys 与 Certificate：

wget "${PKI_URL}/ca-config.json" "${PKI_URL}/etcd-ca-csr.json"
cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare etcd-ca

下载etcd-csr.json文件，并产生 Etcd 证书：
-hostname需修改成所有 masters 节点IP。

wget "${PKI_URL}/etcd-csr.json"
cfssl gencert \
  -ca=etcd-ca.pem \
  -ca-key=etcd-ca-key.pem \
  -config=ca-config.json \
  -hostname=127.0.0.1,192.168.2.186,192.168.2.187,192.168.2.188 \
  -profile=kubernetes \
  etcd-csr.json | cfssljson -bare etcd

完成后删除不必要文件：

rm -rf *.json *.csr

确认/etc/etcd/ssl有以下文件：

ls /etc/etcd/ssl
etcd-ca-key.pem  etcd-ca.pem  etcd-key.pem  etcd.pem

复制相关文件至其他 Etcd 节点，这边为所有master节点，由于需要无密码ssh到其他主机，这里需要做以下操作：
1. 生成k8s-m1的key文件，在k8s-m1上执行如下操作

ssh-keygen -t rsa

用ssh-copy-id 把公钥复制到k8s-m2,k8s-m3上,复制的过程需要输入密码

ssh-copy-id -i  .ssh/id_rsa.pub root@k8s-m2
ssh-copy-id -i  .ssh/id_rsa.pub root@k8s-m3

使用如下命令测试是否能够无密码ssh到k8s-m2，k8s-m3,如果能够不需要密码就能ssh成功，说明配置成功

ssh root@k8s-m2
ssh root@k8s-m3

接下来复制/etc/etcd/ssl下的文件到其他master节点：

for NODE in k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  ssh ${NODE} "mkdir -p /etc/etcd/ssl"
  for FILE in etcd-ca-key.pem  etcd-ca.pem  etcd-key.pem  etcd.pem; do
    scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
  done
done

回显结果类似如下：

[root@k8s-m1 ~]# for NODE in k8s-m2 k8s-m3; do
>   echo "--- $NODE ---"
>   ssh ${NODE} "mkdir -p /etc/etcd/ssl"
>   for FILE in etcd-ca-key.pem  etcd-ca.pem  etcd-key.pem  etcd.pem; do
>     scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
>   done
> done
--- k8s-m2 ---
etcd-ca-key.pem   100% 1679   814.4KB/s   00:00    
etcd-ca.pem       100% 1359   646.7KB/s   00:00    
etcd-key.pem      100% 1675   721.9KB/s   00:00    
etcd.pem          100% 1444   207.9KB/s   00:00    
--- k8s-m3 ---
etcd-ca-key.pem   100% 1679   775.5KB/s   00:00    
etcd-ca.pem       100% 1359   673.8KB/s   00:00    
etcd-key.pem      100% 1675   877.4KB/s   00:00    
etcd.pem          100% 1444   689.8KB/s   00:00

Kubernetes

在k8s-m1建立pki资料夹，然后进入目录完成以下章节操作。

mkdir -p /etc/kubernetes/pki && cd /etc/kubernetes/pki
export PKI_URL="https://kairen.github.io/files/manual-v1.10/pki"
export KUBE_APISERVER="https://192.168.2.186:6443"

下载ca-config.json与ca-csr.json文件，并产生 CA 金钥：

wget "${PKI_URL}/ca-config.json" "${PKI_URL}/ca-csr.json"
cfssl gencert -initca ca-csr.json | cfssljson -bare ca
ls ca*.pem
ca-key.pem  ca.pem

API Server Certificate
下载apiserver-csr.json文件，并产生 kube-apiserver 凭证：

wget "${PKI_URL}/apiserver-csr.json"
cfssl gencert \
  -ca=ca.pem \
  -ca-key=ca-key.pem \
  -config=ca-config.json \
  -hostname=10.96.0.1,192.168.2.185,127.0.0.1,kubernetes.default \
  -profile=kubernetes \
  apiserver-csr.json | cfssljson -bare apiserver

ls apiserver*.pem
apiserver-key.pem  apiserver.pem

这边-hostname的10.96.0.1是 Cluster IP 的 Kubernetes 端点;
192.168.2.185为虚拟IP地址(VIP);注意不是master节点IP也不是node节点IP；
default为 Kubernetes DN。

Front Proxy Certificate

下载front-proxy-ca-csr.json文件，并产生 Front Proxy CA 金钥，Front Proxy 主要是用在 API aggregator 上:

wget "${PKI_URL}/front-proxy-ca-csr.json"
cfssl gencert \
  -initca front-proxy-ca-csr.json | cfssljson -bare front-proxy-ca
ls front-proxy-ca*.pem
front-proxy-ca-key.pem  front-proxy-ca.pem

下载front-proxy-client-csr.json文件，并产生 front-proxy-client 证书：

wget "${PKI_URL}/front-proxy-client-csr.json"
cfssl gencert \
  -ca=front-proxy-ca.pem \
  -ca-key=front-proxy-ca-key.pem \
  -config=ca-config.json \
  -profile=kubernetes \
  front-proxy-client-csr.json | cfssljson -bare front-proxy-client

ls front-proxy-client*.pem
front-proxy-client-key.pem  front-proxy-client.pem

Admin Certificate

下载admin-csr.json文件，并产生 admin certificate 凭证：

wget "${PKI_URL}/admin-csr.json"
cfssl gencert \
-ca=ca.pem \
-ca-key=ca-key.pem \
-config=ca-config.json \
-profile=kubernetes \
admin-csr.json | cfssljson -bare admin

ls admin*.pem
admin-key.pem  admin.pem

接着通过以下指令产生名称为 admin.conf 的 kubeconfig 档：

# admin set cluster
kubectl config set-cluster kubernetes \
  --certificate-authority=ca.pem \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=../admin.conf

# admin set credentials
kubectl config set-credentials kubernetes-admin \
  --client-certificate=admin.pem \
  --client-key=admin-key.pem \
  --embed-certs=true \
  --kubeconfig=../admin.conf

# admin set context
kubectl config set-context kubernetes-admin@kubernetes \
  --cluster=kubernetes \
  --user=kubernetes-admin \
  --kubeconfig=../admin.conf

# admin set default context
kubectl config use-context kubernetes-admin@kubernetes \
    --kubeconfig=../admin.conf

Controller Manager Certificate

下载manager-csr.json文件，并产生 kube-controller-manager certificate 凭证：

wget "${PKI_URL}/manager-csr.json"

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

ls controller-manager*.pem
controller-manager-key.pem  controller-manager.pem

若节点 IP 不同，需要修改manager-csr.json的hosts。这句没看懂，没看到需要修改hosts的地方。manager-csr.json的内容如下：

{
    "CN": "system:kube-controller-manager",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [{
        "C": "TW",
        "ST": "Taipei",
        "L": "Taipei",
        "O": "system:kube-controller-manager",
        "OU": "Kubernetes-manual"
    }]
}

接着通过以下指令产生名称为controller-manager.conf的 kubeconfig 档：

# controller-manager set cluster
kubectl config set-cluster kubernetes \
    --certificate-authority=ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=../controller-manager.conf

# controller-manager set credentials
kubectl config set-credentials system:kube-controller-manager \
    --client-certificate=controller-manager.pem \
    --client-key=controller-manager-key.pem \
    --embed-certs=true \
    --kubeconfig=../controller-manager.conf

# controller-manager set context
kubectl config set-context system:kube-controller-manager@kubernetes \
    --cluster=kubernetes \
    --user=system:kube-controller-manager \
    --kubeconfig=../controller-manager.conf

# controller-manager set default context
kubectl config use-context system:kube-controller-manager@kubernetes \
    --kubeconfig=../controller-manager.conf

Scheduler Certificate

下载scheduler-csr.json文件，并产生 kube-scheduler certificate 凭证：

wget "${PKI_URL}/scheduler-csr.json"

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

ls scheduler*.pem
scheduler-key.pem  scheduler.pem

若节点 IP 不同，需要修改scheduler-csr.json的hosts。同样，这里也没看懂，scheduler-csr.json内容如下：

{
    "CN": "system:kube-scheduler",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [{
        "C": "TW",
        "ST": "Taipei",
        "L": "Taipei",
        "O": "system:kube-scheduler",
        "OU": "Kubernetes-manual"
    }]
}

接着通过以下指令产生名称为 scheduler.conf 的 kubeconfig 档：

# scheduler set cluster
kubectl config set-cluster kubernetes \
    --certificate-authority=ca.pem \
    --embed-certs=true \
    --server=${KUBE_APISERVER} \
    --kubeconfig=../scheduler.conf

# scheduler set credentials
kubectl config set-credentials system:kube-scheduler \
    --client-certificate=scheduler.pem \
    --client-key=scheduler-key.pem \
    --embed-certs=true \
    --kubeconfig=../scheduler.conf

# scheduler set context
kubectl config set-context system:kube-scheduler@kubernetes \
    --cluster=kubernetes \
    --user=system:kube-scheduler \
    --kubeconfig=../scheduler.conf

# scheduler use default context
kubectl config use-context system:kube-scheduler@kubernetes \
    --kubeconfig=../scheduler.conf

Master Kubelet Certificate

接着在所有k8s-m1节点下载kubelet-csr.json文件，并产生凭证：

wget "${PKI_URL}/kubelet-csr.json"
for NODE in k8s-m1 k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  cp kubelet-csr.json kubelet-$NODE-csr.json;
  sed -i "s/\$NODE/$NODE/g" kubelet-$NODE-csr.json;
  cfssl gencert \
    -ca=ca.pem \
    -ca-key=ca-key.pem \
    -config=ca-config.json \
    -hostname=$NODE \
    -profile=kubernetes \
    kubelet-$NODE-csr.json | cfssljson -bare kubelet-$NODE
done

ls kubelet*.pem

kubelet-k8s-m1-key.pem  kubelet-k8s-m1.pem  kubelet-k8s-m2-key.pem  kubelet-k8s-m2.pem  kubelet-k8s-m3-key.pem  kubelet-k8s-m3.pem

这边需要依据节点修改-hostname与$NODE。kubelet-csr.json内容如下：

{
    "CN": "system:node:$NODE",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [{
        "C": "TW",
        "L": "Taipei",
        "ST": "Taipei",
        "O": "system:nodes",
        "OU": "Kubernetes-manual"
    }]
}

完成后复制 kubelet 凭证至其他master节点：

for NODE in k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  ssh ${NODE} "mkdir -p /etc/kubernetes/pki"
  for FILE in kubelet-$NODE-key.pem kubelet-$NODE.pem ca.pem; do
    scp /etc/kubernetes/pki/${FILE} ${NODE}:/etc/kubernetes/pki/${FILE}
  done
done

[root@k8s-m1 pki]# for NODE in k8s-m2 k8s-m3; do
>   echo "--- $NODE ---"
>   ssh ${NODE} "mkdir -p /etc/kubernetes/pki"
>   for FILE in kubelet-$NODE-key.pem kubelet-$NODE.pem ca.pem; do
>     scp /etc/kubernetes/pki/${FILE} ${NODE}:/etc/kubernetes/pki/${FILE}
>   done
> done
--- k8s-m2 ---
kubelet-k8s-m2-key.pem  100% 1679   381.7KB/s   00:00    
kubelet-k8s-m2.pem      100% 1476   720.9KB/s   00:00    
ca.pem                  100% 1403   591.3KB/s   00:00    
--- k8s-m3 ---
kubelet-k8s-m3-key.pem  100% 1679   842.5KB/s   00:00    
kubelet-k8s-m3.pem      100% 1476   482.2KB/s   00:00    
ca.pem                  100% 1403   638./s   00:00    
[root@k8s-m1 pki]#

接着执行以下指令产生名称为kubelet.conf的 kubeconfig 档：

for NODE in k8s-m1 k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  ssh ${NODE} "cd /etc/kubernetes/pki && \
    kubectl config set-cluster kubernetes \
      --certificate-authority=ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=../kubelet.conf && \
    kubectl config set-cluster kubernetes \
      --certificate-authority=ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=../kubelet.conf && \
    kubectl config set-credentials system:node:${NODE} \
      --client-certificate=kubelet-${NODE}.pem \
      --client-key=kubelet-${NODE}-key.pem \
      --embed-certs=true \
      --kubeconfig=../kubelet.conf && \
    kubectl config set-context system:node:${NODE}@kubernetes \
      --cluster=kubernetes \
      --user=system:node:${NODE} \
      --kubeconfig=../kubelet.conf && \
    kubectl config use-context system:node:${NODE}@kubernetes \
      --kubeconfig=../kubelet.conf && \
    rm kubelet-${NODE}.pem kubelet-${NODE}-key.pem"
done

Service Account Key

Service account 不是通过 CA 进行认证，因此不要通过 CA 来做 Service account key 的检查，这边建立一组 Private 与 Public 金钥提供给 Service account key 使用：

openssl genrsa -out sa.key 2048
openssl rsa -in sa.key -pubout -out sa.pub
ls sa.*
sa.key  sa.pub

删除不必要文件
所有信息准备完成后，就可以将一些不必要文件删除：

rm -rf *.json *.csr scheduler*.pem controller-manager*.pem admin*.pem kubelet*.pem

这里没有做删除，文件还是留着吧。
复制文件至其他节点
复制凭证文件至其他master节点：

for NODE in k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  for FILE in $(ls /etc/kubernetes/pki/); do
    scp /etc/kubernetes/pki/${FILE} ${NODE}:/etc/kubernetes/pki/${FILE}
  done
done

复制 Kubernetes config 文件至其他master节点：

for NODE in k8s-m2 k8s-m3; do
  echo "--- $NODE ---"
  for FILE in admin.conf controller-manager.conf scheduler.conf; do
    scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
  done
done

Kubernetes Masters

本部分将说明如何建立与设定 Kubernetes Master 角色，过程中会部署以下元件：
- kube-apiserver：提供 REST APIs，包含授权、认证与状态储存等。
- kube-controller-manager：负责维护集群的状态，如自动扩展，滚动更新等。
- kube-scheduler：负责资源排程，依据预定的排程策略将 Pod 分配到对应节点上。
- Etcd：储存集群所有状态的 Key/Value 储存系统。
- HAProxy：提供负载平衡器。
- Keepalived：提供虚拟网络地址(VIP)。

部署与设定

首先在所有 master 节点下载部署元件的 YAML 文件，这边不采用二进制执行档与 Systemd 来管理这些元件，全部采用 Static Pod 来达成。这边将文件下载至/etc/kubernetes/manifests目录：

export CORE_URL="https://kairen.github.io/files/manual-v1.10/master"
mkdir -p /etc/kubernetes/manifests && cd /etc/kubernetes/manifests

for FILE in kube-apiserver kube-controller-manager kube-scheduler haproxy keepalived etcd etcd.config; do
  wget "${CORE_URL}/${FILE}.yml.conf" -O ${FILE}.yml
  if [ ${FILE} == "etcd.config" ]; then
    mv etcd.config.yml /etc/etcd/etcd.config.yml
    sed -i "s/\${HOSTNAME}/${HOSTNAME}/g" /etc/etcd/etcd.config.yml
    sed -i "s/\${PUBLIC_IP}/$(hostname -i)/g" /etc/etcd/etcd.config.yml
  fi
done

ls /etc/kubernetes/manifests
etcd.yml  haproxy.yml  keepalived.yml  kube-apiserver.yml  kube-controller-manager.yml  kube-scheduler.yml

这里需要修改 YAML 文件里的IP地址信息。
kube-apiserver.yml需要修改的内容如下（其他文件没有发现需要修改的地方）：

--advertise-address=192.168.2.185
--etcd-servers=https://192.168.2.186:2379,https://192.168.2.187:2379,https://192.168.2.188:2379

修改/etc/etcd/etcd.config.yml文件，修改其中的如下内容：

initial-cluster: 'k8s-m1=https://192.168.2.186:2380,k8s-m2=https://192.168.2.187:2380,k8s-m3=https://192.168.2.188:2380'

kube-apiserver 中的NodeRestriction 请参考 Using Node Authorization。
修改/etc/kubernetes/manifests/keepalived.yml如下内容：

env:
    - name: VIRTUAL_IP
      value: 192.168.2.185
    - name: INTERFACE
      value: ens3

由于虚机的网卡名称全部是ens3，不是默认的eth1.

产生一个用来加密 Etcd 的 Key：

head -c 32 /dev/urandom | base64
ZMwOE1PmzPDekFZvypIfAuImI1tHI6oPYrsEkeG6M7M=

注意每台master节点需要用一样的 Key。

在/etc/kubernetes/目录下，建立encryption.yml的加密 YAML 文件：

cat <<EOF > /etc/kubernetes/encryption.yml
kind: EncryptionConfig
apiVersion: v1
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: ZMwOE1PmzPDekFZvypIfAuImI1tHI6oPYrsEkeG6M7M=
      - identity: {}
EOF

Etcd 资料加密可参考这篇 Encrypting data at rest。

在/etc/kubernetes/目录下，建立audit-policy.yml的进阶稽核策略 YAML 档：

cat <<EOF > /etc/kubernetes/audit-policy.yml
apiVersion: audit.k8s.io/v1beta1
kind: Policy
rules:
- level: Metadata
EOF

Audit Policy 请参考这篇 Auditing。

下载haproxy.cfg文件来提供给 HAProxy 容器使用：

mkdir -p /etc/haproxy/
wget "${CORE_URL}/haproxy.cfg" -O /etc/haproxy/haproxy.cfg

需要修改/etc/haproxy/haproxy.cfg的如下部分：

backend api-backend
    mode tcp
    server  api1  192.168.2.186:5443  check
    server  api2  192.168.2.187:5443  check
    server  api3  192.168.2.188:5443  check

下载kubelet.service相关文件来管理 kubelet：

mkdir -p /etc/systemd/system/kubelet.service.d
wget "${CORE_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service
wget "${CORE_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf

若 cluster dns或domain有改变的话，需要修改10-kubelet.conf。
最后建立 var 存放信息，然后启动 kubelet 服务:

mkdir -p /var/lib/kubelet /var/log/kubernetes /var/lib/etcd
systemctl enable kubelet.service && systemctl start kubelet.service

验证安装及排查问题

服务没有启动

完成后会需要一段时间来下载镜像档与启动元件，可以利用该指令来监看：

watch netstat -ntlp

运行以上命令，除了sshd服务，其他啥也没有，傻了，不知道如何下手。
使用 journalctl -f 跟踪日志，发现2018-05-21 11:08:36 星期一如下报错：

failed to run Kubelet: failed to create kubelet: misconfiguration: kubelet cgroup driver: "cgroupfs" is different from docker cgroup driver: "systemd"

看来还是因为没有使用最新版的社区办docker的原因，导致docker使用的文件驱动与kubelet不一致。这个是K8S v1.6.x的一个变化, 文件驱动默认由systemd改成cgroupfs, 而我们安装的docker使用的文件驱动是systemd, 造成不一致, 导致镜像无法启动。

# 查看docker的文件驱动
docker info
[root@k8s-m1 manifests]# docker info
Containers: 0
 Running: 0
 Paused: 0
 Stopped: 0
Images: 0
Server Version: 1.13.1
Storage Driver: overlay2
 Backing Filesystem: xfs
 Supports d_type: true
 Native Overlay Diff: true
Logging Driver: journald
Cgroup Driver: systemd

能想到的有2种：
1. 升级fedora默认的docker为最新的社区版docker
2. 修改kubelet的文件驱动为systemd
先试试第二种：
编辑/etc/systemd/system/kubelet.service.d/10-kubelet.conf文件,修改内容如下：

Environment="KUBELET_KUBECONFIG_ARGS=--kubeconfig=/etc/kubernetes/kubelet.conf"
修改为
Environment="KUBELET_KUBECONFIG_ARGS=--kubeconfig=/etc/kubernetes/kubelet.conf --cgroup-driver=systemd"

保存配置, 重启

systemctl daemon-reload
systemctl restart kubelet

上边方法感觉还是赶不上潮流，还是用第一种方式，把docker版本升级为最新社区版吧：fedora28升级docker为最新社区版方法。
当然还要把/etc/systemd/system/kubelet.service.d/10-kubelet.conf文件改回去。
安装完成之后查看docker版本信息如下：

docker version
Client:
 Version:      18.05.0-ce
 API version:  1.37
 Go version:   go1.9.5
 Git commit:   f150324
 Built:        Wed May  9 22:16:04 2018
 OS/Arch:      linux/amd64
 Experimental: false
 Orchestrator: swarm

Server:
 Engine:
  Version:      18.05.0-ce
  API version:  1.37 (minimum version 1.12)
  Go version:   go1.9.5
  Git commit:   f150324
  Built:        Wed May  9 22:19:55 2018
  OS/Arch:      linux/amd64
  Experimental: false

然后重启kubelet服务

systemctl daemon-reload
systemctl restart kubelet

本作品采用知识共享署名 4.0 国际许可协议进行许可