一、Kubernets简介

Kubernetes是一个稳定高效的开源平台，帮助您确保这些容器化应用程序随时随地运行，并帮助他们找到工作所需的资源和工具。协调一个高度可用的计算机集群，而Kubernets就是将底层的计算资源连接在一起，对外体现为一个高可用的计算机集群。主要是为容器进行集群的一些自动化操作，可以实现容器集群的自动化部署、自动扩缩容、维护等功能。而简称K8s来源就是将8个字母“ubernete”替换为“8”的缩写。

简析Dokcer容器

传统的应用部署方式是通过插件或脚本来安装应用。这样做的缺点是应用的运行、配置、管理、所有生存周期将与当前操作系统绑定，这样做并不利于应用的升级更新/回滚等操作，也有的应用是通过创建虚机的方式来实现的，但是虚拟机非常重，并不易进行移植操作。

新的方式是通过部署容器方式实现，每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。相对于虚拟机，容器能快速部署，由于容器与底层设施、机器文件系统解耦的，所以它能在不同云、不同版本操作系统间进行迁移。

容器占用资源少、部署快，每个应用可以被打包成一个容器镜像，每个应用与容器间成一对一关系也使容器有更大优势，使用容器可以在build或release 的阶段，为应用创建容器镜像，因为每个应用不需要与其余的应用堆栈组合，也不依赖于生产环境基础结构，这使得从研发到测试、生产能提供一致环境。
容器比虚机相比，量级变轻、操作更透明，这更便于监控和管理。

主要功能

Kubernetes能提供一个以“容器为中心的基础架构”，满足在生产环境中运行应用的一些常见需求，如：

1. 多个进程（作为容器运行）协同工作。
2. 应用健康检测、实例的复制
3. 对Pod自动伸缩/扩展
4. 负载均衡
5. 资源监控、日志访问
6. 调试应用程序、提供认证和授权

工作流程

有两种服务器，一个Master主服务器，一个Node节点服务区。其中Master 负责集群的管理，协调集群中的所有行为/活动，例如应用的运行、修改、更新等，下发指令给node执行。

Node节点作为Kubernetes集群中的工作节点。每个node上都有一个Kubelet，用于管理node节点与Kubernetes Master通信。每个Node节点上至少还要运行container runtime（一个容器比如docker或者rkt）。

在Kubernetes上部署应用程序时，会先通知master启动容器中的应用程序，master调度容器在集群的节点上运行，数据就是客户端通过kubectl发请求给主服务器的API，然后API把请求存放在etcd中，让scheduler调度分配这个请求给哪个node服务器，然后将服务下发到node中的kubelet，再被传递到pod中的一个容器中，最后通过kube-proxy网络代理进行tcp转发到互联网中。

二、Kubernets核心

Kubernets集群架构有两个部分组成，一个是Master服务器，主要提供整个集群的管理控制中心，一个是节点node服务器，提供Kubernetes运行时的环境，以及负责维护Pod。

Master 服务器

里面包括一些功能模块，主要作用是管理集群：

kube-apiserver

用于暴露Kubernetes API，任何的资源请求/调用操作都是通过kube-apiserver提供的接口进行的。

etcd

是一致且高可用的键值存储，也是Kubernetes提供默认的分布式存储系统，保存所有集群数据，使用时必须为etcd数据提供备份计划。

kube-controller-manager

是运行管理控制器，他是集群中处理常规任务的后台进程，并且把所有的控制器合并编译到一个二进制文件中，在单个进程中执行。

Replication Controller

负责管理维护，保证Replication Controller定义的副本数量与实际运行Pod数量一致，多了就删掉，不够就创建出来备用。

Node服务器

里面的模块主要是提供具体的服务，以及对容器的直接操作：

kubelet

在每个节点上运行的主要 “节点代理”。kubelet 以 Pod 为单位来运行任务。 kubelet 运行多种机制（主要通过 apiserver）提供的一组 Pod，并确保这些 Pods 中描述的容器健康运行。 不是 Kubernetes 创建的容器将不在 kubelet 的管理范围。docker用于运行容器，而RKT运行容器，作为docker工具的替代方案。

supervisord

是一个轻量级的监控系统，用于保障kubelet和docker的正常的运行。

Kubernetes

在每个节点上运行网络代理。这反映每个节点上 Kubernetes API 中定义的服务，并且可以做简单的TCP和UDP流转发。

Pod含义

一个pod就是一组 一个或多个的容器（如Docker容器），具有共享存储/网络，以及如何运行容器的规范。pod的内容始终位于同一位置并共同调度，并在共享上下文中运行。pod模拟特定于应用程序的“逻辑主机” - 它包含一个或多个相对紧密耦合的应用程序容器 - 在预容器世界中，在同一物理或虚拟机上执行意味着在同一逻辑主机上执行。而Container(容器)，可以理解为pod里面的一个组成部分。

三、Kubernets搭建

本次搭建接受的是三主五从的架构模型，其中比较核心的两个操作，一个是kubeadm init，一个是kubeadm join，这两个操作很容易出错。本次搭建使用的kubeadm工具，而kubeadm作为Kubernetes官方提供的集群部署管理工具，采用“一键式”指令进行集群的快速初始化和安装，极大地简化了部署过程，消除了集群安装的痛点。

1. 环境准备

1.0 集群架构设计，3个主服务器Master1-3，5个节点服务器Worker1-5，Master制作HA高可用集群，解决单点故障，Worker运行pod节点提供服务(Kubernetes集群会通过创建副本集自动实现高可用)。

1.1 部署DNS解析，本次集群小，所以采用修改各个主机的/etc/hosts信息，让每个服务器都可以通过其他服务器的主机名解析到他的IP地址信息。

1.2 给所有服务器配置：停防火墙、关闭Swap、关闭Selinux。

1.3 给所有服务器配置k8s的yum源，方便下载，官方下载渠道为：google官网链接，
国内有个阿里的yum源可以使用：阿里链接

将其加入到/etc/yum.repos.d/下的一个自定义的配置文件，方便下载相关组件。

1.4 所有服务器配置NTP时间同步，所有服务器的时间都是同一的我采用的是阿里的一个公开的NTP服务器：ntp1.aliyun.com 。

1.5 开启linux的路由功能，以及网桥的防火墙功能

cat <<EOF >  /etc/sysctl.d/k8s.conf
vm.swappiness = 0
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
modprobe br_netfilter
sysctl -p /etc/sysctl.d/k8s.conf

2. 为三个主服务器搭建高可用

使用keepalived给三个主服务器创建VIP，并可以根据服务器状态进行滑动，保证主控制服务器的高效稳定，而监控服务也可以保证稳定性。

基本搭建流程：

2.1 安装keepalived，可以直接yum安装。

2.2 修改配置文件/etc/keepalived/keepalived.conf，设置好IP、VIP信息，主从关系等，并添加k8s监控脚本模块：

vrrp_script CheckK8sMaster {
    script "curl -k https://VIP:6443"
    interval 3
    timeout 9
    fall 2
    rise 2
}

2.3 启动服务并检查vip是否成功绑定

3. 创建集群所需的证书

集群中的验证是使用证书进行的，而k8s使用的证书是cfssl，这个步骤只需要在主服务器上执行即可，我们采取的思路是在一个主服务器上创建秘钥文件，然后发布到其他服务器中下面是部署步骤：

3.0 创建一个专属于证书的工作目录，方便管理。

3.1 前往cfssl官网下载部署脚本。

wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64

3.2 给脚本赋予执行权限，再放入系统环境变量中并把后缀删去，这样执行比较方便。

3.3 创建CA证书，手动撰写两个json文ca-config.json、ca-csr.json

然后用脚本创建cfssl gencert -initca ca-csr.json | cfssljson -bare ca

cat >  ca-config.json <<EOF
{
"signing": {
"default": {
  "expiry": "8760h"
},
"profiles": {
  "kubernetes-Soulmate": {
    "usages": [
        "signing",
        "key encipherment",
        "server auth",
        "client auth"
    ],
    "expiry": "8760h"
  }
}
}
}
EOF

cat >  ca-csr.json <<EOF
{
"CN": "kubernetes-Soulmate",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
  "C": "CN",
  "ST": "shanghai",
  "L": "shanghai",
  "O": "k8s",
  "OU": "System"
}
]
}
EOF

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

cat > etcd-csr.json <<EOF
{
  "CN": "etcd",
  "hosts": [
    "127.0.0.1",
    "Master1IP",
    "Master2IP",
    "Master3IP"
  ],
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "CN",
      "ST": "shanghai",
      "L": "shanghai",
      "O": "k8s",
      "OU": "System"
    }
  ]
}
EOF

3.4 创建和etcd连接的文件etcd-csr.json：

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

3.5 将秘钥放到etcd中，由这个分布式存储负责存储和使用，再把必要发布给其他的主服务器：

cp -f etcd.pem etcd-key.pem ca.pem /etc/etcd/ssl/
scp -r /etc/etcd/ssl/*.pem Master2IP:/etc/etcd/ssl/

4. 创建etcd

etcd是Kubernetes集群中的一个十分重要的组件，用于保存集群所有的网络配置和对象的状态信息，其中flannel网路信息、k8s的对象都是存储在这里面的。

4.0 确保证书已经部署到位，每个主服务器间。

4.1 装包，直接使用yum安装即可。

4.2 添加一个systemctl的脚本文件，然后每个机器启动服务。

cat <<EOF >/etc/systemd/system/etcd.service
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
Documentation=https://github.com/coreos

[Service]
Type=notify
WorkingDirectory=/var/lib/etcd/
ExecStart=/usr/bin/etcd \\
  --name $HOSTNAME \\
  --cert-file=/etc/etcd/ssl/etcd.pem \\
  --key-file=/etc/etcd/ssl/etcd-key.pem \\
  --peer-cert-file=/etc/etcd/ssl/etcd.pem \\
  --peer-key-file=/etc/etcd/ssl/etcd-key.pem \\
  --trusted-ca-file=/etc/etcd/ssl/ca.pem \\
  --peer-trusted-ca-file=/etc/etcd/ssl/ca.pem \\
  --initial-advertise-peer-urls https://$(ifconfig eth0 | grep inet | awk '{print $2}' | head -1):2380 \\
  --listen-peer-urls https://$(ifconfig eth0 | grep inet | awk '{print $2}' | head -1):2380 \\
  --listen-client-urls https://$(ifconfig eth0 | grep inet | awk '{print $2}' | head -1):2379,http://127.0.0.1:2379 \\
  --advertise-client-urls https://$(ifconfig eth0 | grep inet | awk '{print $2}' | head -1):2379 \\
  --initial-cluster-token etcd-cluster-0 \\
  --initial-cluster etcd集群服务器名字1=https://其IP:2380, etcd集群服务器名字2=https://其IP:2380\\
  --initial-cluster-state new \\
  --data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

4.3 用systemcl启动etcd服务，等每个服务器启动服务成功，使用下面命令启动etcd集群分布存储：

etcdctl --endpoints=https://Master1IP:2379,\
https://Master2IP:2379,https://Master3IP:2379 \
  --ca-file=/etc/etcd/ssl/ca.pem \
  --cert-file=/etc/etcd/ssl/etcd.pem \
  --key-file=/etc/etcd/ssl/etcd-key.pem  cluster-health

#####附：启动etcd可能会出问题，最大可能是证书验证出现问题，不到集群中，解决方案是：重装 --> 重生成 --> 重部署 --> 重新启动。

1. 用yum 重新安装一下etcd。
2. 重新再一个主服务器上生成一个新证书。
3. 把这个证书覆盖发布到其他主服务器中。
4. 再重启动etcd即可。

5. 部署docker

容器docker是Kubernets中非常重要的基本元素，所有服务都是在这里部署好上线的，下面是最基础的搭建。

5.1 安装docker，使用yum安装即可，只不过yum源需要自己找，下面是我本次是用的docker官网。

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 如果不是13.1版本，不支持最新的docker，只能用低一点的18.06版本
yum install -y docker-ce-18.06.0.ce

5.2 使用systemctl启动docker即可开始使用docker。

5.3 到阿里云中下载需要的镜像并修改好名字，为Kubernetes的搭建准备好，主要是google的镜像都被屏蔽了。(如果在Kubernetes的kubeadm启动yaml文件中指定了镜像源，这一步可以不做)

docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-proxy:v1.13.1
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.13.1
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-controller-manager:v1.13.1
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler:v1.13.1
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.2.6
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/etcd:3.2.24

docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.13.1 k8s.gcr.io/kube-apiserver:v1.13.1
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/kube-proxy:v1.13.1 k8s.gcr.io/kube-proxy:v1.13.1
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/kube-controller-manager:v1.13.1 k8s.gcr.io/kube-controller-manager:v1.13.1
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler:v1.13.1 k8s.gcr.io/kube-scheduler:v1.13.1
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.2.6 k8s.gcr.io/coredns:1.2.6
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1 k8s.gcr.io/pause:3.1
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/etcd:3.2.24 k8s.gcr.io/etcd:3.2.24

docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/kube-proxy:v1.13.1
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/kube-apiserver:v1.13.1
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/kube-controller-manager:v1.13.1
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/kube-scheduler:v1.13.1
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/coredns:1.2.6
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.1
docker image rm registry.cn-hangzhou.aliyuncs.com/google_containers/etcd:3.2.24

6. 安装配置kubeadm

前半部分都可以理解为在为集群部署环境，下面就是安装Kubernets服务了，这个需要所有服务器都做，步骤如下：

6.1 安装基本组件的包：kubelet、kubeadm、kubectl，这次我使用的是1.10版本：
yum install -y kubelet kubeadm kubectl

6.2 修改启动脚本文件/etc/systemd/system/kubelet.service.d/10-kubeadm.conf。

修改这里面的环境变量，然后让systemctl重新加载一下，并把kubelet设置为开机自启动(不设置也可以，只是在启动集群的时候会有一个警告)。

6.3 初始化集群，先做第一个主服务器，然后后面部署到其他主服务器上即可，书写一个初始化的yaml文件 config.yaml(位置不限)。

6.4 启动kubelet：systemctl restart kubelet 但是启动不会报错，但是查看状态会发现其失败状态，不过必须要做这一步，不然集群起不来。

6.5 根据初始化文件启动集群：kubeadm init --config config.yaml，
这个yaml文件在官网有模板，拿来修改即可。

写完模板后执行初始化，这一步出故障的可能性很大，可能是端口一直开不起来然后系统一直循环卡死，也可能是因为kubelet有问题，也可能是etcd的证书部署有问题，导致etcd服务突然猝死。

####总的解决方案是：

1. 在开始启动初始化的时候，打开另一个终端查看：tail -f /vat/log/messages，如果发现运行1-2分钟后还没成功，就观察日志是否循环出现几个一样的报错，某IP的6443端口不存在，那就终止初始化，进行排错。
2. 如果初始化报错退出，就开始排错，排错第一步，重启所有主服务器的etcd服务，看这个服务集群是否出现猝死，如果起不来就重新搭建，从证书开始。
3. 排错第二步，检查初始化文件是否有问题，完成修改。
4. 再次尝试初始化，只不过，这次初始化，必须先重置一次kubeadm reset(这个命令会删除很多文件，一般执行后所有kubeadm的所有操作都要重新做一次)，然后重新尝试初始化。
5. 执行结束后，终端返回一些成功信息，其中最后一行有一个很长的命令。
   这文件的格式大致是：kubeadm join IP:6443 --token 字符串 --discovery-token-ca-cert-hash 哈希值这就是节点加入的命令，在第九步会用到。

6.6 在初始化成功后，终端会返回下面要做的三个命令，执行下面这三个即可：

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

6.7 配置启发服务器，将第一个完成所有配置的主服务器的pki的公钥信息发布出去：

scp -r /etc/kubernetes/pki  Master2IP:/etc/kubernetes/
scp -r /etc/kubernetes/pki  Master3IP:/etc/kubernetes/

然后即可初始化，和6.5一样：

kubeadm init --config config.yaml
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

所以排错思路也差不多，和第五步差不多，但是有一个特殊点必须要注意，在排错中一旦使用kubeadm reset，就要重新部署公钥信息，因为这个命令会删除这些东西，所以要重新部署一次再初始化。

7. 部署pod网络

flannel网络

有两个选择，一个是比较简单的flannel的搭建方法：Flannel为每个host分配一个subnet，容器从这个subnet中分配IP，这些IP可以在host间路由，容器间无需使用nat和端口映射即可实现跨主机通信，flannel使用etcd存放网络配置、已分配的subnet、host的IP等信息。这也只需要在一个主服务器上做，到后面一起部署到其他主服务器上。

7.1.1下载yaml文件，确保上面集群部署正常：
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

7.1.2 用kubectl命令执行即可：
kubectl create -f kube-flannel.yml

7.1.3 查看是否部署成功，通过命令查看网络信息，看有没有flannel.1这个虚拟网络，然后可以通过kubectl get nodes查看节点信息。

calico网络

另一个是calico，这个相对复杂一些，需要借助weave插件，calico的原理就是，将pod以自己的ClusterIP发出包进行一次打包，在上面用自己的真实IP封装再发包。然后会在每个机器的路由表中，写上每个node节点的nodeIP所在网段的路由，然后通过隧道进行数据传递。

7.2.1 直接从官网获取weave和rbac的yaml文件导入Kubernetes集群中，为calico准备环境

kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
kubectl apply -f https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/rbac.yaml

7.2.2 下载官方calico的yaml文件，进行修改

curl https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/hosted/calico.yaml -O

sed -i 's@.*etcd_endpoints:.*@\ \ etcd_endpoints:\ \"https://etcd的IP1:2379,https://etcd的IP2:2379\"@gi' calico.yaml

export ETCD_CERT=`cat /etc/etcd/ssl/etcd.pem | base64 | tr -d '\n'`
export ETCD_KEY=`cat /etc/etcd/ssl/etcd-key.pem | base64 | tr -d '\n'`
export ETCD_CA=`cat /etc/etcd/ssl/ca.pem | base64 | tr -d '\n'`

sed -i "s@.*etcd-cert:.*@\ \ etcd-cert:\ ${ETCD_CERT}@gi" calico.yaml
sed -i "s@.*etcd-key:.*@\ \ etcd-key:\ ${ETCD_KEY}@gi" calico.yaml
sed -i "s@.*etcd-ca:.*@\ \ etcd-ca:\ ${ETCD_CA}@gi" calico.yaml

sed -i 's@.*etcd_ca:.*@\ \ etcd_ca:\ "/calico-secrets/etcd-ca"@gi' calico.yaml
sed -i 's@.*etcd_cert:.*@\ \ etcd_cert:\ "/calico-secrets/etcd-cert"@gi' calico.yaml
sed -i 's@.*etcd_key:.*@\ \ etcd_key:\ "/calico-secrets/etcd-key"@gi' calico.yaml

sed -i 's@192.168.0.0/16@想改的vip网段/子网掩码@' calico.yaml
kubectl apply -f calico.yaml

7.2.3 因为使用了外部etcd，所以我们还要导入一个calico-node的yaml文件

wget https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/manifests/app-layer-policy/etcd/calico-networking/calico-node.yaml
sed -i 's@192.168.0.0/16@上面改的vip网段/子网掩码@' calico-node.yaml

8. 部署dashboard、heapster

dashboard实质上是一个仪表盘，一个前端页面，将页面可观的呈现出来，heapster是监控服务，检测集群健康性，两个结合起来可以组成一个作为有个监控前端。

8.1 下载并修改一个kubernetes-dashboard.yaml文件，并创建和生成登录口令：

wget https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml
kubectl create -f kubernetes-dashboard.yaml
kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}')
# 查看口令密码的命令为：
kubectl -n kube-system describe $(kubectl -n kube-system get secret -n kube-system -o name | grep namespace) | grep token

8.2 配置heapster需要书写4个yaml文件 (可以单独存在一个目录中grafana.yaml、 heapster.yaml、influxdb.yaml、influxdb-service.yaml)。

wget https://github.com/kubernetes/heapster/archive/v1.3.0.zip 
unzip v1.3.0.zip

然后修改里面的yaml文件，进行安装创建的操作：kubectl create -f .

8.3 开启主服务器的pod功能，然后查看信息看看monitor模块开启情况，不过可能一开始是载入中，需要点时间才能准备好。

kubectl taint nodes --all node-role.kubernetes.io/master-
kubectl get pods --all-namespaces

9. 添加节点服务器

在运行初始化的时候有一个加入这个集群的命令，只需要在预备添加的节点服务器上运行即可，添加后可以用命令查看集群节点的状态：kubectl get nodes

本次我部署的集群添加节点的命令是：

kubeadm join Master1IP:6443 --token b99a00.a144ef80536d4344 --discovery-token-ca-cert-hash \
sha256:e16e7644d0d9bb9655f9579eb5f985a97735c410a83c9a4132e9a5ea255758f9

10. 部署Prometheus-Grafana监控

作为市场上常用的Prometheus监控插件，和泛用极广的grafana前端插件，两者结合可以提供一个非常完美的前端监控，下面是具体的操作，我讲其nodeIP设置在30002-30004，方便安全组的设立

git clone https://github.com/redhatxl/k8s-prometheus-grafana.git
cd k8s-prometheus-grafana
sed -i 's/31672/30002/' node-exporter.yaml
kubectl apply -f node-exporter.yaml
cd prometheus
kubectl apply -f .
cd ../grafana/
sed -i '/port:/a\      nodePort: 30004' grafana-svc.yaml
kubectl apply -f .

四、全新服务器加入集群的操作

除了一开始部署的那几个服务器，后面需要添加的话，也可以实现。

1. 安装docker：

   这是第一步也是最关键的一步，因为节点就是依赖docker然后进行提供服务的一个职能，所以要先安装并配置好docker，可以参考上面的第五步。

2. 安装Kubernets组件

3. 安装基本组件的包：kubelet、kubeadm、kubectl，这次我使用的是1.13版本。
   yum install -y kubelet kubeadm kubectl，

4. 使用systemctl启动服务。

5. 作为节点服务器添加进入集群

   这个步骤就和上面第九步一样，添加进去后，可以使用命令查看，也可以查看监控页面内，不过可能一开始是false，等一会即可。

五、Kubernetst 踩过的坑

1. 内部使用的DNS在数据传递默认使用UDP协议

在云中搭建，我们一定会设立安全组，这时候要注意，对内网最好TCP和UDP的所有端口开放信任，不然会导致数据包发出却收不到。

2. etcd显示active，但实际上集群出现了问题

在一次测试搭建中，我kubeadm init一直失败，后来发现etcd的status虽然是active，但是集群是失败的，重启etcd的时候就报错了，这个有很多原因，我经常出现的是，缓存问题，etcd在本机的/var/lib/etcd/下的数据和集群中的不一致，所以删除才能使用

3. 卸载了集群，但是重新init部署，发现部署后，所有的配置都自我恢复了

这个原因是，所有配置存在etcd内，那么卸载集群，删除docker并不会抹除这些配置，所以如果想完全卸载集群，还需要删除etcd中的数据内容。

4. 服务设定的是nodeport，但是发现只有pod所在node可以连接

导致这个原因就是，内部DNS没有通信成功，或者内部网络通信受阻，这个问题最好从根本解决。
不过也可以用一个备用方案，使用真实网络直接数据传递，在服务的yaml文件中的spec下缩进写入hostNetwork: true，例如：

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: test-host
spec:
  replicas: 4
  template:
    metadata:
      labels: 
        name: test-host
    spec:
      containers:
      - name: test-host
        image: registry:5000/back_demon:1.0
        command:
        - /jboss/jboss-eap-6.1/bin/standalone.sh 
        ports:
        - containerPort: 8080
      hostNetwork: true