Kubernetes v1.10.x HA 全手动安装教程(TL;DR)-阿里云开发者社区

本篇延续过往手动安装方式来部署 Kubernetes v1.10.x 版本的 High Availability 集群，主要目的是学习 Kubernetes 安装的一些元件关析与流程。若不想这么累的话，可以参考 Picking the Right Solution 来选择自己最喜欢的方式。

本次安装的软件版本：

Kubernetes v1.10.0
CNI v0.6.0
Etcd v3.1.13
Calico v3.0.4
Docker CE latest version

节点信息

本教学将以下列节点数与规格来进行部署 Kubernetes 集群，操作系统可采用Ubuntu 16.x与CentOS 7.x：

IP Address	Hostname	CPU	Memory
192.16.35.11	k8s-m1	1	4G
192.16.35.12	k8s-m2	1	4G
192.16.35.13	k8s-m3	1	4G
192.16.35.14	k8s-n1	1	4G
192.16.35.15	k8s-n2	1	4G
192.16.35.16	k8s-n2	1	4G

另外由所有 master 节点提供一组 VIP 192.16.35.10。

这边m为主要控制节点，n为应用程序工作节点。
所有操作全部用root使用者进行(方便用)，以 SRE 来说不推荐。
可以下载Vagrantfile 来建立 Virtualbox 虚拟机集群。不过需要注意机器资源是否足够。

事前准备

开始安装前需要确保以下条件已达成：

所有节点彼此网络互通，并且k8s-m1SSH 登入其他节点为 passwdless。
所有防火墙与 SELinux 已关闭。如 CentOS：

$ systemctl stop firewalld && systemctl disable firewalld
$ setenforce 0
$ vim /etc/selinux/config
SELINUX=disabled

所有节点需要设定/etc/hosts解析到所有集群主机。

... 192.16.35.11 k8s-m1
192.16.35.12 k8s-m2
192.16.35.13 k8s-m3
192.16.35.14 k8s-n1
192.16.35.15 k8s-n2
192.16.35.16 k8s-n3

所有节点需要安装 Docker CE 版本的容器引擎：

$ curl -fsSL "https://get.docker.com/" | sh

不管是在 Ubuntu 或 CentOS 都只需要执行该指令就会自动安装最新版 Docker。
CentOS 安装完成后，需要再执行以下指令：

$ systemctl enable docker && systemctl start docker

所有节点需要设定/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

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

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

记得/etc/fstab也要注解掉SWAP挂载。

在所有节点下载 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.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx

在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 证书：

$ 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.16.35.11,192.16.35.12,192.16.35.13 \

 -profile=kubernetes \

 etcd-csr.json | cfssljson -bare etcd

-hostname需修改成所有 masters 节点。

完成后删除不必要文件：

$ 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节点：

$ 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

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.16.35.10: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.16.35.10,127.0.0.1,kubernetes.default \

 -profile=kubernetes \

 apiserver-csr.json | cfssljson -bare apiserver



$ ls apiserver*.pem

apiserver-key.pem apiserver.pem

这边-hostname的96.0.1是 Cluster IP 的 Kubernetes 端点;
16.35.10为虚拟 IP 位址(VIP);
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。

接着通过以下指令产生名称为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.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 凭证至其他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

接着执行以下指令产生名称为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

若IP与教学设定不同的话，请记得修改 YAML 文件。
kube-apiserver 中的NodeRestriction 请参考 Using Node Authorization。

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

$ head -c 32 /dev/urandom | base64SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ=

注意每台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: SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ= - 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

若与本教学 IP 不同的话，请记得修改设定档。

下载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 -ntlpActive Internet connections (only servers)Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name

tcp 0 0 127.0.0.1:10248 0.0.0.0:* LISTEN 10344/kubelet

tcp 0 0 127.0.0.1:10251 0.0.0.0:* LISTEN 11324/kube-schedule

tcp 0 0 0.0.0.0:6443 0.0.0.0:* LISTEN 11416/haproxy

tcp 0 0 127.0.0.1:10252 0.0.0.0:* LISTEN 11235/kube-controll

tcp 0 0 0.0.0.0:9090 0.0.0.0:* LISTEN 11416/haproxy

tcp6 0 0 :::2379 :::* LISTEN 10479/etcd

tcp6 0 0 :::2380 :::* LISTEN 10479/etcd

tcp6 0 0 :::10255 :::* LISTEN 10344/kubelet

tcp6 0 0 :::5443 :::* LISTEN 11295/kube-apiserve

若看到以上信息表示服务正常启动，若发生问题可以用docker指令来查看。

验证集群

完成后，在任意一台master节点复制 admin kubeconfig 文件，并通过简单指令验证：

$ cp /etc/kubernetes/admin.conf ~/.kube/config

$ kubectl get cs

NAME STATUS MESSAGE ERROR

controller-manager Healthy ok

scheduler Healthy ok

etcd-2 Healthy {"health": "true"}

etcd-1 Healthy {"health": "true"}

etcd-0 Healthy {"health": "true"}



$ kubectl get node

NAME STATUS ROLES AGE VERSION

k8s-m1 NotReady master 52s v1.10.0

k8s-m2 NotReady master 51s v1.10.0

k8s-m3 NotReady master 50s v1.10.0



$ kubectl -n kube-system get po

NAME READY STATUS RESTARTS AGE

etcd-k8s-m1 1/1 Running 0 7s

etcd-k8s-m2 1/1 Running 0 57s

haproxy-k8s-m3 1/1 Running 0 1m...

接着确认服务能够执行 logs 等指令：

$ kubectl -n kube-system logs -f kube-scheduler-k8s-m2Error from server (Forbidden): Forbidden (user=kube-apiserver, verb=get, resource=nodes, subresource=proxy) ( pods/log kube-scheduler-k8s-m2)

这边会发现出现 403 Forbidden 问题，这是因为 kube-apiserver user 并没有 nodes 的资源存取权限，属于正常。

由于上述权限问题，必需建立一个apiserver-to-kubelet-rbac.yml来定义权限，以供对 Nodes 容器执行 logs、exec 等指令。在任意一台master节点执行以下指令：

$ kubectl apply -f "${CORE_URL}/apiserver-to-kubelet-rbac.yml.conf"

clusterrole.rbac.authorization.k8s.io "system:kube-apiserver-to-kubelet" configured

clusterrolebinding.rbac.authorization.k8s.io "system:kube-apiserver" configured

# 测试 logs

$ kubectl -n kube-system logs -f kube-scheduler-k8s-m2...

I0403 02:30:36.375935 1 server.go:555] Version: v1.10.0

I0403 02:30:36.378208 1 server.go:574] starting healthz server on 127.0.0.1:10251 设定master节点允许 Taint：

$ kubectl taint nodes node-role.kubernetes.io/master="":NoSchedule --all

node "k8s-m1" tainted

node "k8s-m2" tainted

node "k8s-m3" tainted

Taints and Tolerations。

建立 TLS Bootstrapping RBAC 与 Secret

由于本次安装启用了 TLS 认证，因此每个节点的 kubelet 都必须使用 kube-apiserver 的 CA 的凭证后，才能与 kube-apiserver 进行沟通，而该过程需要手动针对每台节点单独签署凭证是一件繁琐的事情，且一旦节点增加会延伸出管理不易问题; 而 TLS bootstrapping 目标就是解决该问题，通过让 kubelet 先使用一个预定低权限使用者连接到 kube-apiserver，然后在对 kube-apiserver 申请凭证签署，当授权 Token 一致时，Node 节点的 kubelet 凭证将由 kube-apiserver 动态签署提供。具体作法可以参考 TLS Bootstrapping 与 Authenticating with Bootstrap Tokens。

首先在k8s-m1建立一个变量来产生BOOTSTRAP_TOKEN，并建立bootstrap-kubelet.conf的 Kubernetes config 档：

$ cd /etc/kubernetes/pki

$ export TOKEN_ID=$(openssl rand 3 -hex)

$ export TOKEN_SECRET=$(openssl rand 8 -hex)

$ export BOOTSTRAP_TOKEN=${TOKEN_ID}.${TOKEN_SECRET}

$ export KUBE_APISERVER="https://192.16.35.10:6443" # bootstrap set cluster

$ kubectl config set-cluster kubernetes \

 --certificate-authority=ca.pem \

 --embed-certs=true \

 --server=${KUBE_APISERVER} \

 --kubeconfig=../bootstrap-kubelet.conf

# bootstrap set credentials

$ kubectl config set-credentials tls-bootstrap-token-user \

 --token=${BOOTSTRAP_TOKEN} \

 --kubeconfig=../bootstrap-kubelet.conf

# bootstrap set context

$ kubectl config set-context tls-bootstrap-token-user@kubernetes \

 --cluster=kubernetes \

 --user=tls-bootstrap-token-user \

 --kubeconfig=../bootstrap-kubelet.conf

# bootstrap use default context

$ kubectl config use-context tls-bootstrap-token-user@kubernetes \

 --kubeconfig=../bootstrap-kubelet.conf

若想要用手动签署凭证来进行授权的话，可以参考 Certificate。

接着在k8s-m1建立 TLS bootstrap secret 来提供自动签证使用：

$ cat <<EOF | kubectl create -f -

apiVersion: v1

kind: Secret

metadata:

 name: bootstrap-token-${TOKEN_ID} namespace: kube-system

type: bootstrap.kubernetes.io/token

stringData:

 token-id: ${TOKEN_ID}

 token-secret: ${TOKEN_SECRET}

 usage-bootstrap-authentication: "true"

 usage-bootstrap-signing: "true"

 auth-extra-groups: system:bootstrappers:default-node-token

EOF



secret "bootstrap-token-65a3a9" created

在k8s-m1建立 TLS Bootstrap Autoapprove RBAC：

$ kubectl apply -f "${CORE_URL}/kubelet-bootstrap-rbac.yml.conf"

clusterrolebinding.rbac.authorization.k8s.io "kubelet-bootstrap" created

clusterrolebinding.rbac.authorization.k8s.io "node-autoapprove-bootstrap" created

clusterrolebinding.rbac.authorization.k8s.io "node-autoapprove-certificate-rotation" created

Kubernetes Nodes

本部分将说明如何建立与设定 Kubernetes Node 角色，Node 是主要执行容器实例(Pod)的工作节点。

在开始部署前，先在k8-m1将需要用到的文件复制到所有node节点上：

$ cd /etc/kubernetes/pki

$ for NODE in k8s-n1 k8s-n2 k8s-n3; do

 echo "--- $NODE ---"

 ssh ${NODE} "mkdir -p /etc/kubernetes/pki/"

 ssh ${NODE} "mkdir -p /etc/etcd/ssl" # Etcd for FILE in etcd-ca.pem etcd.pem etcd-key.pem; do

 scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE} done # Kubernetes for FILE in pki/ca.pem pki/ca-key.pem bootstrap-kubelet.conf; do

 scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE} done done

部署与设定

在每台node节点下载kubelet.service相关文件来管理 kubelet：

$ export CORE_URL="https://kairen.github.io/files/manual-v1.10/node"

$ 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

$ systemctl enable kubelet.service && systemctl start kubelet.service

验证集群

完成后，在任意一台master节点并通过简单指令验证：

$ kubectl get csr

NAME AGE REQUESTOR CONDITION

csr-bvz9l 11m system:node:k8s-m1 Approved,Issued

csr-jwr8k 11m system:node:k8s-m2 Approved,Issued

csr-q867w 11m system:node:k8s-m3 Approved,Issued

node-csr-Y-FGvxZWJqI-8RIK_IrpgdsvjGQVGW0E4UJOuaU8ogk 17s system:bootstrap:dca3e1 Approved,Issued

node-csr-cnX9T1xp1LdxVDc9QW43W0pYkhEigjwgceRshKuI82c 19s system:bootstrap:dca3e1 Approved,Issued

node-csr-m7SBA9RAGCnsgYWJB-u2HoB2qLSfiQZeAxWFI2WYN7Y 18s system:bootstrap:dca3e1 Approved,Issued



$ kubectl get nodes

NAME STATUS ROLES AGE VERSION

k8s-m1 NotReady master 12m v1.10.0

k8s-m2 NotReady master 11m v1.10.0

k8s-m3 NotReady master 11m v1.10.0

k8s-n1 NotReady node 32s v1.10.0

k8s-n2 NotReady node 31s v1.10.0

k8s-n3 NotReady node 29s v1.10.0

Kubernetes Core Addons 部署

当完成上面所有步骤后，接着需要部署一些插件，其中如Kubernetes DNS与Kubernetes Proxy等这种 Addons 是非常重要的。

Kubernetes Proxy

Kube-proxy 是实现 Service 的关键插件，kube-proxy 会在每台节点上执行，然后监听 API Server 的 Service 与 Endpoint 资源物件的改变，然后来依据变化执行 iptables 来实现网络的转发。这边我们会需要建议一个 DaemonSet 来执行，并且建立一些需要的 Certificates。

在k8s-m1下载kube-proxy.yml来建立 Kubernetes Proxy Addon：

$ kubectl apply -f "https://kairen.github.io/files/manual-v1.10/addon/kube-proxy.yml.conf"

serviceaccount "kube-proxy" created

clusterrolebinding.rbac.authorization.k8s.io "system:kube-proxy" created

configmap "kube-proxy" created

daemonset.apps "kube-proxy" created



$ kubectl -n kube-system get po -o wide -l k8s-app=kube-proxy

NAME READY STATUS RESTARTS AGE IP NODE

kube-proxy-8j5w8 1/1 Running 0 29s 192.16.35.16 k8s-n3

kube-proxy-c4zvt 1/1 Running 0 29s 192.16.35.11 k8s-m1

kube-proxy-clpl6 1/1 Running 0 29s 192.16.35.12 k8s-m2...

Kubernetes DNS

Kube DNS 是 Kubernetes 集群内部 Pod 之间互相沟通的重要 Addon，它允许 Pod 可以通过 Domain Name 方式来连接 Service，其主要由 Kube DNS 与 Sky DNS 组合而成，通过 Kube DNS 监听 Service 与 Endpoint 变化，来提供给 Sky DNS 信息，已更新解析位址。

在k8s-m1下载kube-proxy.yml来建立 Kubernetes Proxy Addon：

$ kubectl apply -f "https://kairen.github.io/files/manual-v1.10/addon/kube-dns.yml.conf"

serviceaccount "kube-dns" created

service "kube-dns" created

deployment.extensions "kube-dns" created



$ kubectl -n kube-system get po -l k8s-app=kube-dns

NAME READY STATUS RESTARTS AGE

kube-dns-654684d656-zq5t8 0/3 Pending 0 1m

这边会发现处于Pending状态，是由于 Kubernetes Pod Network 还未建立完成，因此所有节点会处于NotReady状态，而造成 Pod 无法被排程分配到指定节点上启动，由于为了解决该问题，下节将说明如何建立 Pod Network。

Calico Network 安装与设定

Calico 是一款纯 Layer 3 的资料中心网络方案(不需要 Overlay 网络)，Calico 好处是它整合了各种云原生平台，且 Calico 在每一个节点利用 Linux Kernel 实现高效的 vRouter 来负责资料的转发，而当资料中心复杂度增加时，可以用 BGP route reflector 来达成。

本次不采用手动方式来建立 Calico 网络，若想了解可以参考 Integration Guide。

在k8s-m1下载calico.yaml来建立 Calico Network：

$ kubectl apply -f "https://kairen.github.io/files/manual-v1.10/network/calico.yml.conf"

configmap "calico-config" created

daemonset "calico-node" created

deployment "calico-kube-controllers" created

clusterrolebinding "calico-cni-plugin" created

clusterrole "calico-cni-plugin" created

serviceaccount "calico-cni-plugin" created

clusterrolebinding "calico-kube-controllers" created

clusterrole "calico-kube-controllers" created

serviceaccount "calico-kube-controllers" created



$ kubectl -n kube-system get po -l k8s-app=calico-node -o wide

NAME READY STATUS RESTARTS AGE IP NODE

calico-node-22mbb 2/2 Running 0 1m 192.16.35.12 k8s-m2

calico-node-2qwf5 2/2 Running 0 1m 192.16.35.11 k8s-m1

calico-node-g2sp8 2/2 Running 0 1m 192.16.35.13 k8s-m3

calico-node-hghp4 2/2 Running 0 1m 192.16.35.14 k8s-n1

calico-node-qp6gf 2/2 Running 0 1m 192.16.35.15 k8s-n2

calico-node-zfx4n 2/2 Running 0 1m 192.16.35.16 k8s-n3

这边若节点 IP 与网卡不同的话，请修改calico.yml文件。

在k8s-m1下载 Calico CLI 来查看 Calico nodes:

$ wget https://github.com/projectcalico/calicoctl/releases/download/v3.1.0/calicoctl -O /usr/local/bin/calicoctl

$ chmod u+x /usr/local/bin/calicoctl

$ cat <<EOF > ~/calico-rcexport ETCD_ENDPOINTS="https://192.16.35.11:2379,https://192.16.35.12:2379,https://192.16.35.13:2379"export ETCD_CA_CERT_FILE="/etc/etcd/ssl/etcd-ca.pem"export ETCD_CERT_FILE="/etc/etcd/ssl/etcd.pem"export ETCD_KEY_FILE="/etc/etcd/ssl/etcd-key.pem"

EOF



$ . ~/calico-rc

$ calicoctl node statusCalico process is running.

IPv4 BGP status+--------------+-------------------+-------+----------+-------------+| PEER ADDRESS | PEER TYPE | STATE | SINCE | INFO |+--------------+-------------------+-------+----------+-------------+| 192.16.35.12 | node-to-node mesh | up | 04:42:37 | Established || 192.16.35.13 | node-to-node mesh | up | 04:42:42 | Established || 192.16.35.14 | node-to-node mesh | up | 04:42:37 | Established || 192.16.35.15 | node-to-node mesh | up | 04:42:41 | Established || 192.16.35.16 | node-to-node mesh | up | 04:42:36 | Established |+--------------+-------------------+-------+----------+-------------+...

查看 pending 的 pod 是否已执行：

$ kubectl -n kube-system get po -l k8s-app=kube-dns

kubectl -n kube-system get po -l k8s-app=kube-dns

NAME READY STATUS RESTARTS AGE

kube-dns-654684d656-j8xzx 3/3 Running 0 10m

Kubernetes Extra Addons 部署

本节说明如何部署一些官方常用的 Addons，如 Dashboard、Heapster 等。

Dashboard

Dashboard 是 Kubernetes 社区官方开发的仪表板，有了仪表板后管理者就能够通过 Web-based 方式来管理 Kubernetes 集群，除了提升管理方便，也让资源视觉化，让人更直觉看见系统信息的呈现结果。

在k8s-m1通过 kubectl 来建立 kubernetes dashboard 即可：

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml

$ kubectl -n kube-system get po,svc -l k8s-app=kubernetes-dashboard

NAME READY STATUS RESTARTS AGE

kubernetes-dashboard-7d5dcdb6d9-j492l 1/1 Running 0 12s



NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

kubernetes-dashboard ClusterIP 10.111.22.111 <none> 443/TCP 12s

这边会额外建立一个名称为open-api Cluster Role Binding，这仅作为方便测试时使用，在一般情况下不要开启，不然就会直接被存取所有 API:

$ cat <<EOF | kubectl create -f -

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRoleBinding

metadata:

 name: open-api

 namespace: ""

roleRef:

 apiGroup: rbac.authorization.k8s.io

 kind: ClusterRole

 name: cluster-admin

subjects: - apiGroup: rbac.authorization.k8s.io

 kind: User

 name: system:anonymous

EOF

注意!管理者可以针对特定使用者来开放 API 存取权限，但这边方便使用直接绑在 cluster-admin cluster role。

完成后，就可以通过浏览器存取 Dashboard。

在 1.7 版本以后的 Dashboard 将不再提供所有权限，因此需要建立一个 service account 来绑定 cluster-admin role：

$ kubectl -n kube-system create sa dashboard

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

$ SECRET=$(kubectl -n kube-system get sa dashboard -o yaml | awk '/dashboard-token/ {print $3}')

$ kubectl -n kube-system describe secrets ${SECRET} | awk '/token:/{print $2}'

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJkYXNoYm9hcmQtdG9rZW4tdzVocmgiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoiZGFzaGJvYXJkIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiYWJmMTFjYzMtZjRlYi0xMWU3LTgzYWUtMDgwMDI3NjdkOWI5Iiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmRhc2hib2FyZCJ9.Xuyq34ci7Mk8bI97o4IldDyKySOOqRXRsxVWIJkPNiVUxKT4wpQZtikNJe2mfUBBD-JvoXTzwqyeSSTsAy2CiKQhekW8QgPLYelkBPBibySjBhJpiCD38J1u7yru4P0Pww2ZQJDjIxY4vqT46ywBklReGVqY3ogtUQg-eXueBmz-o7lJYMjw8L14692OJuhBjzTRSaKW8U2MPluBVnD7M2SOekDff7KpSxgOwXHsLVQoMrVNbspUCvtIiEI1EiXkyCNRGwfnd2my3uzUABIHFhm0_RZSmGwExPbxflr8Fc6bxmuz-_jSdOtUidYkFIzvEWw2vRovPgs3MXTv59RwUw

复制token，然后贴到 Kubernetes dashboard。注意这边一般来说要针对不同 User 开启特定存取权限。

Heapster

Heapster 是 Kubernetes 社区维护的容器集群监控与效能分析工具。Heapster 会从 Kubernetes apiserver 取得所有 Node 信息，然后再通过这些 Node 来取得 kubelet 上的资料，最后再将所有收集到资料送到 Heapster 的后台储存 InfluxDB，最后利用 Grafana 来抓取 InfluxDB 的资料源来进行视觉化。

在k8s-m1通过 kubectl 来建立 kubernetes monitor 即可：

$ kubectl apply -f "https://kairen.github.io/files/manual-v1.10/addon/kube-monitor.yml.conf"

$ kubectl -n kube-system get po,svc

NAME READY STATUS RESTARTS AGE...

po/heapster-74fb5c8cdc-62xzc 4/4 Running 0 7m

po/influxdb-grafana-55bd7df44-nw4nc 2/2 Running 0 7m



NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE...

svc/heapster ClusterIP 10.100.242.225 <none> 80/TCP 7m

svc/monitoring-grafana ClusterIP 10.101.106.180 <none> 80/TCP 7m

svc/monitoring-influxdb ClusterIP 10.109.245.142 <none> 8083/TCP,8086/TCP 7m···

完成后，就可以通过浏览器存取 Grafana Dashboard。

Ingress Controller

Ingress是利用 Nginx 或 HAProxy 等负载平衡器来曝露集群内服务的元件，Ingress 主要通过设定 Ingress 规格来定义 Domain Name 映射 Kubernetes 内部 Service，这种方式可以避免掉使用过多的 NodePort 问题。

在k8s-m1通过 kubectl 来建立 Ingress Controller 即可：

$ kubectl create ns ingress-nginx

$ kubectl apply -f "https://kairen.github.io/files/manual-v1.10/addon/ingress-controller.yml.conf"

$ kubectl -n ingress-nginx get po

NAME READY STATUS RESTARTS AGEdefault-http-backend-5c6d95c48-rzxfb 1/1 Running 0 7m

nginx-ingress-controller-699cdf846-982n4 1/1 Running 0 7m

这里也可以选择 Traefik 的 Ingress Controller。

测试 Ingress 功能

这边先建立一个 Nginx HTTP server Deployment 与 Service：

$ kubectl run nginx-dp --image nginx --port 80

$ kubectl expose deploy nginx-dp --port 80

$ kubectl get po,svc

$ cat <<EOF | kubectl create -f -

apiVersion: extensions/v1beta1

kind: Ingress

metadata:

 name: test-nginx-ingress

 annotations:

 ingress.kubernetes.io/rewrite-target: /

spec:

 rules:

 - host: test.nginx.com

 http:

 paths:

 - path: /

 backend:

 serviceName: nginx-dp

 servicePort: 80

EOF

通过 curl 来进行测试：

$ curl 192.16.35.10 -H 'Host: test.nginx.com'<!DOCTYPE html><html><head><title>Welcome to nginx!</title>...

# 测试其他 domain name 是否会回传 404

$ curl 192.16.35.10 -H 'Host: test.nginx.com1'default backend - 404

Helm Tiller Server

Helm 是 Kubernetes Chart 的管理工具，Kubernetes Chart 是一套预先组态的 Kubernetes 资源套件。其中Tiller Server主要负责接收来至 Client 的指令，并通过 kube-apiserver 与 Kubernetes 集群做沟通，根据 Chart 定义的内容，来产生与管理各种对应 API 物件的 Kubernetes 部署文档(又称为 Release)。

首先在k8s-m1安装 Helm tool：

$ wget -qO- https://kubernetes-helm.storage.googleapis.com/helm-v2.8.1-linux-amd64.tar.gz | tar -zx

$ sudo mv linux-amd64/helm /usr/local/bin/

另外在所有node节点安装 socat：

$ sudo apt-get install -y socat

接着初始化 Helm(这边会安装 Tiller Server)：

$ kubectl -n kube-system create sa tiller

$ kubectl create clusterrolebinding tiller --clusterrole cluster-admin --serviceaccount=kube-system:tiller

$ helm init --service-account tiller...Tiller (the Helm server-side component) has been installed into your Kubernetes Cluster.Happy Helming!



$ kubectl -n kube-system get po -l app=helm

NAME READY STATUS RESTARTS AGE

tiller-deploy-5f789bd9f7-tzss6 1/1 Running 0 29s



$ helm versionClient: &version.Version{SemVer:"v2.8.1", GitCommit:"6af75a8fd72e2aa18a2b278cfe5c7a1c5feca7f2", GitTreeState:"clean"}Server: &version.Version{SemVer:"v2.8.1", GitCommit:"6af75a8fd72e2aa18a2b278cfe5c7a1c5feca7f2", GitTreeState:"clean"}

测试 Helm 功能

这边部署简单 Jenkins 来进行功能测试：

$ helm install --name demo --set Persistence.Enabled=false stable/jenkins

$ kubectl get po,svc -l app=demo-jenkins

NAME READY STATUS RESTARTS AGE

demo-jenkins-7bf4bfcff-q74nt 1/1 Running 0 2m



NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

demo-jenkins LoadBalancer 10.103.15.129 <pending> 8080:31161/TCP 2m

demo-jenkins-agent ClusterIP 10.103.160.126 <none> 50000/TCP 2m

# 取得 admin 账号的密码

$ printf $(kubectl get secret --namespace default demo-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

r6y9FMuF2u

完成后，就可以通过浏览器存取 Jenkins Web。

测试完成后，即可删除：

$ helm ls

NAME REVISION UPDATED STATUS CHART NAMESPACE

demo 1 Tue Apr 10 07:29:51 2018 DEPLOYED jenkins-0.14.4 default



$ helm delete demo --purge

release "demo" deleted

更多 Helm Apps 可以到 Kubeapps Hub 寻找。

测试集群

SSH 进入k8s-m1节点，然后关闭该节点：

$ sudo poweroff

接着进入到k8s-m2节点，通过 kubectl 来检查集群是否能够正常执行：

# 先检查 etcd 状态，可以发现 etcd-0 因为关机而中断

$ kubectl get cs

NAME STATUS MESSAGE ERROR

scheduler Healthy ok

controller-manager Healthy ok

etcd-1 Healthy {"health": "true"}

etcd-2 Healthy {"health": "true"}

etcd-0 Unhealthy Get https://192.16.35.11:2379/health: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers) # 测试是否可以建立 Pod

$ kubectl run nginx --image nginx --restart=Never --port 80

$ kubectl get po

NAME READY STATUS RESTARTS AGE

nginx 1/1 Running 0 22s

本文转自kubernetes中文社区- Kubernetes v1.10.x HA 全手动安装教程(TL;DR)

Kubernetes v1.10.x HA 全手动安装教程(TL;DR)

节点信息

事前准备

建立集群 CA keys 与 Certificates

Etcd

Kubernetes

API Server Certificate

Front Proxy Certificate

Admin Certificate

Controller Manager Certificate

Scheduler Certificate

Master Kubelet Certificate

Service Account Key

删除不必要文件

复制文件至其他节点

Kubernetes Masters

部署与设定

验证集群

建立 TLS Bootstrapping RBAC 与 Secret

Kubernetes Nodes

部署与设定

验证集群

Kubernetes Core Addons 部署

Kubernetes Proxy

Kubernetes DNS

Calico Network 安装与设定

Kubernetes Extra Addons 部署

Dashboard

Heapster

Ingress Controller

测试 Ingress 功能

Helm Tiller Server

测试 Helm 功能

测试集群

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Kubernetes v1.10.x HA 全手动安装教程(TL;DR)

节点信息

事前准备

建立集群 CA keys 与 Certificates

Etcd

Kubernetes

API Server Certificate

Front Proxy Certificate

Admin Certificate

Controller Manager Certificate

Scheduler Certificate

Master Kubelet Certificate

Service Account Key

删除不必要文件

复制文件至其他节点

Kubernetes Masters

部署与设定

验证集群

建立 TLS Bootstrapping RBAC 与 Secret

Kubernetes Nodes

部署与设定

验证集群

Kubernetes Core Addons 部署

Kubernetes Proxy

Kubernetes DNS

Calico Network 安装与设定

Kubernetes Extra Addons 部署

Dashboard

Heapster

Ingress Controller

测试 Ingress 功能

Helm Tiller Server

测试 Helm 功能

测试集群

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像