Kubernetes 1.8.x 全手動安裝教程

時間 2019-11-16

標籤 kubernetes 1.8.x 手動安裝教程简体版

原文原文鏈接

Kubernetes 提供了許多雲端平臺與操做系統的安裝方式，本章將以全手動安裝方式來部署，主要是學習與瞭解 Kubernetes 建立流程。若想要了解更多平臺的部署能夠參考 Picking the Right Solution來選擇本身最喜歡的方式。html

本次安裝版本爲：node

Kubernetes v1.8.2
Etcd v3.2.9
Calico v2.6.2
Docker v17.10.0-ce

預先準備信息

本教程將如下列節點數與規格來進行部署 Kubernetes 集羣，操做系統可採用Ubuntu 16.x與CentOS 7.x：linux

IP Address	Role	CPU	Memory
172.16.35.12	master1	1	2G
172.16.35.10	node1	1	2G
172.16.35.11	node2	1	2G

這邊 master 爲主要控制節點也是部署節點，node 爲應用程序工做節點。
全部操做所有用root使用者進行，以 SRE 來講不推薦。
能夠下載 Vagrantfile 來創建 Virtual box 虛擬機集羣。

首先安裝前要確認如下幾項都已將準備完成：nginx

全部節點彼此網絡互通，而且master1 SSH 登入其餘節點爲 passwdless。
全部防火牆與 SELinux 已關閉。如 CentOS：

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

全部節點須要設定/etc/host解析到全部主機。

...
172.16.35.10 node1
172.16.35.11 node2
172.16.35.12 master1

全部節點須要安裝Docker或rtk引擎。這邊採用Docker來看成容器引擎，安裝方式以下：

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

不論是在 Ubuntu 或 CentOS 都只須要執行該指令就會自動安裝最新版 Docker。
CentOS 安裝完成後，須要再執行如下指令：git
$ systemctl enable docker && systemctl start docker

編輯/lib/systemd/system/docker.service，在ExecStart=..上面加入：github

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

完成後，從新啓動 docker 服務：docker
$ systemctl daemon-reload && systemctl restart 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

在master1須要安裝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

Etcd

在開始安裝 Kubernetes 以前，須要先將一些必要系統建立完成，其中 Etcd 就是 Kubernetes 最重要的一環，Kubernetes 會將大部分信息儲存於 Etcd 上，來提供給其餘節點索取，以確保整個集羣運做與溝通正常。json

建立集羣 CA 與 Certificates

在這部分，將會須要產生 client 與 server 的各組件 certificates，而且替 Kubernetes admin user 產生 client 證書。bootstrap

創建/etc/etcd/ssl文件夾，而後進入目錄完成如下操做。vim

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

下載ca-config.json與etcd-ca-csr.json文件，併產生 CA 密鑰：

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

下載etcd-csr.json文件，併產生 kube-apiserver certificate 證書：

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

$ ls etcd*.pem
etcd-ca-key.pem  etcd-ca.pem  etcd-key.pem  etcd.pe

若節點 IP 不一樣，須要修改etcd-csr.json的hosts。

完成後刪除沒必要要文件：

$ rm -rf *.json

確認/etc/etcd/ssl有如下文件：

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

Etcd 安裝與設定

首先在master1節點下載 Etcd，並解壓縮放到 /opt 底下與安裝：

$ export ETCD_URL="https://github.com/coreos/etcd/releases/download"
$ cd && wget -qO- --show-progress "${ETCD_URL}/v3.2.9/etcd-v3.2.9-linux-amd64.tar.gz" | tar -zx
$ mv etcd-v3.2.9-linux-amd64/etcd* /usr/local/bin/ && rm -rf etcd-v3.2.9-linux-amd64

完成後新建 Etcd Group 與 User，並創建 Etcd 配置文件目錄：

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

下載etcd相關文件，咱們未來管理 Etcd：

$ export ETCD_CONF_URL="https://kairen.github.io/files/manual-v1.8/master"
$ wget "${ETCD_CONF_URL}/etcd.conf" -O /etc/etcd/etcd.conf
$ wget "${ETCD_CONF_URL}/etcd.service" -O /lib/systemd/system/etcd.service

若與該教程 IP 不一樣的話，請用本身 IP 取代172.16.35.12。

創建 var 存放信息，而後啓動 Etcd 服務:

$ mkdir -p /var/lib/etcd && chown etcd:etcd -R /var/lib/etcd /etc/etcd
$ systemctl enable etcd.service && systemctl start etcd.service

經過簡單指令驗證：

$ export CA="/etc/etcd/ssl"
$ ETCDCTL_API=3 etcdctl \
    --cacert=${CA}/etcd-ca.pem \
    --cert=${CA}/etcd.pem \
    --key=${CA}/etcd-key.pem \
    --endpoints="https://172.16.35.12:2379" \
    endpoint health
# output
https://172.16.35.12:2379 is healthy: successfully committed proposal: took = 641.36µs

Kubernetes Master

Master 是 Kubernetes 的大總管，主要建立apiserver、Controller manager與Scheduler來組件管理全部 Node。本步驟將下載 Kubernetes 並安裝至 master1上，而後產生相關 TLS Cert 與 CA 密鑰，提供給集羣組件認證使用。

下載 Kubernetes 組件

首先經過網絡取得全部須要的執行文件：

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

# Download 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

建立集羣 CA 與 Certificates

在這部分，將會須要生成 client 與 server 的各組件 certificates，而且替 Kubernetes admin user 生成 client 證書。

建立pki文件夾，而後進入目錄完成如下操做。

$ mkdir -p /etc/kubernetes/pki && cd /etc/kubernetes/pki
$ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki"
$ export KUBE_APISERVER="https://172.16.35.12: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 certificate 證書：

$ 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,172.16.35.12,127.0.0.1,kubernetes.default \
  -profile=kubernetes \
  apiserver-csr.json | cfssljson -bare apiserver

$ ls apiserver*.pem
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 上:

$ 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

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 文件：

$ export BOOTSTRAP_TOKEN=$(head -c 16 /dev/urandom | od -An -t x | tr -d ' ')
$ cat <<EOF > /etc/kubernetes/token.csv
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
EOF

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

# bootstrap set-credentials
$ kubectl config set-credentials kubelet-bootstrap \
    --token=${BOOTSTRAP_TOKEN} \
    --kubeconfig=../bootstrap.conf

# bootstrap set-context
$ kubectl config set-context default \
    --cluster=kubernetes \
    --user=kubelet-bootstrap \
   --kubeconfig=../bootstrap.conf

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

若想要用 CA 方式來認證，能夠參考 Kubelet certificate。

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

若節點 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 set default context
$ kubectl config use-context system:kube-scheduler@kubernetes \
    --kubeconfig=../scheduler.conf

Kubelet master certificate

下載kubelet-csr.json文件，並生成 master node certificate 證書：

$ wget "${PKI_URL}/kubelet-csr.json"
$ sed -i 's/$NODE/master1/g' kubelet-csr.json
$ cfssl gencert \
  -ca=ca.pem \
  -ca-key=ca-key.pem \
  -config=ca-config.json \
  -hostname=master1,172.16.35.12,172.16.35.12 \
  -profile=kubernetes \
  kubelet-csr.json | cfssljson -bare kubelet

$ ls kubelet*.pem
kubelet-key.pem  kubelet.pem

這邊$NODE須要隨節點名稱不一樣而改變。

接着經過如下指令生成名稱爲 kubelet.conf 的 kubeconfig 文件：

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

# kubelet set-credentials
$ kubectl config set-credentials system:node:master1 \
    --client-certificate=kubelet.pem \
    --client-key=kubelet-key.pem \
    --embed-certs=true \
    --kubeconfig=../kubelet.conf

# kubelet set-context
$ kubectl config set-context system:node:master1@kubernetes \
    --cluster=kubernetes \
    --user=system:node:master1 \
    --kubeconfig=../kubelet.conf

# kubelet set default context
$ kubectl config use-context system:node:master1@kubernetes \
    --kubeconfig=../kubelet.conf

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

確認/etc/kubernetes與/etc/kubernetes/pki有如下文件：

$ ls /etc/kubernetes/
admin.conf  bootstrap.conf  controller-manager.conf  kubelet.conf  pki  scheduler.conf  token.csv

$ ls /etc/kubernetes/pki
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
admin.pem      apiserver.pem      ca.pem      controller-manager.pem      front-proxy-ca.pem      front-proxy-client.pem      kubelet.pem      sa.pub  scheduler.pem

安裝 Kubernetes 核心組件

首先下載 Kubernetes 核心組件 YAML 文件，這邊咱們不透過 Binary 方案來建立 Master 核心組件，而是利用 Kubernetes Static Pod 來建立，所以需下載全部核心組件的Static Pod文件到/etc/kubernetes/manifests目錄：

$ export CORE_URL="https://kairen.github.io/files/manual-v1.8/master"
$ mkdir -p /etc/kubernetes/manifests && cd /etc/kubernetes/manifests
$ for FILE in apiserver manager scheduler; do
    wget "${CORE_URL}/${FILE}.yml.conf" -O ${FILE}.yml
  done

若IP與教程設定不一樣的話，請記得修改apiserver.yml、manager.yml、scheduler.yml。
apiserver 中的 NodeRestriction 請參考 Using Node Authorization。

生成一個用來加密 Etcd 的 Key：

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

在/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。

下載kubelet.service相關文件來管理 kubelet：

$ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/master"
$ mkdir -p /etc/systemd/system/kubelet.service.d
$ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service
$ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf

最後建立 var 存放信息，而後啓動 kubelet 服務:

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

完成後會須要一段時間來下載鏡像文件與啓動組件，能夠利用該指令來查看：

$ watch netstat -ntlp
tcp        0      0 127.0.0.1:10248         0.0.0.0:*               LISTEN      23012/kubelet
tcp        0      0 127.0.0.1:10251         0.0.0.0:*               LISTEN      22305/kube-schedule
tcp        0      0 127.0.0.1:10252         0.0.0.0:*               LISTEN      22529/kube-controll
tcp6       0      0 :::6443                 :::*                    LISTEN      22956/kube-apiserve

若看到以上信息表示服務正常啓動，若發生問題能夠用docker cli來查看。

完成後，複製 admin kubeconfig 文件，並經過簡單指令驗證：

$ cp /etc/kubernetes/admin.conf ~/.kube/config
$ kubectl get cs
NAME                 STATUS    MESSAGE              ERROR
etcd-0               Healthy   {"health": "true"}
scheduler            Healthy   ok
controller-manager   Healthy   ok

$ kubectl get node
NAME      STATUS     ROLES     AGE       VERSION
master1   NotReady   master    4m        v1.8.2

$ kubectl -n kube-system get po
NAME                              READY     STATUS    RESTARTS   AGE
kube-apiserver-master1            1/1       Running   0          4m
kube-controller-manager-master1   1/1       Running   0          4m
kube-scheduler-master1            1/1       Running   0          4m

確認服務可以執行 logs 等指令：

$ kubectl -n kube-system logs -f kube-scheduler-master1
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 等指令：

$ cd /etc/kubernetes/
$ export URL="https://kairen.github.io/files/manual-v1.8/master"
$ wget "${URL}/apiserver-to-kubelet-rbac.yml.conf" -O apiserver-to-kubelet-rbac.yml
$ kubectl apply -f apiserver-to-kubelet-rbac.yml

# 測試 logs
$ kubectl -n kube-system logs -f kube-scheduler-master1
...
I1031 03:22:42.527697       1 leaderelection.go:184] successfully acquired lease kube-system/kube-scheduler

Kubernetes Node

Node 是主要執行容器實例的節點，可視爲工做節點。在這步驟咱們會下載 Kubernetes binary 文件，並建立 node 的 certificate 來提供給節點註冊認證用。Kubernetes 使用Node Authorizer來提供Authorization mode，這種受權模式會替 Kubelet 生成 API request。

在開始前，咱們先在master1將須要的 ca 與 cert 複製到 Node 節點上：

$ for NODE in node1 node2; do
    ssh ${NODE} "mkdir -p /etc/kubernetes/pki/"
    ssh ${NODE} "mkdir -p /etc/etcd/ssl"
    # Etcd ca and cert
    for FILE in etcd-ca.pem etcd.pem etcd-key.pem; do
      scp /etc/etcd/ssl/${FILE} ${NODE}:/etc/etcd/ssl/${FILE}
    done
    # Kubernetes ca and cert
    for FILE in pki/ca.pem pki/ca-key.pem bootstrap.conf; do
      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
    done
  done

下載 Kubernetes 組件

首先經過網絡取得全部須要的執行文件：

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

# Download 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

設定 Kubernetes node

接着下載 Kubernetes 相關文件，包含 drop-in file、systemd service 檔案等：

$ export KUBELET_URL="https://kairen.github.io/files/manual-v1.8/node"
$ mkdir -p /etc/systemd/system/kubelet.service.d
$ wget "${KUBELET_URL}/kubelet.service" -O /lib/systemd/system/kubelet.service
$ wget "${KUBELET_URL}/10-kubelet.conf" -O /etc/systemd/system/kubelet.service.d/10-kubelet.conf

接着在全部node建立 var 存放信息，而後啓動 kubelet 服務:

$ mkdir -p /var/lib/kubelet /var/log/kubernetes /etc/kubernetes/manifests
$ systemctl enable kubelet.service && systemctl start kubelet.service

P.S. 重複同樣動做來完成其餘節點。

受權 Kubernetes Node

當全部節點都完成後，在master節點，由於咱們採用 TLS Bootstrapping，所須要建立一個 ClusterRoleBinding：

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

在master經過簡單指令驗證，會看到節點處於pending：

$ kubectl get csr
NAME                                                   AGE       REQUESTOR           CONDITION
node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE   2s        kubelet-bootstrap   Pending
node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE   2s        kubelet-bootstrap   Pending

經過 kubectl 來容許節點加入集羣：

$ kubectl get csr | awk '/Pending/ {print $1}' | xargs kubectl certificate approve
certificatesigningrequest "node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE" approved
certificatesigningrequest "node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE" approved

$ kubectl get csr
NAME                                                   AGE       REQUESTOR           CONDITION
node-csr-YWf97ZrLCTlr2hmXsNLfjVLwaLfZRsu52FRKOYjpcBE   30s       kubelet-bootstrap   Approved,Issued
node-csr-eq4q6ffOwT4yqYQNU6sT7mphPOQdFN6yulMVZeu6pkE   30s       kubelet-bootstrap   Approved,Issued

$ kubectl get no
NAME      STATUS     ROLES     AGE       VERSION
master1   NotReady   master    15m       v1.8.2
node1     NotReady   <none>    8m        v1.8.2
node2     NotReady   <none>    6s        v1.8.2

Kubernetes Core Addons 部署

當完成上面全部步驟後，接着咱們須要安裝一些插件，而這些有部分是很是重要跟好用的，如Kube-dns與Kube-proxy等。

Kube-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 證書：

$ export PKI_URL="https://kairen.github.io/files/manual-v1.8/pki"
$ cd /etc/kubernetes/pki
$ wget "${PKI_URL}/kube-proxy-csr.json" "${PKI_URL}/ca-config.json"
$ cfssl gencert \
  -ca=ca.pem \
  -ca-key=ca-key.pem \
  -config=ca-config.json \
  -profile=kubernetes \
  kube-proxy-csr.json | cfssljson -bare kube-proxy

$ ls kube-proxy*.pem
kube-proxy-key.pem  kube-proxy.pem

接着透過如下指令生成名稱爲 kube-proxy.conf 的 kubeconfig 文件：

# kube-proxy set-cluster
$ kubectl config set-cluster kubernetes \
    --certificate-authority=ca.pem \
    --embed-certs=true \
    --server="https://172.16.35.12:6443" \
    --kubeconfig=../kube-proxy.conf

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

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

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

完成後刪除沒必要要文件：

$ rm -rf *.json

確認/etc/kubernetes有如下文件：

$ ls /etc/kubernetes/
admin.conf        bootstrap.conf           encryption.yml  kube-proxy.conf  pki             token.csv
audit-policy.yml  controller-manager.conf  kubelet.conf    manifests        scheduler.conf

在master1將kube-proxy相關文件複製到 Node 節點上：

$ for NODE in node1 node2; do
    for FILE in pki/kube-proxy.pem pki/kube-proxy-key.pem kube-proxy.conf; do
      scp /etc/kubernetes/${FILE} ${NODE}:/etc/kubernetes/${FILE}
    done
  done

完成後，在master1經過 kubectl 來建立 kube-proxy daemon：

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"
$ mkdir -p /etc/kubernetes/addons && cd /etc/kubernetes/addons
$ wget "${ADDON_URL}/kube-proxy.yml.conf" -O kube-proxy.yml
$ kubectl apply -f kube-proxy.yml
$ kubectl -n kube-system get po -l k8s-app=kube-proxy
NAME               READY     STATUS    RESTARTS   AGE
kube-proxy-bpp7q   1/1       Running   0          47s
kube-proxy-cztvh   1/1       Running   0          47s
kube-proxy-q7mm4   1/1       Running   0          47s

Kube-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 便可：

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"
$ wget "${ADDON_URL}/kube-dns.yml.conf" -O kube-dns.yml
$ kubectl apply -f kube-dns.yml
$ kubectl -n kube-system get po -l k8s-app=kube-dns
NAME                        READY     STATUS    RESTARTS   AGE
kube-dns-6cb549f55f-h4zr5   0/3       Pending   0          40s

Calico Network 安裝與設定

Calico 是一款純 Layer 3 的數據中心網絡方案(不須要 Overlay 網絡)，Calico 好處是他已與各類雲原平生臺有良好的整合，而 Calico 在每個節點利用 Linux Kernel 實現高效的 vRouter 來負責數據的轉發，而當數據中心複雜度增長時，能夠用 BGP route reflector 來達成。

首先在master1經過 kubectl 創建 Calico policy controller：

$ export CALICO_CONF_URL="https://kairen.github.io/files/manual-v1.8/network"
$ wget "${CALICO_CONF_URL}/calico-controller.yml.conf" -O calico-controller.yml
$ kubectl apply -f calico-controller.yml
$ kubectl -n kube-system get po -l k8s-app=calico-policy
NAME                                        READY     STATUS    RESTARTS   AGE
calico-policy-controller-5ff8b4549d-tctmm   0/1       Pending   0          5s

在master1下載 Calico CLI 工具：

$ wget https://github.com/projectcalico/calicoctl/releases/download/v1.6.1/calicoctl
$ chmod +x calicoctl && mv calicoctl /usr/local/bin/

而後在全部節點下載 Calico，並執行如下步驟：

$ export CALICO_URL="https://github.com/projectcalico/cni-plugin/releases/download/v1.11.0"
$ wget -N -P /opt/cni/bin ${CALICO_URL}/calico
$ wget -N -P /opt/cni/bin ${CALICO_URL}/calico-ipam
$ chmod +x /opt/cni/bin/calico /opt/cni/bin/calico-ipam

接着在全部節點下載 CNI plugins配置文件，以及 calico-node.service：

$ mkdir -p /etc/cni/net.d
$ export CALICO_CONF_URL="https://kairen.github.io/files/manual-v1.8/network"
$ wget "${CALICO_CONF_URL}/10-calico.conf" -O /etc/cni/net.d/10-calico.conf
$ wget "${CALICO_CONF_URL}/calico-node.service" -O /lib/systemd/system/calico-node.service

若部署的機器是使用虛擬機，如 Virtualbox 等的話，請修改calico-node.service文件，並在IP_AUTODETECTION_METHOD(包含 IP6)部分指定綁定的網卡，以免默認綁定到 NAT 網絡上。

以後在全部節點啓動 Calico-node:

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

在master1查看 Calico nodes:

$ cat <<EOF > ~/calico-rc
export ETCD_ENDPOINTS="https://172.16.35.12: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 get node -o wide
NAME      ASN       IPV4              IPV6
master1   (64512)   172.16.35.12/24
node1     (64512)   172.16.35.10/24
node2     (64512)   172.16.35.11/24

查看 pending 的 pod 是否已執行：

$ kubectl -n kube-system get po
NAME                                        READY     STATUS    RESTARTS   AGE
calico-policy-controller-5ff8b4549d-tctmm   1/1       Running   0          4m
kube-apiserver-master1                      1/1       Running   0          20m
kube-controller-manager-master1             1/1       Running   0          20m
kube-dns-6cb549f55f-h4zr5                   3/3       Running   0          5m
kube-proxy-fnrkb                            1/1       Running   0          6m
kube-proxy-l72bq                            1/1       Running   0          6m
kube-proxy-m6rfw                            1/1       Running   0          6m
kube-scheduler-master1                      1/1       Running   0          20m

最後若想省事，能夠直接用 Standard Hosted 方式安裝。

Kubernetes Extra Addons 部署

本節說明如何部署一些官方經常使用的 Addons，如 Dashboard、Heapster 等。

Dashboard addon

Dashboard 是 Kubernetes 社區官方開發的儀表板，有了儀表板後管理者就可以透過 Web-based 方式來管理 Kubernetes 集羣，除了提高管理方便，也讓資源可視化，讓人更直覺看見系統信息的呈現結果。

首先咱們要創建kubernetes-dashboard-certs，來提供給 Dashboard TLS 使用：

$ mkdir -p /etc/kubernetes/addons/certs && cd /etc/kubernetes/addons
$ openssl genrsa -des3 -passout pass:x -out certs/dashboard.pass.key 2048
$ openssl rsa -passin pass:x -in certs/dashboard.pass.key -out certs/dashboard.key
$ openssl req -new -key certs/dashboard.key -out certs/dashboard.csr -subj '/CN=kube-dashboard'
$ openssl x509 -req -sha256 -days 365 -in certs/dashboard.csr -signkey certs/dashboard.key -out certs/dashboard.crt
$ rm certs/dashboard.pass.key
$ kubectl create secret generic kubernetes-dashboard-certs\
    --from-file=certs -n kube-system

接着在master1經過 kubectl 來創建 kubernetes dashboard 便可：

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"
$ wget ${ADDON_URL}/kube-dashboard.yml.conf -O kube-dashboard.yml
$ kubectl apply -f kube-dashboard.yml
$ kubectl -n kube-system get po,svc -l k8s-app=kubernetes-dashboard
NAME                                      READY     STATUS    RESTARTS   AGE
po/kubernetes-dashboard-747c4f7cf-md5m8   1/1       Running   0          56s

NAME                       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
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/

Heapster addon

Heapster 是 Kubernetes 社區維護的容器集羣監控分析工具。Heapster 會從 Kubernetes apiserver 得到全部 Node 信息，而後再經過這些 Node 來得到 kubelet 上的數據，最後再將全部收集到數據送到 Heapster 的後臺儲存 InfluxDB，最後利用 Grafana 來抓取 InfluxDB 的數據源來進行可視化。

在master1經過 kubectl 來建立 kubernetes monitor 便可：

$ export ADDON_URL="https://kairen.github.io/files/manual-v1.8/addon"
$ wget ${ADDON_URL}/kube-monitor.yml.conf -O kube-monitor.yml
$ kubectl apply -f kube-monitor.yml
$ 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，https://172.16.35.12:6443/api/v1/proxy/namespaces/kube-system/services/monitoring-grafana

簡單部署 Nginx 服務

Kubernetes 能夠選擇使用指令直接建立應用程序與服務，或者撰寫 YAML 與 JSON 檔案來描述部署應用程序的配置，如下將建立一個簡單的 Nginx 服務：

$ kubectl run nginx --image=nginx --port=80
$ kubectl expose deploy nginx --port=80 --type=LoadBalancer --external-ip=172.16.35.12
$ kubectl get svc,po
NAME             TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
svc/kubernetes   ClusterIP      10.96.0.1       <none>         443/TCP        1h
svc/nginx        LoadBalancer   10.97.121.243   172.16.35.12   80:30344/TCP   22s

NAME                        READY     STATUS    RESTARTS   AGE
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

擴展服務數量

若集羣node節點增長了，而想讓 Nginx 服務提供可靠性的話，能夠經過如下方式來擴展服務的副本：

$ kubectl scale deploy nginx --replicas=2

$ kubectl get pods -o wide
NAME                    READY     STATUS    RESTARTS   AGE       IP             NODE
nginx-158599303-0h9lr   1/1       Running   0          25s       10.244.100.5   node2
nginx-158599303-k7cbt   1/1       Running   0          1m        10.244.24.3    node1

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。