kubeadm(k8s)部署—单主集群

Kubernetes概述
简介
Kubernetes是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效（powerful）,Kubernetes提供了应用部署，规划，更新，维护的一种机制。

Kubernetes一个核心的特点就是能够自主的管理容器来保证云平台中的容器按照用户的期望状态运行着（比如用户想让apache一直运行，用户不需要关心怎么去做，Kubernetes会自动去监控，然后去重启，新建，总之，让apache一直提供服务），管理员可以加载一个微型服务，让规划器来找到合适的位置，同时，Kubernetes也系统提升工具以及人性化方面，让用户能够方便的部署自己的应用（就像canary deployments）。

现在Kubernetes着重于不间断的服务状态（比如web服务器或者缓存服务器）和原生云平台应用（Nosql）,在不久的将来会支持各种生产云平台中的各种服务，例如，分批，工作流，以及传统数据库。

在Kubenetes中，所有的容器均在Pod中运行,一个Pod可以承载一个或者多个相关的容器，在后边的案例中，同一个Pod中的容器会部署在同一个物理机器上并且能够共享资源。一个Pod也可以包含O个或者多个磁盘卷组（volumes）,这些卷组将会以目录的形式提供给一个容器，或者被所有Pod中的容器共享，对于用户创建的每个Pod,系统会自动选择那个健康并且有足够容量的机器，然后创建类似容器的容器,当容器创建失败的时候，容器会被node agent自动的重启,这个node agent叫kubelet,但是，如果是Pod失败或者机器，它不会自动的转移并且启动，除非用户定义了 replication controller。

用户可以自己创建并管理Pod,Kubernetes将这些操作简化为两个操作：基于相同的Pod配置文件部署多个Pod复制品；创建可替代的Pod当一个Pod挂了或者机器挂了的时候。而Kubernetes API中负责来重新启动，迁移等行为的部分叫做“replication controller”，它根据一个模板生成了一个Pod,然后系统就根据用户的需求创建了许多冗余，这些冗余的Pod组成了一个整个应用，或者服务，或者服务中的一层。一旦一个Pod被创建，系统就会不停的监控Pod的健康情况以及Pod所在主机的健康情况，如果这个Pod因为软件原因挂掉了或者所在的机器挂掉了，replication controller 会自动在一个健康的机器上创建一个一摸一样的Pod,来维持原来的Pod冗余状态不变，一个应用的多个Pod可以共享一个机器。

我们经常需要选中一组Pod，例如，我们要限制一组Pod的某些操作，或者查询某组Pod的状态，作为Kubernetes的基本机制，用户可以给Kubernetes Api中的任何对象贴上一组 key:value的标签，然后，我们就可以通过标签来选择一组相关的Kubernetes Api 对象，然后去执行一些特定的操作，每个资源额外拥有一组（很多） keys 和 values,然后外部的工具可以使用这些keys和vlues值进行对象的检索，这些Map叫做annotations（注释）。

Kubernetes支持一种特殊的网络模型，Kubernetes创建了一个地址空间，并且不动态的分配端口，它可以允许用户选择任何想使用的端口，为了实现这个功能，它为每个Pod分配IP地址。

现代互联网应用一般都会包含多层服务构成，比如web前台空间与用来存储键值对的内存服务器以及对应的存储服务，为了更好的服务于这样的架构，Kubernetes提供了服务的抽象，并提供了固定的IP地址和DNS名称，而这些与一系列Pod进行动态关联，这些都通过之前提到的标签进行关联，所以我们可以关联任何我们想关联的Pod，当一个Pod中的容器访问这个地址的时候，这个请求会被转发到本地代理（kube proxy）,每台机器上均有一个本地代理，然后被转发到相应的后端容器。Kubernetes通过一种轮训机制选择相应的后端容器，这些动态的Pod被替换的时候,Kube proxy时刻追踪着，所以，服务的 IP地址（dns名称），从来不变。

所有Kubernetes中的资源，比如Pod,都通过一个叫URI的东西来区分，这个URI有一个UID,URI的重要组成部分是：对象的类型（比如pod），对象的名字，对象的命名空间，对于特殊的对象类型，在同一个命名空间内，所有的名字都是不同的，在对象只提供名称，不提供命名空间的情况下，这种情况是假定是默认的命名空间。UID是时间和空间上的唯一。
 

二、 安装

环境：

主机名	角色	配置	外网ip	内网ip	系统	内核版本
k8s-m01	master	2核4G	10.0.0.41	172.16.1.41	centos7.7	4.4.224-1.el7.elrepo.x86_64
k8s-m02	node	2核2G	10.0.0.42	172.16.1.42	centos7.7	4.4.224-1.el7.elrepo.x86_64

 

初始环境（2台都做）

1，修改主机名

[root@ k8s-m01 ~]# hostnamectl set-hostname k8s-m01
[root@ k8s-m02 ~]# hostnamectl set-hostname k8s-m02

2，做host解析

cat>>/etc/hosts<<\EOF
> 10.0.0.41 k8s-m01
> 10.0.0.42 k8s-m02
> EOF

3，同步系统时间

echo "*/5* * * * /usr/sbin/ntpdate ntp1.aliyun.com >/dev/null 2>&1" >>/var/spool/cron/root

4.加载并优化内核参数

cat >/etc/sysctl.d/kubernetes.conf<<\EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
net.ipv4.tcp_tw_recycle=0
vm.swappiness=0
vm.overcommit_memory=1
vm.panic_on_oom=0
fs.inotify.max_user_instances=8192
fs.inotify.max_user_watches=1048576
fs.file-max=52706963
fs.nr_open=52706963
net.ipv6.conf.all.disable_ipv6=1
net.netfilter.nf_conntrack_max=2310720
EOF

modprobe ip_vs_rr
modprobe br_netfilter
sysctl -p /etc/sysctl.d/kubernetes.conf

5，关闭swap分区
如果开启了swap分区, kubelet会启动失败(可以通过将参数-ail-swap-on设置为false来忽略swap on) ,故需要在每个node节点机器上关团swap分区。

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

6，关闭防火墙和selinux

systemctl stop firewalld
systemctl disable firewalld
iptables -F && iptables -X && iptables -F -t nat && iptables -X -t nat
iptables -P FORWARD ACCEPT
setenforce 0
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

7,安装docker

yum -y install yum-utils device-mapper-persistent-data lvm2
wget -P /etc/yum.repos.d/ https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache
yum -y install docker-ce

systemctl start docker

cat> /etc/docker/daemon.json<<\EOF
{
   "registry-mirrors": ["https://q3u0qv3z.mirror.aliyuncs.com"]
}
EOF

systemctl daemon-reload #重新载入

systemctl restart docker #启动docker

systemctl enable docker #开机自启

8，升级内核

rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
rpm -Uvh http://www.elrepo.org/elrepo-release-7.0-3.el7.elrepo.noarch.rpm
yum --enablerepo=elrepo-kernel install kernel-lt -y
grub2-set-default 0 && grub2-mkconfig -o /etc/grub2.cfg
reboot #重启服务器

三、 Kubeadm部署集群

1，安装kubeadm，kubelet，kubectl  
所有节点都安装kubeadm，kubelet，kubectl，但是：node节点上的kubectl不是必须的。

kubeadm：集群管理命令。
kubelet： 该组件运行在集群中所有机器上，执行启动pod和容器等操作。
kubectl：与集群通信的命令工具。

kubeadm不会为你安装或管理kubelet或kubectl ,因此你需要确保它们与kubeadm安装的Kubernetes控制平面版本匹配。否则,就有发生版本倾斜的风险,这可能导致意外的错误行为。然而, kubelet和控制平面之间的一个小版本倾斜是允许的，但是kubelet版本可能永远不会超过API服务器版本。例如,运行1.7.0的kubelets应该完全兼容1.8.0 API服务器，反之则不然。

1.1，配置yum源 （master上执行）

cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpghttps://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

1.2，清除和重载缓存

yum clean all
yum makecache

1.3，安装指定版本

yum install -y kubelet-1.18.0 kubeadm-1.18.0 kubectl-1.18.0
systemctl enable --now kubelet #开机自启

2，配置初始化master

2.1，获取默认配置文件

[root@ k8s-m01 ~]# kubeadm config print init-defaults > kubeadm-init.yaml

2.2，修改配置文件

[root@ k8s-m01 ~]# vim kubeadm-init.yaml 
apiVersion: kubeadm.k8s.io/v1beta2
bootstrapTokens:
- groups:
  - system:bootstrappers:kubeadm:default-node-token
  token: abcdef.0123456789abcdef
  ttl: 24h0m0s
  usages:
  - signing
  - authentication
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: 10.0.0.41    #宿主机ip地址
  bindPort: 6443
nodeRegistration:
  criSocket: /var/run/dockershim.sock
  name: k8s-m01
  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
---
apiServer:
  timeoutForControlPlane: 4m0s
apiVersion: kubeadm.k8s.io/v1beta2
certificatesDir: /etc/kubernetes/pki
clusterName: kubernetes
controllerManager: {}
dns:
  type: CoreDNS
etcd:
  local:
    dataDir: /var/lib/etcd
imageRepository: k8s.gcr.io
kind: ClusterConfiguration
kubernetesVersion: v1.18.0
networking:
  dnsDomain: cluster.local
  podSubnet: "10.244.0.0/16"    #网络插件flannel的默认网络地址  (自己添加)
  serviceSubnet: 10.96.0.0/12
scheduler: {}

3，在两台服务器上拉取k8s镜像(master node都做)

cat >k8s.images< kube-apiserver:v1.18.0
kube-controller-manager:v1.18.0
kube-proxy:v1.18.0
kube-scheduler:v1.18.0
coredns:1.6.7
etcd:3.4.3-0
pause:3.2
EOF

 

for i in `cat k8s.images`
do
    REPO=$(echo "$i"|awk -F ':' '{print $1}')
    TAG=$(echo "$i"|awk -F ':' '{print $2}')
    sudo docker pull registry.cn-beijing.aliyuncs.com/crazywjj/$i
    sudo docker tag  registry.cn-beijing.aliyuncs.com/crazywjj/$i k8s.gcr.io/$REPO:$TAG
    sudo docker rmi -f registry.cn-beijing.aliyuncs.com/crazywjj/$i
done

[root@ k8s-m01 ~]# docker images
REPOSITORY                           TAG                 IMAGE ID            CREATED             SIZE
k8s.gcr.io/etcd                      3.4.3-0             8a8b25a998f5        2 weeks ago         288MB
k8s.gcr.io/pause                     3.2                 08e5cdaeebf2        2 weeks ago         683kB
k8s.gcr.io/kube-scheduler            v1.18.0             37ee14e07d55        2 weeks ago         95.3MB
k8s.gcr.io/kube-controller-manager   v1.18.0             664a914a98e6        2 weeks ago         162MB
k8s.gcr.io/coredns                   1.6.7               3747791a7d1a        2 weeks ago         43.8MB
k8s.gcr.io/kube-apiserver            v1.18.0             7224e36df23e        2 weeks ago         173MB
k8s.gcr.io/kube-proxy                v1.18.0             dc58acc3a2b0        2 weeks ago         117MB

4，初始化master （最后一行就是加入node节点的密码）

[root@ k8s-m01 ~]# kubeadm init --config kubeadm-init.yaml

W0526 17:04:07.331197    4513 configset.go:202] WARNING: kubeadm cannot validate component configs for API groups [kubelet.config.k8s.io kubeproxy.config.k8s.io]
[init] Using Kubernetes version: v1.18.0
[preflight] Running pre-flight checks
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [k8s-m01 kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 10.0.0.41]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [k8s-m01 localhost] and IPs [10.0.0.41 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [k8s-m01 localhost] and IPs [10.0.0.41 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
W0526 17:04:13.127070    4513 manifests.go:225] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[control-plane] Creating static Pod manifest for "kube-scheduler"
W0526 17:04:13.128271    4513 manifests.go:225] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 28.503689 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.18" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node k8s-m01 as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node k8s-m01 as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: abcdef.0123456789abcdef
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to get nodes
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 10.0.0.41:6443 --token abcdef.0123456789abcdef \
    --discovery-token-ca-cert-hash sha256:ac6871f54194c36ef7878537116819afc1dc356128030b90b4afba8d14b56995 

5，配置kubectl命令

[root@ k8s-m01 ~]# mkdir -p $HOME/.kube
[root@ k8s-m01 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@ k8s-m01 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

6，获取pods列表命令

[root@ k8s-m01 ~]# yum install -y bash-completion
[root@ k8s-m01 ~]# echo 'source /usr/share/bash-completion/bash_completion' >> /etc/profile
[root@ k8s-m01 ~]# source /etc/profile
[root@ k8s-m01 ~]# source <(kubectl completion bash)
[root@ k8s-m01 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[root@ k8s-m01 ~]# source ~/.bashrc

[root@ k8s-m01 ~]# kubectl get pods --all-namespaces
NAMESPACE     NAME                              READY   STATUS    RESTARTS   AGE
kube-system   coredns-66bff467f8-7j7lz          0/1     Pending   0          119s
kube-system   coredns-66bff467f8-ldx79          0/1     Pending   0          119s
kube-system   etcd-k8s-m01                      1/1     Running   0          2m7s
kube-system   kube-apiserver-k8s-m01            1/1     Running   0          2m7s
kube-system   kube-controller-manager-k8s-m01   1/1     Running   0          2m7s
kube-system   kube-proxy-5wmd9                  1/1     Running   0          119s
kube-system   kube-scheduler-k8s-m01            1/1     Running   0          2m7s
##查看集群的健康状态
[root@ k8s-m01 ~]# kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok
controller-manager   Healthy   ok
etcd-0               Healthy   {"health":"true"}

[root@ k8s-m01 ~]# kubectl get nodes
NAME      STATUS     ROLES    AGE     VERSION
k8s-m01   NotReady   master   3m22s   v1.18.0
# node节点为NotReady，因为corednspod没有启动，缺少网络pod

7，安装网络插件flannel

简介：
Flannel是 CoreOS 团队针对 Kubernetes 设计的一个覆盖网络（Overlay Network）工具，其目的在于帮助每一个使用 Kuberentes 的 CoreOS 主机拥有一个完整的子网。这次的分享内容将从Flannel的介绍、工作原理及安装和配置三方面来介绍这个工具的使用方法。

Flannel通过给每台宿主机分配一个子网的方式为容器提供虚拟网络，它基于Linux TUN/TAP，使用UDP封装IP包来创建overlay网络，并借助etcd维护网络的分配情况。

Flannel是一种基于overlay网络的跨主机容器网络解决方案 ,也就是将TCP数据包封装在另一种网络包里面进行路由转发和通信, Flannel是CoreOS开发专门用于docker多机互联的一个工具,让集群中的不同节点主机创建的容器都具有全集群唯一的虚拟ip地址。

Flannel使用go语言编写。

Flannel实现原理

Flannel为每个host分配-个subnet ,容器从这个subnet中分配IP ,这些IP可以在host间路由,容器间无需使用nat和端口映射即可实现跨主机通信。
每个subnet都是从一个更大的IP池中划分的, flannel会在每个主机上运行一个叫flanneld的agent ,其职责就是从池子中分配subnet。
Flannel使用etcd存放网络配置、已分配的subnet. host的IP等信息。
Flannel数据包在主机间转发是由backend实现的,目前已经支持UDP、VxLAN、 host-gw. AWS VPC和GCE路由等多种backend.
 

下载yml（master执行）

curl -o kube-flannel.yml https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

注意：
flannel默认会使用主机的第-一张物理网卡,如果你有多张网卡,需要通过配置单独指定。修改kube-flannel.yml中的以下部分。

修改yml文件

[root@ k8s-m01 ~]# vim kube-flannel.yml 

拉取镜像（master.node）

cat >flannel.images< v0.12.0-amd64
v0.12.0-arm
v0.12.0-arm64
v0.12.0-ppc64le
v0.12.0-s390x
EOF
 

for i in `cat flannel.images`
do
    sudo docker pull registry.cn-beijing.aliyuncs.com/crazywjj/flannel:$i
    sudo docker tag  registry.cn-beijing.aliyuncs.com/crazywjj/flannel:$i quay.io/coreos/flannel:$i
    sudo docker rmi -f registry.cn-beijing.aliyuncs.com/crazywjj/flannel:$i
done

执行kube-flannel.yml （master上执行）

[root@ k8s-m01 ~]#  kubectl apply -f kube-flannel.yml

检查集群状态（master上操作）

[root@ k8s-m01 ~]# kubectl get pods --all-namespaces -o wide

[root@ k8s-m01 ~]# kubectl get nodes
NAME      STATUS   ROLES    AGE   VERSION
k8s-m01   Ready    master   31m   v1.18.0

 

[root@ k8s-m01 ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1            443/TCP   32m

[root@ k8s-m01 ~]# kubectl get cs
NAME                 STATUS    MESSAGE             ERROR
scheduler            Healthy   ok                  
controller-manager   Healthy   ok                  
etcd-0               Healthy   {"health":"true"}   
 

8、加入node节点,

节点(node)是工作负载(容器和pod等运行的地方,如果要向集群添加新节点,请为每台机器执行以下操作:

●node节点执行1.1.2初始化准备
●下载安装镜像
●执行kubeadm join

下载安装镜像（node）

node上也是需要下载安装一些镜像的，需要下载的镜像为：kube-proxy、pause、flannel

（上面已经下载过了）

 

不知道令牌，可以在主节点运行以该命令：

[root@ k8s-m01 ~]# kubeadm token list

加入node节点==(从初始化节点获取密码)==（node上操作）

kubeadm join 10.0.0.41:6443 --token abcdef.0123456789abcdef \
    --discovery-token-ca-cert-hash sha256:ac6871f54194c36ef7878537116819afc1dc356128030b90b4afba8d14b56995

检查node状态（master上操作）

[root@ k8s-m01 ~]# kubectl get nodes
NAME      STATUS     ROLES    AGE   VERSION
k8s-m01   Ready      master   11m   v1.18.0
k8s-m02   NotReady     21s   v1.18.0

#如果状态为 notready；查看一下pods的状态并检查：
[root@ k8s-m01 ~]#  kubectl get pods -n kube-system

验证kubernetes功能（master上操作）

创建测试文件

[root@ k8s-m01 ~] cat > nginx-ds.yml < apiVersion: v1
kind: Service
metadata:
  name: nginx-ds
  labels:
    app: nginx-ds
spec:
  type: NodePort
  selector:
    app: nginx-ds
  ports:
  - name: http
    port: 80
    targetPort: 80
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nginx-ds
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  selector:
    matchLabels:
      app: nginx-ds
  template:
    metadata:
      labels:
        app: nginx-ds
    spec:
      containers:
      - name: my-nginx
        image: daocloud.io/library/nginx:latest
        ports:
        - containerPort: 80
EOF

执行测试：（master上操作）

[root@ k8s-m01 ~]# kubectl create -f nginx-ds.yml
service/nginx-ds created
daemonset.apps/nginx-ds created

检查各节点的pod ip连通性注意这个里的NodePort端口是不固定的（master上操作）

#时间可能会稍长，由于网络和服务器配置的问题

[root@ k8s-m01 ~]# kubectl get pods -o wide|grep nginx-ds
nginx-ds-p7hl9   0/1     ContainerCreating   0          24s     k8s-m02            

[root@ k8s-m01 ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1              443/TCP        39m
nginx-ds     NodePort    10.102.70.215          80:32665/TCP   8m17s

#可见nginx-ds的信息：
#Service Cluster IP ：10.102.70.215
#服务端口：80
#NodePort端口：32665

检查服务IP和端口可达性（master上操作）

这里的端口为上面的端口32665

[root@ k8s-m01 ~]# curl -Is 10.0.0.42:32665
HTTP/1.1 200 OK
Server: nginx/1.17.10
Date: Mon, 25 May 2020 18:33:21 GMT
Content-Type: text/html
Content-Length: 612
Last-Modified: Tue, 14 Apr 2020 14:19:26 GMT
Connection: keep-alive
ETag: "5e95c66e-264"
Accept-Ranges: bytes

9.移除node节点

#在master节点执行

kubectl drain k8s-m02 --delete-local-data --force --ignore-daemonsets
kubectl delete node k8s-m02

#在node节点执行

[root@ k8s-m02 ~]# kubeadm reset
[root@ k8s-m02 ~]# systemctl stop kubelet
[root@ k8s-m02 ~]# systemctl stop docker
[root@ k8s-m02 ~]# rm -rf /var/lib/cni/ /var/lib/kubelet/* /etc/cni/
[root@ k8s-m02 ~]# ifconfig cni0 down
[root@ k8s-m02 ~]# ifconfig flannel.1 down
[root@ k8s-m02 ~]# ifconfig docker0 down
[root@ k8s-m02 ~]# ip link delete cni0
[root@ k8s-m02 ~]# ip link delete flannel.1
[root@ k8s-m02 ~]# systemctl start docker
 

#查看容器发现都已经删除

[root@ k8s-m02 ~]# docker ps -a

四 .Dashboard界面

Dashboard 是基于网页的 Kubernetes 用户界面。您可以使用 Dashboard 将容器应用部署到 Kubernetes 集群中，也可以对容器应用排错，还能管理集群本身及其附属资源。您可以使用 Dashboard 获取运行在集群中的应用的概览信息，也可以创建或者修改 Kubernetes 资源（如 Deployment，Job，DaemonSet 等等）。例如，您可以对 Deployment 实现弹性伸缩、发起滚动升级、重启 Pod 或者使用向导创建新的应用。

在kubernetes Dashboard中可以查看集群中应用的运行状态，也能够创建和修改各种kubernetes资源（比如Deployment，Job，Daemonset等等），用户可以对Deployment实现弹性伸缩，执行滚动升级，重启pod或者使用向导创建新的应用。

可以说，kubernetes Dashboard提供了kubectl的绝大部分功能。

• 全面的群集管理：命名空间，节点，窗格，副本集，部署，存储，RBAC创建修改等
• 快速且始终如一的即时更新：无需刷新页面即可查看最新信息
• 快速查看集群运行状况：实时图表可帮助快速跟踪性能不佳的资源
• 易于CRUD和扩展：加上内联API文档，可以轻松了解每个字段的作用
• 简单的OpenID集成：无需特殊代理

Dashboard 同时展示了kubernetes集群中的资源状态信息和所有报错信息。

官方参考文档：https://kubernetes.io/zh/docs/tasks/access-application-cluster/web-ui-dashboard/

GitHub项目下载地址：https://github.com/kubernetes/dashboard

4.1 下载 dashboard 文件 （master上执行）

[root@ k8s-m01 ~]# curl -o dashboard-recommended.yaml https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-rc7/aio/deploy/recommended.yaml
[root@ k8s-m01 ~]# kubectl apply -f  dashboard-recommended.yaml

查看运行状态：

[root@ k8s-m01 ~]# kubectl get pods -n kubernetes-dashboard
NAME                                                               READY   STATUS           RESTARTS   AGE
dashboard-metrics-scraper-dc6947fbf-cgr26     1/1          Running           0                  111s
kubernetes-dashboard-5d4dc8b976-lhm97       1/1         Running            0                  112s

查看kubernetes-dashboard所有信息：

[root@ k8s-m01 ~]# kubectl get all -n kubernetes-dashboard
NAME                                                                       READY   STATUS    RESTARTS   AGE
pod/dashboard-metrics-scraper-dc6947fbf-cgr26    1/1           Running     0                  3m19s
pod/kubernetes-dashboard-5d4dc8b976-lhm97       1/1          Running     0                  3m20s

NAME                                                 TYPE         CLUSTER-IP      EXTERNAL-IP   PORT(S)     AGE
service/dashboard-metrics-scraper    ClusterIP    10.108.101.75                  8000/TCP    3m20s
service/kubernetes-dashboard          ClusterIP    10.107.186.64                    443/TCP     3m21s

NAME                                                                READY      UP-TO-DATE   AVAILABLE   AGE
deployment.apps/dashboard-metrics-scraper   1/1             1                   1                       3m19s
deployment.apps/kubernetes-dashboard           1/1            1                    1                      3m21s

NAME                                                                               DESIRED     CURRENT   READY   AGE
replicaset.apps/dashboard-metrics-scraper-dc6947fbf    1                   1                  1             3m19s
replicaset.apps/kubernetes-dashboard-5d4dc8b976       1                   1                  1             3m20s

4.2 访问 dashboard

从 1.7 开始，dashboard 只允许通过 https 访问，如果使用 kube proxy 则必须监听 localhost 或 127.0.0.1。对于 NodePort 没有这个限制，但是仅建议在开发环境中使用。对于不满足这些条件的登录访问，在登录成功后浏览器不跳转，始终停在登录界面。

访问方式：

Dashboard的github https://github.com/kubernetes/dashboard/blob/master/docs/user/accessing-dashboard/1.7.x-and-above.md

• kubectl proxy：kubectl proxy在您的机器和Kubernetes API服务器之间创建代理服务器。默认情况下，只能在本地（从启动它的计算机上）访问它。

• kubectl port-forward：通过端口转发映射本地端口到指定的应用端口，从而访问集群中的应用程序(Pod)。

• NodePort：这种方法只推荐使用在一个node节点的方案，在大多数的环境都需要多个node节点，因此这种方法没有什么实用价值，不建议使用。

• API Server：如果Kubernetes API服务器是公开的并且可以从外部访问，则可以直接在以下位置访问仪表板： https://:/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/

  注意：仅当您选择在浏览器中安装用户证书时，才可以使用这种方式访问Dashboard。在示例中，可以使用kubeconfig文件用于联系API服务器的证书。

• Ingress

采用API Server访问： https://10.0.0.41:6443/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/

我们使用的是system:anonymous用户来访问位于kube-system命名空间中的名为https:kubernetes-dashboard的service资源。这个用户没有权限访问，所以被拒绝了。

4.3 生成浏览器访问证书

dashboard 默认只支持 token 认证（不支持 client 证书认证），所以如果使用 Kubeconfig 文件，需要将 token 写入到该文件。

创建证书：（master上）

首先需要确认kubectl命令的配置文件，默认情况下为/etc/kubernetes/admin.conf，而且已经自动创建在$HOME/.kube/config中，如果没有创建则需要手动赋值。

[root@ k8s-m01 ~]# cat $HOME/.kube/config

如果确认有集群的配置，则运行以下命令来生成一个p12格式的浏览器证书

[root@ k8s-m01 ~]# cd /etc/kubernetes/pki
[root@ k8s-m01 pki]# grep 'client-certificate-data' ~/.kube/config | head -n 1 | awk '{print $2}' | base64 -d > dashboard.crt
[root@ k8s-m01 pki]# grep 'client-key-data' ~/.kube/config | head -n 1 | awk '{print $2}' | base64 -d > dashboard.key

生成p12证书，按要求输入密码直接回车即可，密码不要胡乱输，后面给浏览器导入的时候要用。

[root@ k8s-m01 pki]# openssl pkcs12 -export -clcerts -inkey dashboard.key -in dashboard.crt -out dashboard.p12 -name "kubernetes-client"
Enter Export Password:123456
Verifying - Enter Export Password:123456

将生成的dashboard.p12证书下载到桌面；然后导入浏览器：

谷歌（Google）或者火狐（Firefox）

4.4 登录dashboard

1. 创建登录 dashboard 的 token 和 kubeconfig 配置文件

方式一：创建登录 token （master）

kubectl create sa dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin
ADMIN_SECRET=$(kubectl get secrets -n kube-system | grep dashboard-admin | awk '{print $1}')
DASHBOARD_LOGIN_TOKEN=$(kubectl describe secret -n kube-system ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}')
echo ${DASHBOARD_LOGIN_TOKEN}

方法二：创建使用 token 的 KubeConfig 文件 （推荐使用这种方式） （master）

cd /etc/kubernetes/pki
KUBE_APISERVER="https://10.0.0.41:6443"
DASHBOARD_LOGIN_TOKEN=$(kubectl describe secret -n kube-system ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}')

# 设置集群参数
kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.crt \
  --embed-certs=true \
  --server=${KUBE_APISERVER} \
  --kubeconfig=dashboard.kubeconfig

# 设置客户端认证参数，使用上面创建的 Token
kubectl config set-credentials dashboard_user \
  --token=${DASHBOARD_LOGIN_TOKEN} \
  --kubeconfig=dashboard.kubeconfig

# 设置上下文参数
kubectl config set-context default \
  --cluster=kubernetes \
  --user=dashboard_user \
  --kubeconfig=dashboard.kubeconfig

# 设置默认上下文
kubectl config use-context default --kubeconfig=dashboard.kubeconfig

将dashboard.kubeconfig导入到桌面，用生成的 dashboard.kubeconfig 登录 Dashboard（其它API server节点也可以用）。

然后测试https://10.0.0.41:6443/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/
（选择第二个，然后后面有三个点，然后选择你导入桌面的文件，然后登陆就OK了）