1.1. 使用kubeadm部署Kubernetes v1.30

想要快速的体验Kubernetes的功能，官方提供了非常多的部署方案，可以使用官方提供的kubeadm以容器的方式运行Kubernetes集群，也可以使用二进制方式部署更有利于理解Kubernetes的架构，我们先使用kubeadm快速的部署一个Kubernetes集群后，学习Kubernetes的使用，然后动手使用二进制的方式来深入理解Kubernetes架构。

注意：请不要把目光仅仅放在部署上，要慢慢的了解其本质。

Kubernetesv1.13版本发布后，kubeadm才正式进入GA，可以生产使用。目前Kubernetes的对应镜像仓库，在国内阿里云也有了镜像站点，使用kubeadm部署Kubernetes集群变得简单并且容易了很多，本文使用kubeadm带领大家快速部署Kubernetes v1.30版本。

实验环境准备

在本书的实验环境的基础上，我们如下来分配角色：

主机名	IP地址（NAT）	最低配置	描述
linux-node1.linuxhot.com	eth0:192.168.56.11	1CPU/1G内存	Kubernets Master/Etcd节点
linux-node2.linuxhot.com	eth0:192.168.56.12	1CPU/1G内存	Kubernets Node节点
linux-node3.linuxhot.com	eth0:192.168.56.13	1CPU/1G内存	Kubernets Node节点
Service网段	10.1.0.0/16
Pod网段	10.2.0.0/16
备注	如果有条件可以部署多个Kubernets node，实验效果更佳。

1.1.1. 设置软件包仓库并安装

首先要设置软件包仓库，用于安装依赖的软件包。

1.设置kubernetes YUM仓库

Ubuntu 16.04 18.04 20.04 22.04操作系统（推荐）

# Step1: 安装必要的一些系统工具
sudo apt-get -y update
sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

# Step2: 设置Kubernetes仓库

curl -fsSL https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.30/deb/Release.key | gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.30/deb/ /" | tee /etc/apt/sources.list.d/kubernets.list

# Step3: 设置Docker仓库

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get -y update

# Step4: 安装容器运行时、kubeadm、kubectl、kubelet
sudo apt-get -y install containerd.io kubeadm kubectl kubelet

CentOS 7操作系统

# Step1: 设置Kubernetes仓库
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=kubernetes
baseurl=https://mirrors.tuna.tsinghua.edu.cn/kubernetes/core%3A/stable%3A/v1.30/rpm/
enabled=1
gpgcheck=0
EOF

# Step2: 设置Docker仓库
curl -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
curl -o /etc/yum.repos.d/docker-ce.repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# Step3: 安装容器运行时、kubeadm、kubectl、kubelet
yum install -y containerd.io kubeadm kubelet kubectl

CentOS 8操作系统

# Step1: 设置Kubernetes仓库
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=kubernetes
baseurl=https://mirrors.tuna.tsinghua.edu.cn/kubernetes/core%3A/stable%3A/v1.30/rpm/
enabled=1
gpgcheck=0
EOF

# Step2: 设置Docker仓库
dnf config-manager --add-repo=http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# Step3: 安装容器运行时、kubeadm、kubectl、kubelet
dnf -y install containerd.io kubeadm kubelet kubectl iproute-tc

# Step4: 设置内核参数
modprobe br_netfilter
echo 1 > /proc/sys/net/bridge/bridge-nf-call-iptables
echo 1 > /proc/sys/net/ipv4/ip_forward

1.1.2. 运行环境配置

1.配置kubelet

默认情况下，Kubelet不允许所在的主机存在交换分区，后期规划的时候，可以考虑在系统安装的时候不创建交换分区，针对已经存在交换分区的可以设置忽略禁止使用Swap的限制，不然无法启动Kubelet。下面配置可以不配置，自v1.22版本以后，默认的Cgroup驱动为systemd

[root@linux-node1 ~]# vim /etc/sysconfig/kubelet
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBELET_EXTRA_ARGS="--fail-swap-on=false"

在所有节点上关闭SWAP

[root@linux-node1 ~]# swapoff -a

2.设置内核参数

[root@linux-node1 ~]# cat <<EOF >  /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

使配置生效

[root@linux-node1 ~]# sysctl --system

3.启动kubelet并设置开机启动

注意，此时kubelet是无法正常启动的，可以查看/var/log/messages有报错信息，等待执行初始化之后即可正常，为正常现象。

systemctl enable kubelet && systemctl start kubelet
mkdir -p /etc/containerd
containerd config default > /etc/containerd/config.toml
sed -i 's#registry.k8s.io/pause:3.8#registry.aliyuncs.com/google_containers/pause:3.9#g' /etc/containerd/config.toml
systemctl enable containerd && systemctl restart containerd

4.使用IPVS进行负载均衡

在Kubernetes集群中Kube-Proxy组件负载均衡的功能，默认使用iptables，生产环境建议使用ipvs进行负载均衡。在所有节点启用ipvs模块

[root@linux-node1 ~]# cat <<EOF > /etc/sysconfig/modules/ipvs.modules
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack
EOF
[root@linux-node1 ~]# chmod +x /etc/sysconfig/modules/ipvs.modules
[root@linux-node1 ~]# source /etc/sysconfig/modules/ipvs.modules

查看模块是否加载正常

[root@linux-node1 ~]# lsmod | grep -e ip_vs -e nf_conntrack
ip_vs_sh               12688  0 
ip_vs_wrr              12697  0 
ip_vs_rr               12600  0 
ip_vs                 145497  6 ip_vs_rr,ip_vs_sh,ip_vs_wrr
nf_conntrack_ipv4      15053  15 
nf_defrag_ipv4         12729  1 nf_conntrack_ipv4
nf_conntrack          133095  7 ip_vs,nf_nat,nf_nat_ipv4,xt_conntrack,nf_nat_masquerade_ipv4,nf_conntrack_netlink,nf_conntrack_ipv4
libcrc32c              12644  4 xfs,ip_vs,nf_nat,nf_conntrack

以上步骤请在Kubernetes的所有节点上执行，本实验环境是需要在linux-node1、linux-node2、linux-node3这三台机器上均安装Docker、kubeadm、kubelet，对于以上操作需要自动化可以参考我使用SaltStack完成的salt-kubeadm项目：https://github.com/unixhot/salt-kubeadm

1.1.3. 初始化集群部署Master

在所有节点上安装完毕后，在linux-node1这台Master节点上进行集群的初始化工作。

1.导出所有默认的配置

[root@linux-node1 ~]# kubeadm config print init-defaults > kubeadm.yaml

上面的命令会生成一个默认配置的kubeadm配置文件，然后在此基础上进行修改即可。

[root@linux-node1 ~]# cat kubeadm.yaml 
apiVersion: kubeadm.k8s.io/v1beta3
bootstrapTokens:
- groups:
  - system:bootstrappers:kubeadm:default-node-token
  token: abcdef.0123456789abcdef
  ttl: 24h0m0s
  usages:
  - signing
  - authentication
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: 192.168.56.11  #修改为API Server的地址
  bindPort: 6443
nodeRegistration:
  criSocket: /var/run/dockershim.sock
  name: linux-node1.example.com     #修改Master节点的主机名称
  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
---
apiServer:
  timeoutForControlPlane: 4m0s
apiVersion: kubeadm.k8s.io/v1beta3
certificatesDir: /etc/kubernetes/pki
clusterName: kubernetes
controllerManager: {}
dns:
  type: CoreDNS
etcd:
  local:
    dataDir: /var/lib/etcd
imageRepository: registry.aliyuncs.com/google_containers  #修改为阿里云镜像仓库
kind: ClusterConfiguration
kubernetesVersion: v1.30.2  #修改为具体的版本
networking:
  dnsDomain: cluster.local
  serviceSubnet: 10.1.0.0/16   #修改Service的网络
  podSubnet: 10.2.0.0/16      #新增Pod的网络
scheduler: {}
---   #下面有增加的三行配置，用于设置Kubeproxy使用LVS

2. 执行初始化操作

[root@linux-node1 ~]# kubeadm init --config kubeadm.yaml
[init] Using Kubernetes version: v1.30.2
[preflight] Running pre-flight checks
error execution phase preflight: [preflight] Some fatal errors occurred:
        [ERROR NumCPU]: the number of available CPUs 1 is less than the required 2
        [ERROR Swap]: running with swap on is not supported. Please disable swa
[preflight] If you know what you are doing, you can make a check non-fatal with `--ignore-preflight-errors=...`
To see the stack trace of this error execute with --v=5 or higher

如果遇到上面这样的报错，是因为在实验环境开启了交换分区，以及CPU的核数小于2造成的，可以使用--ignore-preflight-errors=进行忽略。 --ignore-preflight-errors=：忽略运行时的错误，例如上面目前存在[ERROR NumCPU]和[ERROR Swap]，忽略这两个报错就是增加--ignore-preflight-errors=NumCPU 和--ignore-preflight-errors=Swap的配置即可。

再次执行初始化操作：

[root@linux-node1 ~]# kubeadm init --config kubeadm.yaml \
  --ignore-preflight-errors=NumCPU 
[init] Using Kubernetes version: v1.30.2
[preflight] Running pre-flight checks
        [WARNING NumCPU]: the number of available CPUs 1 is less than the required 2
        [WARNING Swap]: running with swap on is not supported. Please disable swap
[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'

执行完毕后，会在当前输出下停留，等待下载Kubernetes组件的Docker镜像。根据你的网络情况，可以持续1-5分钟，你也可以使用docker images查看下载的镜像。镜像下载完毕之后，就会进行初始操作：

这里省略了所有输出，初始化操作主要经历了下面15个步骤，每个阶段均输出均使用[步骤名称]作为开头：

[init]：指定版本进行初始化操作
[preflight] ：初始化前的检查和下载所需要的Docker镜像文件。
[kubelet-start]：生成kubelet的配置文件”/var/lib/kubelet/config.yaml”，没有这个文件kubelet无法启动，所以初始化之前的kubelet实际上启动失败。
[certificates]：生成Kubernetes使用的证书，存放在/etc/kubernetes/pki目录中。
[kubeconfig] ：生成 KubeConfig文件，存放在/etc/kubernetes目录中，组件之间通信需要使用对应文件。
[control-plane]：使用/etc/kubernetes/manifest目录下的YAML文件，安装 Master组件。
[etcd]：使用/etc/kubernetes/manifest/etcd.yaml安装Etcd服务。
[wait-control-plane]：等待control-plan部署的Master组件启动。
[apiclient]：检查Master组件服务状态。
[uploadconfig]：更新配置
[kubelet]：使用configMap配置kubelet。
[patchnode]：更新CNI信息到Node上，通过注释的方式记录。
[mark-control-plane]：为当前节点打标签，打了角色Master，和不可调度标签，这样默认就不会使用Master节点来运行Pod。
[bootstrap-token]：生成token记录下来，后边使用kubeadm join往集群中添加节点时会用到
[addons]：安装附加组件CoreDNS和kube-proxy

成功执行之后，你会看到下面的输出：

Your Kubernetes master 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/
You can now join any number of machines by running the following on each node
as root:
kubeadm join 192.168.56.11:6443 --token 19fhhl.3mzkyk16tcgp6vga --discovery-token-ca-cert-hash sha256:76a88c38b673d3b2ac73e33127a809688cb3e58c533512ac6d92ecb66aa57a45

如果执行失败，那意味着之前的操作存在问题，检查顺序如下：

基础环境
主机名是否可以解析，SELinux，iptables是否关闭。
交换分区是否存在free -m查看
内核参数是否修改、IPVS是否修改（目前阶段不会造成失败）
基础软件
Docker是否安装并启动
Kubelet是否安装并启动
执行kubeadm是否有别的报错是否忽略
systemctl status kubelet查看kubelet是否启动
如果kubelet无法启动，查看日志有什么报错，并解决报错。
以上都解决完毕，需要重新初始化
kubeadm reset 进行重置（生产千万不要执行，会直接删除集群）
根据kubeadm reset 提升，清楚iptables和LVS。

请根据上面输出的要求配置kubectl命令来访问集群。

3.为kubectl准备Kubeconfig文件。

kubectl默认会在执行的用户家目录下面的.kube目录下寻找config文件。这里是将在初始化时[kubeconfig]步骤生成的admin.conf拷贝到.kube/config。

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

在该配置文件中，记录了API Server的访问地址，所以后面直接执行kubectl命令就可以正常连接到API Server中。

4.使用kubectl命令查看组件状态

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

**知识回顾：为什么上面的输出没有显示API Server组件的状态

因为API Server是Kubernetes集群的入口，所有和Kubernetes集群的交互都必须经过APIServer，kubectl命令也是连接到API Server上进行交互，所以如果能够正常使用kubectl执行命令，意味着API Server运行正常。

5.使用kubectl获取Node信息

目前只有一个节点，角色是Master，状态是NotReady。

[root@linux-node1 ~]# kubectl get node
NAME STATUS ROLES AGE VERSION
linux-node1.unixhot.com NotReady master 14m v1.30.2

1.1.4. 部署网络插件

Master节点NotReady的原因就是因为没有使用任何的网络插件，此时Node和Master的连接还不正常。目前最流行的Kubernetes网络插件有Flannel、Calico、Canal，这里分别列举了Canal和Flannel，你可以选择其中之一进行部署。因为基础的Kubernetes集群已经配置完毕，后面的增加组件等操作，几乎都可以使用kubectl和一个YAML配置文件来完成。

【部署canal网络插件】

需要自行解决Docker镜像国内无法访问的问题。

[root@linux-node1 ~]# kubectl apply -f https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/hosted/canal/rbac.yaml
[root@linux-node1 ~]# kubectl apply -f https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/hosted/canal/canal.yaml

【部署Flannel网络插件】（推荐）部署Flannel网络插件需要修改Pod的IP地址段，修改为和你初始化一直的网段，可以先下载Flannel的YAML文件修改后，再执行。由于官方的YAML文件镜像无法访问，这里可以使用笔者修改好的YAML文件。

[root@linux-node1 ~]# git clone --depth 1 https://github.com/unixhot/salt-kubeadm.git
[root@linux-node1 ~]# cp salt-kubeadm/salt/k8s/templates/flannel/kube-flannel.yml.template /opt/kube-flannel.yml
[root@linux-node1 Documentation]# vim /opt/kube-flannel.yml
# 修改"Network": "{{ POD_CIDR }}",为"Network": "10.2.0.0/16",

74   net-conf.json: |
75     {
76       "Network": "10.2.0.0/16",
77       "Backend": {
78         "Type": "vxlan"
79       }
80     }

部署Flannel

[root@linux-node1 Documentation]# kubectl create -f /opt/kube-flannel.yml

查看Pod状态

[root@linux-node1 Documentation]# kubectl get pod -n kube-system
NAME                                              READY   STATUS     RESTARTS   AGE
coredns-58cc8c89f4-cjhdv                          0/1     Pending    0          41m
coredns-58cc8c89f4-vdfn2                          0/1     Pending    0          41m
etcd-linux-node1.unixhot.com                      1/1     Running    0          41m
kube-apiserver-linux-node1.unixhot.com            1/1     Running    0          40m
kube-controller-manager-linux-node1.unixhot.com   1/1     Running    1          40m
kube-flannel-ds-amd64-bwsxl                       0/1     Init:0/1   0          20s
kube-proxy-5qrmh                                  1/1     Running    0          41m
kube-scheduler-linux-node1.unixhot.com            1/1     Running    1          41m

可以看到此时CoreDNS处于Pending状态，需要等待网络插件canal或者Flannel的Pod状态变成Running之后CoreDNS也会正常。所有Pod的状态都变成Running之后，这个时候再次获取Node，会发现节点变成了Ready状态。

[root@linux-node1 ~]# kubectl get node
NAME STATUS ROLES AGE VERSION
linux-node1.unixhot.com Ready master 29m v1.18.3

kubeadm其实使用Kubernetes部署Kubernetes，这样就存在先有鸡还是先有蛋的问题，所以，我们首先手动部署了Docker和kubelet，然后kubeadm调用kubelet以静态Pod的方式部署了Kubernetes集群中的其它组件。静态Pod在后面的章节会讲到。

1.1.5. 部署Node节点

Master节点部署完毕之后，就可以部署Node节点，首先请遵循部署Docker和kubeadm章节为Node节点部署安装好docker、kubeadm和kubelet，此过程这里不再重复列出。

1.在Master节点输出增加节点的命令

[root@linux-node1 ~]# kubeadm token create --print-join-command
kubeadm join 192.168.56.11:6443 --token isggqa.xjwsm3i6nex91d2x --discovery-token-ca-cert-hash sha256:718827895a9a5e63dfa9ff54e16ad6dc0c493139c9c573b67ad66968036cd569

2.在Node节点执行

注意如果节点有交换分区，需要增加--ignore-preflight-errors=Swap。

部署linux-node2

[root@linux-node2 ~]# kubeadm join 192.168.56.11:6443 --token isggqa.xjwsm3i6nex91d2x --discovery-token-ca-cert-hash sha256:718827895a9a5e63dfa9ff54e16ad6dc0c493139c9c573b67ad66968036cd569 --ignore-preflight-errors=Swap

部署linux-node3

[root@linux-node3 ~]# kubeadm join 192.168.56.11:6443 --tokenisggqa.xjwsm3i6nex91d2x --discovery-token-ca-cert-hash sha256:718827895a9a5e63dfa9ff54e16ad6dc0c493139c9c573b67ad66968036cd569 --ignore-preflight-errors=Swap

这个时候kubernetes会使用DaemonSet在所有节点上都部署canal/flannel和kube-proxy。部署完毕之后节点即部署完毕。DaemonSet的内容后面会讲解。

    [root@linux-node1 ~]# kubectl get daemonset --all-namespaces
    NAMESPACE NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE
    kube-system canal 2 2 1 2 1 beta.kubernetes.io/os=linux 17m
    kube-system kube-proxy 2 2 2 2 2 <none> 47m

待所有Pod全部启动完毕之后，节点就恢复Ready状态。


    [root@linux-node1 ~]# kubectl get pod --all-namespaces
    NAMESPACE NAME READY STATUS RESTARTS AGE
    kube-system canal-lv92w 3/3 Running 0 8m45s
    kube-system canal-rq5n5 3/3 Running 0 23m
    kube-system coredns-78d4cf999f-5k4sg 1/1 Running 0 53m
    kube-system coredns-78d4cf999f-bnbgf 1/1 Running 0 53m
    kube-system etcd-linux-node1.linuxhot.com 1/1 Running 0 52m
    kube-system kube-apiserver-linux-node1.linuxhot.com 1/1 Running 0 52m
    kube-system kube-controller-manager-linux-node1.linuxhot.com 1/1 Running 0 52m
    kube-system kube-proxy-sddlp 1/1 Running 0 53m
    kube-system kube-proxy-tw96b 1/1 Running 0 8m45s
    kube-system kube-scheduler-linux-node1.linuxhot.com 1/1 Running 0 52m

查看所有节点

    [root@linux-node1 ~]# kubectl get node
    NAME STATUS ROLES AGE VERSION
    linux-node1.linuxhot.com Ready master 49m v1.18.3
    linux-node2.linuxhot.com Ready <none> 4m48s v1.18.3

如何给Node加上Roles标签

使用kubectl get node能够看到linux-node1.linuxhot.com的ROLES是master这个是在进行集群初始化的时候[mark-control-plane]进行标记的。

    [mark-control-plane] Marking the node linux-node1.linuxhot.com as control-plane
    by adding the label "node-role.kubernetes.io/master=''"

    [mark-control-plane] Marking the node linux-node1.linuxhot.com as control-plane
    by adding the taints [node-role.kubernetes.io/master:NoSchedule]

1.查看节点的标签

    [root@linux-node1 ~]# kubectl get nodes --show-labels

    NAME STATUS ROLES AGE VERSION LABELS

    linux-node1.linuxhot.com Ready master 48m v1.18.3
    beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=linux-node1.linuxhot.com,node-role.kubernetes.io/master=

    linux-node2.linuxhot.com Ready <none> 7m13s v1.18.3
    beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=linux-node2.linuxhot.com

2.增加标签

    [root@linux-node1 ~]# kubectl label nodes linux-node2.linuxhot.com
    node-role.kubernetes.io/node=

    node/linux-node2.linuxhot.com labeled

3.查看效果

    [root@linux-node1 ~]# kubectl get nodes
    NAME STATUS ROLES AGE VERSION
    linux-node1.linuxhot.com Ready master 50m v1.18.3
    linux-node2.linuxhot.com Ready node 8m41s v1.18.3

1.1.6. 6.测试Kubernetes集群

在上面的步骤中，我们创建了一个Kubernetes集群，1个Master和2个Node节点，在生产环境需要考虑Master的高可用，这里先不用考虑，后面会讲到。

1.创建一个单Pod的Nginx应用

    [root@linux-node1 ~]# kubectl create deployment nginx --image=nginx:alpine
    deployment.apps/nginx created

    [root@linux-node1 ~]# kubectl get pod
    NAME READY STATUS RESTARTS AGE
    nginx-54458cd494-9j7ql 0/1 ContainerCreating 0 10s

2.查看Pod详细信息

待Pod的状态为Running后，可以获取Pod的IP地址，这个IP地址是从Master节点初始化的--pod-network-cidr=10.2.0.0/16地址段中分配的。

    [root@linux-node1 ~]# kubectl get pod -o wide

    NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES

    nginx-54458cd494-9j7ql 1/1 Running 0 59s 10.2.1.2 linux-node2.linuxhot.com
    <none> <none>

3.测试Nginx访问

    [root@linux-node1 ~]# curl --head http://10.2.1.2

    HTTP/1.1 200 OK
    Server: nginx/1.15.8
    Date: Sun, 13 Jan 2019 01:16:36 GMT
    Content-Type: text/html
    Content-Length: 612
    Last-Modified: Wed, 26 Dec 2018 23:21:49 GMT
    Connection: keep-alive
    ETag: "5c240d0d-264"
    Accept-Ranges: bytes

4.测试扩容

现在将Nginx应用的Pod副本数量拓展到2个节点

    [root@linux-node1 ~]# kubectl scale deployment nginx --replicas=2

    deployment.extensions/nginx scaled

    [root@linux-node1 ~]# kubectl get pod

    NAME READY STATUS RESTARTS AGE

    nginx-54458cd494-9j7ql 1/1 Running 0 2m13s

    nginx-54458cd494-vnm4f 1/1 Running 0 5s

5.为Nginx增加Service

为Nginx增加Service，会创建一个Cluster IP，从Master初始化的--service-cidr=10.1.0.0/16地址段中进行分配，并开启NodePort是在Node节点上进行端口映射，进行外部访问。

    [root@linux-node1 ~]# kubectl expose deployment nginx --port=80
    --type=NodePort

    service/nginx exposed

    [root@linux-node1 ~]# kubectl get service

    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    kubernetes ClusterIP 10.1.0.1 <none> 443/TCP 88m
    nginx NodePort 10.1.147.204 <none> 80:30599/TCP 67m

6.测试Service的VIP

    [root@linux-node1 ~]# curl --head http://10.1.147.204/

    HTTP/1.1 200 OK 
    Server: nginx/1.15.8
    Date: Sun, 13 Jan 2019 01:26:21 GMT
    Content-Type: text/html
    Content-Length: 612
    Last-Modified: Wed, 26 Dec 2018 23:21:49 GMT
    Connection: keep-alive
    ETag: "5c240d0d-264"
    Accept-Ranges: bytes

7.测试NodePort，外部访问。

这一切看起来似乎不是十分完美，但是现在你已经拥有了一个Kubernetes集群，接下来就可以继续探索Kubernetes的世界了。

5.2 使用kubeadm部署Kubernetes集群