Kubernetes 1.8.x 全手动安装教程

作者：Kyle.Bai

目前就职 @inwinstack. 软件工程师

GitHub：https://github.com/kairen

Kubernetes 提供了许多云端平台与操作系统的安装方式，本章将以全手动安装方式来部署，主要是学习与了解 Kubernetes 创建流程。若想要了解更多平台的部署可以参考官方文档来选择自己最喜欢的方式。

本次安装版本为：

• Kubernetes v1.8.2

• Etcd v3.2.9

• Calico v2.6.2

• Docker v17.10.0-ce

1

预先准备信息

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

• 这边 master 为主要控制节点也是部署节点，node 为应用程序工作节点。

• 所有操作全部用root使用者进行，以 SRE 来说不推荐。

• 可以下载 Vagrantfile 来建立 Virtual box 虚拟机集群。 首先安装前要确认以下几项都已将准备完成：

• 所有节点彼此网络互通，并且master1 SSH 登入其他节点为 passwdless。

• 所有防火墙与 SELinux 已关闭。如 CentOS：

1. $ systemctl stop firewalld && systemctl disable firewalld

2. $ setenforce 0

3. $ vim /etc/selinux/config

4. SELINUX=disabled

• 所有节点需要设定/etc/host解析到所有主机。

1. ...

2. 172.16.35.10 node1

3. 172.16.35.11 node2

4. 172.16.35.12 master1

• 所有节点需要安装Docker或rtk引擎。这边采用Docker来当作容器引擎，安装方式如下：

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

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

1. $ systemctl enable docker && systemctl start docker

编辑/lib/systemd/system/docker.service，在ExecStart=..上面加入：

1. ExecStartPost=/sbin/iptables -I FORWARD -s 0.0.0.0/0 -j ACCEPT

完成后，重新启动 docker 服务：

1. $ systemctl daemon-reload && systemctl restart docker

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

1. $ cat <<EOF > /etc/sysctl.d/k8s.conf

2. net.ipv4.ip_forward = 1

3. net.bridge.bridge-nf-call-ip6tables = 1

4. net.bridge.bridge-nf-call-iptables = 1

5. EOF

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

• 在master1需要安装CFSSL工具，这将会用来建立 TLS certificates。

1. $ export CFSSL_URL="https://pkg.cfssl.org/R1.2"

2. $ wget "${CFSSL_URL}/cfssl_linux-amd64" -O /usr/local/bin/cfssl

3. $ wget "${CFSSL_URL}/cfssljson_linux-amd64" -O /usr/local/bin/cfssljson

4. $ chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson

2

Etcd

在开始安装 Kubernetes 之前，需要先将一些必要系统创建完成，其中 Etcd 就是 Kubernetes 最重要的一环，Kubernetes 会将大部分信息储存于 Etcd 上，来提供给其他节点索取，以确保整个集群运作与沟通正常。

2.1创建集群 CA 与 Certificates

在这部分，将会需要产生 client 与 server 的各组件 certificates，并且替 Kubernetes admin user 产生 client 证书。 建立/etc/etcd/ssl文件夹，然后进入目录完成以下操作。

1. $ mkdir -p /etc/etcd/ssl && cd /etc/etcd/ssl

2. $ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki"

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

1. $ wget "${PKI_URL}/ca-config.json" "${PKI_URL}/etcd-ca-csr.json"

2. $ cfssl gencert -initca etcd-ca-csr.json | cfssljson -bare etcd-ca

3. $ ls etcd-ca*.pem

4. etcd-ca-key.pem  etcd-ca.pem

下载etcd-csr.json文件，并产生 kube-apiserver certificate 证书：

1. $ wget "${PKI_URL}/etcd-csr.json"

2. $ cfssl gencert \

3.  -ca=etcd-ca.pem \

4.  -ca-key=etcd-ca-key.pem \

5.  -config=ca-config.json \

6.  -profile=kubernetes \

7.  etcd-csr.json | cfssljson -bare etcd

8. $ ls etcd*.pem

9. etcd-ca-key.pem  etcd-ca.pem  etcd-key.pem  etcd.pe

若节点 IP 不同，需要修改etcd-csr.json的hosts。 完成后删除不必要文件：

1. $ rm -rf *.json

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

1. $ ls /etc/etcd/ssl

2. etcd-ca.csr  etcd-ca-key.pem  etcd-ca.pem  etcd.csr  etcd-key.pem  etcd.pem

2.2Etcd 安装与设定

首先在master1节点下载 Etcd，并解压缩放到 /opt 底下与安装：

1. $ export ETCD_URL="https://github.com/coreos/etcd/releases/download"

2. $ cd && wget -qO- --show-progress "${ETCD_URL}/v3.2.9/etcd-v3.2.9-linux-amd64.tar.gz" | tar -zx

3. $ mv etcd-v3.2.9-linux-amd64/etcd* /usr/local/bin/ && rm -rf etcd-v3.2.9-linux-amd64

完成后新建 Etcd Group 与 User，并建立 Etcd 配置文件目录：

1. $ groupadd etcd && useradd -c "Etcd user" -g etcd -s /sbin/nologin -r etcd

下载etcd相关文件，我们将来管理 Etcd：

1. $ export ETCD_CONF_URL="https://kairen.github.io/files/manual-v1.8/master"

2. $ wget "${ETCD_CONF_URL}/etcd.conf" -O /etc/etcd/etcd.conf

3. $ wget "${ETCD_CONF_URL}/etcd.service" -O /lib/systemd/system/etcd.service

若与该教程 IP 不同的话，请用自己 IP 取代172.16.35.12。 建立 var 存放信息，然后启动 Etcd 服务:

1. $ mkdir -p /var/lib/etcd && chown etcd:etcd -R /var/lib/etcd /etc/etcd

2. $ systemctl enable etcd.service && systemctl start etcd.service

通过简单指令验证：

1. $ export CA="/etc/etcd/ssl"

2. $ ETCDCTL_API=3 etcdctl \

3.    --cacert=${CA}/etcd-ca.pem \

4.    --cert=${CA}/etcd.pem \

5.    --key=${CA}/etcd-key.pem \

6.    --endpoints="https://172.16.35.12:2379" \

7.    endpoint health

8. # output

9. https://172.16.35.12:2379 is healthy: successfully committed proposal: took = 641.36µs

3

Kubernetes Master

Master 是 Kubernetes 的大总管，主要创建apiserver、Controller manager与Scheduler来组件管理所有 Node。本步骤将下载 Kubernetes 并安装至 master1上，然后产生相关 TLS Cert 与 CA 密钥，提供给集群组件认证使用。

3.1下载 Kubernetes 组件

首先通过网络取得所有需要的执行文件：

1. # Download Kubernetes

2. $ export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.8.2/bin/linux/amd64"

3. $ wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet

4. $ wget "${KUBE_URL}/kubectl" -O /usr/local/bin/kubectl

5. $ chmod +x /usr/local/bin/kubelet /usr/local/bin/kubectl

6. # Download CNI

7. $ mkdir -p /opt/cni/bin && cd /opt/cni/bin

8. $ export CNI_URL="https://github.com/containernetworking/plugins/releases/download"

9. $ wget -qO- --show-progress "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx

3.2创建集群 CA 与 Certificates

在这部分，将会需要生成 client 与 server 的各组件 certificates，并且替 Kubernetes admin user 生成 client 证书。 创建pki文件夹，然后进入目录完成以下操作。

1. $ mkdir -p /etc/kubernetes/pki && cd /etc/kubernetes/pki

2. $ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki"

3. $ export KUBE_APISERVER="https://172.16.35.12:6443"

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

1. $ wget "${PKI_URL}/ca-config.json" "${PKI_URL}/ca-csr.json"

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

3. $ ls ca*.pem

4. ca-key.pem  ca.pem

API server certificate 下载apiserver-csr.json文件，并生成 kube-apiserver certificate 证书：

1. $ wget "${PKI_URL}/apiserver-csr.json"

2. $ cfssl gencert \

3.  -ca=ca.pem \

4.  -ca-key=ca-key.pem \

5.  -config=ca-config.json \

6.  -hostname=10.96.0.1,172.16.35.12,127.0.0.1,kubernetes.default \

7.  -profile=kubernetes \

8.  apiserver-csr.json | cfssljson -bare apiserver

9. $ ls apiserver*.pem

10. apiserver-key.pem  apiserver.pem

若节点 IP 不同，需要修改apiserver-csr.json的hosts。 Front proxy certificate 下载front-proxy-ca-csr.json文件，并生成 Front proxy CA 密钥，Front proxy 主要是用在 API aggregator 上:

1. $ wget "${PKI_URL}/front-proxy-ca-csr.json"

2. $ cfssl gencert \

3.  -initca front-proxy-ca-csr.json | cfssljson -bare front-proxy-ca

4. $ ls front-proxy-ca*.pem

5. front-proxy-ca-key.pem  front-proxy-ca.pem

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

1. $ wget "${PKI_URL}/front-proxy-client-csr.json"

2. $ cfssl gencert \

3.  -ca=front-proxy-ca.pem \

4.  -ca-key=front-proxy-ca-key.pem \

5.  -config=ca-config.json \

6.  -profile=kubernetes \

7.  front-proxy-client-csr.json | cfssljson -bare front-proxy-client

8. $ ls front-proxy-client*.pem

9. front-proxy-client-key.pem  front-proxy-client.pem

Bootstrap Token 由于通过手动创建 CA 方式太过繁杂，只适合少量机器，因为每次签证时都需要绑定 Node IP，随机器增加会带来很多困扰，因此这边使用 TLS Bootstrapping 方式进行授权，由 apiserver 自动给符合条件的 Node 发送证书来授权加入集群。 主要做法是 kubelet 启动时，向 kube-apiserver 传送 TLS Bootstrapping 请求，而 kube-apiserver 验证 kubelet 请求的 token 是否与设定的一样，若一样就自动产生 kubelet 证书与密钥。具体作法可以参考 TLS bootstrapping。 首先建立一个变量来产生BOOTSTRAP_TOKEN，并建立 bootstrap.conf 的 kubeconfig 文件：

1. $ export BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')

2. $ cat <<EOF > /etc/kubernetes/token.csv

3. ${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"

4. EOF

5. # bootstrap set-cluster

6. $ kubectl config set-cluster kubernetes \

7.    --certificate-authority=ca.pem \

8.    --embed-certs=true \

9.    --server=${KUBE_APISERVER} \

10.    --kubeconfig=../bootstrap.conf

11. # bootstrap set-credentials

12. $ kubectl config set-credentials kubelet-bootstrap \

13.    --token=${BOOTSTRAP_TOKEN} \

14.    --kubeconfig=../bootstrap.conf

15. # bootstrap set-context

16. $ kubectl config set-context default \

17.    --cluster=kubernetes \

18.    --user=kubelet-bootstrap \

19.   --kubeconfig=../bootstrap.conf

20. # bootstrap set default context

21. $ kubectl config use-context default --kubeconfig=../bootstrap.conf

若想要用 CA 方式来认证，可以参考 Kubelet certificate。 Admin certificate 下载admin-csr.json文件，并生成 admin certificate 证书：

1. $ wget "${PKI_URL}/admin-csr.json"

2. $ cfssl gencert \

3.  -ca=ca.pem \

4.  -ca-key=ca-key.pem \

5.  -config=ca-config.json \

6.  -profile=kubernetes \

7.  admin-csr.json | cfssljson -bare admin

8. $ ls admin*.pem

9. admin-key.pem  admin.pem

接着通过以下指令生成名称为 admin.conf 的 kubeconfig 文件：

1. # admin set-cluster

2. $ kubectl config set-cluster kubernetes \

3.    --certificate-authority=ca.pem \

4.    --embed-certs=true \

5.    --server=${KUBE_APISERVER} \

6.    --kubeconfig=../admin.conf

7. # admin set-credentials

8. $ kubectl config set-credentials kubernetes-admin \

9.    --client-certificate=admin.pem \

10.    --client-key=admin-key.pem \

11.    --embed-certs=true \

12.    --kubeconfig=../admin.conf

13. # admin set-context

14. $ kubectl config set-context kubernetes-admin@kubernetes \

15.    --cluster=kubernetes \

16.    --user=kubernetes-admin \

17.    --kubeconfig=../admin.conf

18. # admin set default context

19. $ kubectl config use-context kubernetes-admin@kubernetes \

20.    --kubeconfig=../admin.conf

21. Controller manager certificate

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

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

2. $ cfssl gencert \

3.  -ca=ca.pem \

4.  -ca-key=ca-key.pem \

5.  -config=ca-config.json \

6.  -profile=kubernetes \

7.  manager-csr.json | cfssljson -bare controller-manager

8. $ ls controller-manager*.pem

若节点 IP 不同，需要修改manager-csr.json的hosts。 接着通过以下指令生成名称为controller-manager.conf的 kubeconfig 文件：

1. # controller-manager set-cluster

2. $ kubectl config set-cluster kubernetes \

3.    --certificate-authority=ca.pem \

4.    --embed-certs=true \

5.    --server=${KUBE_APISERVER} \

6.    --kubeconfig=../controller-manager.conf

7. # controller-manager set-credentials

8. $ kubectl config set-credentials system:kube-controller-manager \

9.    --client-certificate=controller-manager.pem \

10.    --client-key=controller-manager-key.pem \

11.    --embed-certs=true \

12.    --kubeconfig=../controller-manager.conf

13. # controller-manager set-context

14. $ kubectl config set-context system:kube-controller-manager@kubernetes \

15.    --cluster=kubernetes \

16.    --user=system:kube-controller-manager \

17.    --kubeconfig=../controller-manager.conf

18. # controller-manager set default context

19. $ kubectl config use-context system:kube-controller-manager@kubernetes \

20.    --kubeconfig=../controller-manager.conf

Scheduler certificate 下载scheduler-csr.json文件，并生成 kube-scheduler certificate 证书：

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

2. $ cfssl gencert \

3.  -ca=ca.pem \

4.  -ca-key=ca-key.pem \

5.  -config=ca-config.json \

6.  -profile=kubernetes \

7.  scheduler-csr.json | cfssljson -bare scheduler

8. $ ls scheduler*.pem

9. scheduler-key.pem  scheduler.pem

若节点 IP 不同，需要修改scheduler-csr.json的hosts。 接着通过以下指令生成名称为 scheduler.conf 的 kubeconfig 文件：

1. # scheduler set-cluster

2. $ kubectl config set-cluster kubernetes \

3.    --certificate-authority=ca.pem \

4.    --embed-certs=true \

5.    --server=${KUBE_APISERVER} \

6.    --kubeconfig=../scheduler.conf

7. # scheduler set-credentials

8. $ kubectl config set-credentials system:kube-scheduler \

9.    --client-certificate=scheduler.pem \

10.    --client-key=scheduler-key.pem \

11.    --embed-certs=true \

12.    --kubeconfig=../scheduler.conf

13. # scheduler set-context

14. $ kubectl config set-context system:kube-scheduler@kubernetes \

15.    --cluster=kubernetes \

16.    --user=system:kube-scheduler \

17.    --kubeconfig=../scheduler.conf

18. # scheduler set default context

19. $ kubectl config use-context system:kube-scheduler@kubernetes \

20.    --kubeconfig=../scheduler.conf

Kubelet master certificate 下载kubelet-csr.json文件，并生成 master node certificate 证书：

1. $ wget "${PKI_URL}/kubelet-csr.json"

2. $ sed -i 's/$NODE/master1/g' kubelet-csr.json

3. $ cfssl gencert \

4.  -ca=ca.pem \

5.  -ca-key=ca-key.pem \

6.  -config=ca-config.json \

7.  -hostname=master1,172.16.35.12,172.16.35.12 \

8.  -profile=kubernetes \

9.  kubelet-csr.json | cfssljson -bare kubelet

10. $ ls kubelet*.pem

11. kubelet-key.pem  kubelet.pem

这边$NODE需要随节点名称不同而改变。 接着通过以下指令生成名称为 kubelet.conf 的 kubeconfig 文件：

1. # kubelet set-cluster

2. $ kubectl config set-cluster kubernetes \

3.    --certificate-authority=ca.pem \

4.    --embed-certs=true \

5.    --server=${KUBE_APISERVER} \

6.    --kubeconfig=../kubelet.conf

7. # kubelet set-credentials

8. $ kubectl config set-credentials system:node:master1 \

9.    --client-certificate=kubelet.pem \

10.    --client-key=kubelet-key.pem \

11.    --embed-certs=true \

12.    --kubeconfig=../kubelet.conf

13. # kubelet set-context

14. $ kubectl config set-context system:node:master1@kubernetes \

15.    --cluster=kubernetes \

16.    --user=system:node:master1 \

17.    --kubeconfig=../kubelet.conf

18. # kubelet set default context

19. $ kubectl config use-context system:node:master1@kubernetes \

20.    --kubeconfig=../kubelet.conf

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

1. $ openssl genrsa -out sa.key 2048

2. $ openssl rsa -in sa.key -pubout -out sa.pub

3. $ ls sa.*

4. sa.key  sa.pub

完成后删除不必要文件：

1. $ rm -rf *.json *.csr

确认/etc/kubernetes与/etc/kubernetes/pki有以下文件：

1. $ ls /etc/kubernetes/

2. admin.conf  bootstrap.conf  controller-manager.conf  kubelet.conf  pki  scheduler.conf  token.csv

3. $ ls /etc/kubernetes/pki

4. admin-key.pem  apiserver-key.pem  ca-key.pem  controller-manager-key.pem  front-proxy-ca-key.pem  front-proxy-client-key.pem  kubelet-key.pem  sa.key  scheduler-key.pem

5. admin.pem      apiserver.pem      ca.pem      controller-manager.pem      front-proxy-ca.pem      front-proxy-client.pem      kubelet.pem      sa.pub  scheduler.pem

3.3安装 Kubernetes 核心组件

首先下载 Kubernetes 核心组件 YAML 文件，这边我们不透过 Binary 方案来创建 Master 核心组件，而是利用 Kubernetes Static Pod 来创建，因此需下载所有核心组件的Static Pod文件到/etc/kubernetes/manifests目录：

1. $ export CORE_URL="https://kairen.github.io/files/manual-v1.8/master"

2. $ mkdir -p /etc/kubernetes/manifests && cd /etc/kubernetes/manifests

3. $ for FILE in apiserver manager scheduler; do

4.    wget "${CORE_URL}/${FILE}.yml.conf" -O ${FILE}.yml

5.  done

若IP与教程设定不同的话，请记得修改apiserver.yml、manager.yml、scheduler.yml。 apiserver 中的 NodeRestriction 请参考 Using Node Authorization。 生成一个用来加密 Etcd 的 Key：

1. $ head -c 32 /dev/urandom | base64

2. SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ=

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

1. $ cat <<EOF > /etc/kubernetes/encryption.yml

2. kind: EncryptionConfig

3. apiVersion: v1

4. resources:

5.  - resources:

6.      - secrets

7.    providers:

8.      - aescbc:

9.          keys:

10.            - name: key1

11.              secret: SUpbL4juUYyvxj3/gonV5xVEx8j769/99TSAf8YT/sQ=

12.      - identity: {}

13. EOF

Etcd 数据加密可参考这篇 Encrypting data at rest。 在/etc/kubernetes/目录下，创建audit-policy.yml的进阶审核策略 YAML 文件：

1. $ cat <<EOF > /etc/kubernetes/audit-policy.yml

2. apiVersion: audit.k8s.io/v1beta1

3. kind: Policy

4. rules:

5. - level: Metadata

6. EOF

Audit Policy 请参考这篇 Auditing。 下载kubelet.service相关文件来管理 kubelet：

1. $ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/master"

2. $ mkdir -p /etc/systemd/system/kubelet.service.d

3. $ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service

4. $ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf

最后创建 var 存放信息，然后启动 kubelet 服务:

1. $ mkdir -p /var/lib/kubelet /var/log/kubernetes

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

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

1. $ watch netstat -ntlp

2. tcp        0      0 127.0.0.1:10248         0.0.0.0:*               LISTEN      23012/kubelet

3. tcp        0      0 127.0.0.1:10251         0.0.0.0:*               LISTEN      22305/kube-schedule

4. tcp        0      0 127.0.0.1:10252         0.0.0.0:*               LISTEN      22529/kube-controll

5. tcp6       0      0 :::6443                 :::*                    LISTEN      22956/kube-apiserve

若看到以上信息表示服务正常启动，若发生问题可以用docker cli来查看。 完成后，复制 admin kubeconfig 文件，并通过简单指令验证：

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

2. $ kubectl get cs

3. NAME                 STATUS    MESSAGE              ERROR

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

5. scheduler            Healthy   ok

6. controller-manager   Healthy   ok

7. $ kubectl get node

8. NAME      STATUS     ROLES     AGE       VERSION

9. master1   NotReady   master    4m        v1.8.2

10. $ kubectl -n kube-system get po

11. NAME                              READY     STATUS    RESTARTS   AGE

12. kube-apiserver-master1            1/1       Running   0          4m

13. kube-controller-manager-master1   1/1       Running   0          4m

14. kube-scheduler-master1            1/1       Running   0          4m

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

1. $ kubectl -n kube-system logs -f kube-scheduler-master1

2. Error from server (Forbidden): Forbidden (user=kube-apiserver, verb=get, resource=nodes, subresource=proxy) ( pods/log kube-apiserver-master1)

这边会发现出现 403 Forbidden 问题，这是因为 kube-apiserver user 并没有 nodes 的资源权限，属于正常。 由于上述权限问题，我们必需创建一个 apiserver-to-kubelet-rbac.yml 来定义权限，以供我们执行 logs、exec 等指令：

1. $ cd /etc/kubernetes/

2. $ export URL="https://kairen.github.io/files/manual-v1.8/master"

3. $ wget "${URL}/apiserver-to-kubelet-rbac.yml.conf" -O apiserver-to-kubelet-rbac.yml

4. $ kubectl apply -f apiserver-to-kubelet-rbac.yml

5. # 測試 logs

6. $ kubectl -n kube-system logs -f kube-scheduler-master1

7. ...

8. I1031 03:22:42.527697       1 leaderelection.go:184] successfully acquired lease kube-system/kube-scheduler

4

Kubernetes Node

Node 是主要执行容器实例的节点，可视为工作节点。在这步骤我们会下载 Kubernetes binary 文件，并创建 node 的 certificate 来提供给节点注册认证用。Kubernetes 使用Node Authorizer来提供Authorization mode，这种授权模式会替 Kubelet 生成 API request。 在开始前，我们先在master1将需要的 ca 与 cert 复制到 Node 节点上：

1. $ for NODE in node1 node2; do

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

3.    ssh ${NODE} "mkdir -p /etc/etcd/ssl"

4.    # Etcd ca and cert

5.    for FILE in etcd-ca.pem etcd.pem etcd-key.pem; do

6.      scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}

7.    done

8.    # Kubernetes ca and cert

9.    for FILE in pki/ca.pem pki/ca-key.pem bootstrap.conf; do

10.      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}

11.    done

12.  done

4.1下载 Kubernetes 组件

首先通过网络取得所有需要的执行文件：

1. # Download Kubernetes

2. $ export KUBE_URL="https://storage.googleapis.com/kubernetes-release/release/v1.8.2/bin/linux/amd64"

3. $ wget "${KUBE_URL}/kubelet" -O /usr/local/bin/kubelet

4. $ chmod +x /usr/local/bin/kubelet

5. # Download CNI

6. $ mkdir -p /opt/cni/bin && cd /opt/cni/bin

7. $ export CNI_URL="https://github.com/containernetworking/plugins/releases/download"

8. $ wget -qO- --show-progress "${CNI_URL}/v0.6.0/cni-plugins-amd64-v0.6.0.tgz" | tar -zx

4.2设定 Kubernetes node

接着下载 Kubernetes 相关文件，包含 drop-in file、systemd service 档案等：

1. $ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/node"

2. $ mkdir -p /etc/systemd/system/kubelet.service.d

3. $ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service

4. $ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf

接着在所有node创建 var 存放信息，然后启动 kubelet 服务:

1. $ mkdir -p /var/lib/kubelet /var/log/kubernetes /etc/kubernetes/manifests

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

P.S. 重复一样动作来完成其他节点。

4.3授权 Kubernetes Node

当所有节点都完成后，在master节点，因为我们采用 TLS Bootstrapping，所需要创建一个 ClusterRoleBinding：

1. $ kubectl create clusterrolebinding kubelet-bootstrap \

2.    --clusterrole=system:node-bootstrapper \

3.    --user=kubelet-bootstrap

在master通过简单指令验证，会看到节点处于pending：

1. $ kubectl get csr

2. NAME                                                   AGE       REQUESTOR           CONDITION

3. node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE   2s        kubelet-bootstrap   Pending

4. node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE   2s        kubelet-bootstrap   Pending

通过 kubectl 来允许节点加入集群：

1. $ kubectl get csr | awk '/Pending/ {print $1}' | xargs kubectl certificate approve

2. certificatesigningrequest "node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE" approved

3. certificatesigningrequest "node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE" approved

4. $ kubectl get csr

5. NAME                                                   AGE       REQUESTOR           CONDITION

6. node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE   30s       kubelet-bootstrap   Approved,Issued

7. node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE   30s       kubelet-bootstrap   Approved,Issued

8. $ kubectl get no

9. NAME      STATUS     ROLES     AGE       VERSION

10. master1   NotReady   master    15m       v1.8.2

11. node1     NotReady   <none>    8m        v1.8.2

12. node2     NotReady   <none>    6s        v1.8.2

5

Kubernetes Core Addons 部署

当完成上面所有步骤后，接着我们需要安装一些插件，而这些有部分是非常重要跟好用的，如Kube-dns与Kube-proxy等。

5.1Kube-proxy addon

Kube-proxy 是实现 Service 的关键组件，kube-proxy 会在每台节点上执行，然后监听 API Server 的 Service 与 Endpoint 资源对象的改变，然后来依据变化执行 iptables 来实现网络的转发。这边我们会需要建议一个 DaemonSet 来执行，并且创建一些需要的 certificate。Kubernetes 1.8 kube-proxy 开启 ipvs 首先在master1下载kube-proxy-csr.json文件，并产生 kube-proxy certificate 证书：

1. $ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki"

2. $ cd /etc/kubernetes/pki

3. $ wget "${PKI_URL}/kube-proxy-csr.json" "${PKI_URL}/ca-config.json"

4. $ cfssl gencert \

5.  -ca=ca.pem \

6.  -ca-key=ca-key.pem \

7.  -config=ca-config.json \

8.  -profile=kubernetes \

9.  kube-proxy-csr.json | cfssljson -bare kube-proxy

10. $ ls kube-proxy*.pem

11. kube-proxy-key.pem  kube-proxy.pem

接着透过以下指令生成名称为 kube-proxy.conf 的 kubeconfig 文件：

1. # kube-proxy set-cluster

2. $ kubectl config set-cluster kubernetes \

3.    --certificate-authority=ca.pem \

4.    --embed-certs=true \

5.    --server="https://172.16.35.12:6443" \

6.    --kubeconfig=../kube-proxy.conf

7. # kube-proxy set-credentials

8. $ kubectl config set-credentials system:kube-proxy \

9.    --client-key=kube-proxy-key.pem \

10.    --client-certificate=kube-proxy.pem \

11.    --embed-certs=true \

12.    --kubeconfig=../kube-proxy.conf

13. # kube-proxy set-context

14. $ kubectl config set-context system:kube-proxy@kubernetes \

15.    --cluster=kubernetes \

16.    --user=system:kube-proxy \

17.    --kubeconfig=../kube-proxy.conf

18. # kube-proxy set default context

19. $ kubectl config use-context system:kube-proxy@kubernetes \

20.    --kubeconfig=../kube-proxy.conf

完成后删除不必要文件：

1. $ rm -rf *.json

确认/etc/kubernetes有以下文件：

1. $ ls /etc/kubernetes/

2. admin.conf        bootstrap.conf           encryption.yml  kube-proxy.conf  pki             token.csv

3. audit-policy.yml  controller-manager.conf  kubelet.conf    manifests        scheduler.conf

在master1将kube-proxy相关文件复制到 Node 节点上：

1. $ for NODE in node1 node2; do

2.    for FILE in pki/kube-proxy.pem pki/kube-proxy-key.pem kube-proxy.conf; do

3.      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}

4.    done

5.  done

完成后，在master1通过 kubectl 来创建 kube-proxy daemon：

1. $ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"

2. $ mkdir -p /etc/kubernetes/addons && cd /etc/kubernetes/addons

3. $ wget "${ADDON_URL}/kube-proxy.yml.conf" -O kube-proxy.yml

4. $ kubectl apply -f kube-proxy.yml

5. $ kubectl -n kube-system get po -l k8s-app=kube-proxy

6. NAME               READY     STATUS    RESTARTS   AGE

7. kube-proxy-bpp7q   1/1       Running   0          47s

8. kube-proxy-cztvh   1/1       Running   0          47s

9. kube-proxy-q7mm4   1/1       Running   0          47s

5.2Kube-dns addon

Kube DNS 是 Kubernetes 集群内部 Pod 之间互相沟通的重要 Addon，它允许 Pod 可以通过 Domain Name 方式来连接 Service，其主要由 Kube DNS 与 Sky DNS 组合而成，通过 Kube DNS 监听 Service 与 Endpoint 变化，来提供给 Sky DNS 信息，已更新解析地址。 安装只需要在master1通过 kubectl 来创建 kube-dns deployment 即可：

1. $ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"

2. $ wget "${ADDON_URL}/kube-dns.yml.conf" -O kube-dns.yml

3. $ kubectl apply -f kube-dns.yml

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

5. NAME                        READY     STATUS    RESTARTS   AGE

6. kube-dns-6cb549f55f-h4zr5   0/3       Pending   0          40s

6

Calico Network 安装与设定

Calico 是一款纯 Layer 3 的数据中心网络方案(不需要 Overlay 网络)，Calico 好处是他已与各种云原生平台有良好的整合，而 Calico 在每一个节点利用 Linux Kernel 实现高效的 vRouter 来负责数据的转发，而当数据中心复杂度增加时，可以用 BGP route reflector 来达成。 首先在master1通过 kubectl 建立 Calico policy controller：

1. $ export CALICO_CONF_URL="https://kairen.github.io/files/manual-v1.8/network"

2. $ wget "${CALICO_CONF_URL}/calico-controller.yml.conf" -O calico-controller.yml

3. $ kubectl apply -f calico-controller.yml

4. $ kubectl -n kube-system get po -l k8s-app=calico-policy

5. NAME                                        READY     STATUS    RESTARTS   AGE

6. calico-policy-controller-5ff8b4549d-tctmm   0/1       Pending   0          5s

在master1下载 Calico CLI 工具：

1. $ wget https://github.com/projectcalico/calicoctl/releases/download/v1.6.1/calicoctl

2. $ chmod +x calicoctl && mv calicoctl /usr/local/bin/

然后在所有节点下载 Calico，并执行以下步骤：

1. $ export CALICO_URL="https://github.com/projectcalico/cni-plugin/releases/download/v1.11.0"

2. $ wget -N -P /opt/cni/bin ${CALICO_URL}/calico

3. $ wget -N -P /opt/cni/bin ${CALICO_URL}/calico-ipam

4. $ chmod +x /opt/cni/bin/calico /opt/cni/bin/calico-ipam

接着在所有节点下载 CNI plugins配置文件，以及 calico-node.service：

1. $ mkdir -p /etc/cni/net.d

2. $ export CALICO_CONF_URL="https://kairen.github.io/files/manual-v1.8/network"

3. $ wget "${CALICO_CONF_URL}/10-calico.conf" -O /etc/cni/net.d/10-calico.conf

4. $ wget "${CALICO_CONF_URL}/calico-node.service" -O /lib/systemd/system/calico-node.service

若部署的机器是使用虚拟机，如 Virtualbox 等的话，请修改calico-node.service文件，并在IPAUTODETECTIONMETHOD(包含 IP6)部分指定绑定的网卡，以避免默认绑定到 NAT 网络上。 之后在所有节点启动 Calico-node:

1. $ systemctl enable calico-node.service && systemctl start calico-node.service

在master1查看 Calico nodes:

1. $ cat <<EOF > ~/calico-rc

2. export ETCD_ENDPOINTS="https://172.16.35.12:2379"

3. export ETCD_CA_CERT_FILE="/etc/etcd/ssl/etcd-ca.pem"

4. export ETCD_CERT_FILE="/etc/etcd/ssl/etcd.pem"

5. export ETCD_KEY_FILE="/etc/etcd/ssl/etcd-key.pem"

6. EOF

7. $ . ~/calico-rc

8. $ calicoctl get node -o wide

9. NAME      ASN       IPV4              IPV6

10. master1   (64512)   172.16.35.12/24

11. node1     (64512)   172.16.35.10/24

12. node2     (64512)   172.16.35.11/24

查看 pending 的 pod 是否已执行：

1. $ kubectl -n kube-system get po

2. NAME                                        READY     STATUS    RESTARTS   AGE

3. calico-policy-controller-5ff8b4549d-tctmm   1/1       Running   0          4m

4. kube-apiserver-master1                      1/1       Running   0          20m

5. kube-controller-manager-master1             1/1       Running   0          20m

6. kube-dns-6cb549f55f-h4zr5                   3/3       Running   0          5m

7. kube-proxy-fnrkb                            1/1       Running   0          6m

8. kube-proxy-l72bq                            1/1       Running   0          6m

9. kube-proxy-m6rfw                            1/1       Running   0          6m

10. kube-scheduler-master1                      1/1       Running   0          20m

最后若想省事，可以直接用 Standard Hosted 方式安装。

7

Kubernetes Extra Addons 部署

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

7.1Dashboard addon

Dashboard 是 Kubernetes 社区官方开发的仪表板，有了仪表板后管理者就能够透过 Web-based 方式来管理 Kubernetes 集群，除了提升管理方便，也让资源可视化，让人更直觉看见系统信息的呈现结果。 首先我们要建立kubernetes-dashboard-certs，来提供给 Dashboard TLS 使用：

1. $ mkdir -p /etc/kubernetes/addons/certs && cd /etc/kubernetes/addons

2. $ openssl genrsa -des3 -passout pass:x -out certs/dashboard.pass.key 2048

3. $ openssl rsa -passin pass:x -in certs/dashboard.pass.key -out certs/dashboard.key

4. $ openssl req -new -key certs/dashboard.key -out certs/dashboard.csr -subj '/CN=kube-dashboard'

5. $ openssl x509 -req -sha256 -days 365 -in certs/dashboard.csr -signkey certs/dashboard.key -out certs/dashboard.crt

6. $ rm certs/dashboard.pass.key

7. $ kubectl create secret generic kubernetes-dashboard-certs\

8.    --from-file=certs -n kube-system

接着在master1通过 kubectl 来建立 kubernetes dashboard 即可：

1. $ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"

2. $ wget ${ADDON_URL}/kube-dashboard.yml.conf -O kube-dashboard.yml

3. $ kubectl apply -f kube-dashboard.yml

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

5. NAME                                      READY     STATUS    RESTARTS   AGE

6. po/kubernetes-dashboard-747c4f7cf-md5m8   1/1       Running   0          56s

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

8. svc/kubernetes-dashboard   ClusterIP   10.98.120.209   <none>        443/TCP   56s

P.S. 这边会额外创建一个名称为anonymous-open-door Cluster Role Binding，这仅作为方便测试时使用，在一般情况下不要开启，不然就会直接被存取所有 API。 完成后，就可以透过浏览器访问 Dashboard，https://172.16.35.12:6443/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/

7.2Heapster addon

Heapster 是 Kubernetes 社区维护的容器集群监控分析工具。Heapster 会从 Kubernetes apiserver 获得所有 Node 信息，然后再通过这些 Node 来获得 kubelet 上的数据，最后再将所有收集到数据送到 Heapster 的后台储存 InfluxDB，最后利用 Grafana 来抓取 InfluxDB 的数据源来进行可视化。 在master1通过 kubectl 来创建 kubernetes monitor 即可：

1. $ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"

2. $ wget ${ADDON_URL}/kube-monitor.yml.conf -O kube-monitor.yml

3. $ kubectl apply -f kube-monitor.yml

4. $ kubectl -n kube-system get po,svc

5. NAME                                           READY     STATUS    RESTARTS   AGE

6. ...

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

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

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

10. ...

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

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

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

14. ···

完成后，就可以透过浏览器存取 Grafana Dashboard，https://172.16.35.12:6443/api/v1/proxy/namespaces/kube-system/services/monitoring-grafana

8

简单部署 Nginx 服务

Kubernetes 可以选择使用指令直接创建应用程序与服务，或者撰写 YAML 与 JSON 档案来描述部署应用程序的配置，以下将创建一个简单的 Nginx 服务：

1. $ kubectl run nginx --image=nginx --port=80

2. $ kubectl expose deploy nginx --port=80 --type=LoadBalancer --external-ip=172.16.35.12

3. $ kubectl get svc,po

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

5. svc/kubernetes   ClusterIP      10.96.0.1       <none>         443/TCP        1h

6. svc/nginx        LoadBalancer   10.97.121.243   172.16.35.12   80:30344/TCP   22s

7. NAME                        READY     STATUS    RESTARTS   AGE

8. po/nginx-7cbc4b4d9c-7796l   1/1       Running   0          28s       192.160.57.181   ,172.16.35.12   80:32054/TCP   21s

这边type可以选择 NodePort 与 LoadBalancer，在本地裸机部署，两者差异在于NodePort只映射 Host port 到 Container port，而LoadBalancer则继承NodePort额外多出映射 Host target port 到 Container port。 确认没问题后即可在浏览器存取 http://172.16.35.12

8.1扩展服务数量

若集群node节点增加了，而想让 Nginx 服务提供可靠性的话，可以通过以下方式来扩展服务的副本：

1. $ kubectl scale deploy nginx --replicas=2

2. $ kubectl get pods -o wide

3. NAME                    READY     STATUS    RESTARTS   AGE       IP             NODE

4. nginx-158599303-0h9lr   1/1       Running   0          25s       10.244.100.5   node2

5. nginx-158599303-k7cbt   1/1       Running   0          1m        10.244.24.3    node1