k8s手工安装-阿里云开发者社区

k8s节点介绍

master：主要负责管理k8s的所有node

etcd：保存了整个集群的状态
apiserver：提供了资源操作的唯一入口，并且提供认证、授权、访问控制、api注册和发现等机制
scheduler负责资源的调度，按照预定的调度策略将pod调度到相应的机器上
controller manager负责维护集群的状态，比如故障检测，自动扩展，滚动更新等

node：主要执行容器实例的节点，可视为工作节点。

kubelet：负责维护容器的生命周期，同时也负责Volume（CVI）和网络（CNI）的管理；
kube-proxy负责为Service提供cluster内部的服务发现和负载均衡；

安装前

k8s在网上有许多的云端平台与操作系统的安装方式。如果通过手工安装来部署，将有利于我们更加了解k8s的流程。

IP address	Role	CPU	Memory
192.168.0.102	master	1	2G
192.168.0.103	node1	1	2G
192.168.0.104	node2	1	2G

这边master节点为主要的控制节点，同时它也是部署节点
node为应用程序工作节点

首先安装前要确认：

所有节点之间实现免密码访问
所有防火墙与selinux已关闭
所有节点需要设定/etc/hosts 解析到所有主机
所有节点需要安装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

在master节点需要安装CFSSL工具，这将会用来建立TLS certificate

$ 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

k8s会把大部分信息存储在Etcd上，来供其他节点索取，以确保这个集群运作与沟通正常。

创建集群 CA 与 Certificates

在这部分，将会需要产生 client 与 server 的各组件 certificates，并且替 Kubernetes admin user 产生 client 证书。

在master主机上建立/etc/etcd/ssl文件夹，然后进入目录完成以下操作。

$ 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.pem

若节点 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 安装与设定

首先在master节点下载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填入

建立 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://192.168.0.102:2379" \
 endpoint health

https://192.168.0.102:2379 is healthy: successfully committed proposal: took = 641.36µs

Master

Master主要创建apiserver、Controller manager与Scheduler来组件管理所有 Node

下载 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 -xvf

创建集群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://1792.168.0.102: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

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

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

下载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

由于通过手动创建 CA 方式太过繁杂，只适合少量机器，因为每次签证时都需要绑定 Node IP，随机器增加会带来很多困扰，因此这边使用 TLS Bootstrapping 方式进行授权，由 apiserver 自动给符合条件的 Node 发送证书来授权加入集群。

主要做法是 kubelet 启动时，向 kube-apiserver 传送 TLS Bootstrapping 请求，而 kube-apiserver 验证 kubelet 请求的 token 是否与设定的一样，若一样就自动产生 kubelet 证书与密钥。

首先建立一个变量来产生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

下载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

下载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

若节点 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-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-csr.json文件，并生成 master node certificate 证书：

$ wget "${PKI_URL}/kubelet-csr.json" $ sed -i 's/$NODE/master/g' kubelet-csr.json $ cfssl gencert \
 -ca=ca.pem \
 -ca-key=ca-key.pem \
 -config=ca-config.json \
 -hostname=master,192.168.0.102,192.168.0.102 \
 -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 不是通过 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

安装k8s核心组件

首先下载 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。

生成一个用来加密 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

在/etc/kubernetes/目录下，创建audit-policy.yml的进阶审核策略 YAML 文件：

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

下载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

完成后，复制 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-master
...
I1031 03:22:42.527697 1 leaderelection.go:184] successfully acquired lease kube-system/kube-scheduler

k8s node

在开始前，我们先在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 相关文件，包含 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

用一样的动作来完成其他节点

当所有节点都完成后，在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
master NotReady master 15m v1.8.2
node1 NotReady <none> 8m v1.8.2
node2 NotReady <none> 6s v1.8.2

这样就完成了k8s集群的部署

Kubernetes Core Addons 部署

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

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

首先在master下载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

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

安装只需要在master通过 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

部署

k8s可以通过指令直接创建应用程序和服务，也可以通过YAML或JSON档案来描述部署应用程序的配置。

以下将创建一个简单的 Nginx 服务：

$ kubectl run nginx --image=nginx --port=80 $ kubectl expose deploy nginx --port=80 --type=LoadBalancer --external-ip=192.168.0.102 $ 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 192.168.0.102 80:30344/TCP 22s

NAME READY STATUS RESTARTS AGE
po/nginx-7cbc4b4d9c-7796l 1/1 Running 0 28s 192.160.57.181 ,192.168.0.102 80:32054/TCP 21s

这边type可以选择 NodePort 与 LoadBalancer，在本地裸机部署，两者差异在于NodePort只映射 Host port 到 Container port，而LoadBalancer则继承NodePort额外多出映射 Host target port 到 Container port。

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

$ kubectl scale deploy nginx --replicas=2

本文转移开源中国- k8s手工安装

k8s手工安装

k8s节点介绍

安装前

部署etcd

创建集群 CA 与 Certificates

Etcd 安装与设定

Master

下载 Kubernetes 组件

创建集群ca与certificates

安装k8s核心组件

k8s node

下载 Kubernetes 组件

Kubernetes Core Addons 部署

部署

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

k8s手工安装

k8s节点介绍

安装前

部署etcd

创建集群 CA 与 Certificates

Etcd 安装与设定

Master

下载 Kubernetes 组件

创建集群ca与certificates

安装k8s核心组件

k8s node

下载 Kubernetes 组件

Kubernetes Core Addons 部署

部署

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像