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是时间和空间上的唯一。

二、 安装

环境：

初始环境（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 <<EOF > /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<<EOF
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<<EOF
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    <none>        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   <none>   21s   v1.18.0

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

验证kubernetes功能（master上操作）

创建测试文件

[root@ k8s-m01 ~] cat > nginx-ds.yml <<EOF
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   <none>   k8s-m02   <none>           <none>

[root@ k8s-m01 ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        39m
nginx-ds     NodePort    10.102.70.215   <none>        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