小规模容器编排使用Docker Swarm不香么，用个锤子的kubernetes

Posted 2023-03-31 MCNU云原生

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了小规模容器编排使用Docker Swarm不香么，用个锤子的kubernetes相关的知识，希望对你有一定的参考价值。

文章目录

一、Docker Swarm是什么？

Docker Swarm是一款由Docker官方推出的容器编排工具，其主要作用是把若干台Docker 主机抽象为一个整体，并且通过一个入口统一管理这些Docker 主机上的各种Docker 资源，用于管理和编排多个Docker容器的集群。

它可以让用户方便地管理多个Docker节点，以及部署和扩展应用程序。Docker Swarm通过提供集群管理、负载均衡、服务发现和滚动更新等功能，简化了分布式应用程序的开发和部署过程。

有人会有疑问，kubernetes现在已经是容器编排领域的王者了，还有Docker Swarm什么事情？其实不然，根据我的个人经验以及和同行的交流来看，kubernetes功能非常强大，但是也非常复杂，部署和运维过程不是都需要有不少的工作，需要有专门的团队专家维护，属于比较“重”的。而相对来说Docker Swarm则比较轻量级，维护相对简单，对于一些中小企业来说，不需要投入过多的成本，也是一个非常好的选择。

还是老话：适合的才是最好的。

二、Swarmkit和Swarm Mode是什么？

Docker容器编排的功能经历了好几代，分别是Docker Swarm、Swarmkit和Swarm Mode。苍天啊，我也有点服了，整这么几个相近的名字，确实让初学者头疼凌乱。

Docker Swarm是Docker容器编排最初提供的功能，它独立于Docker Engine之外，使用Docker CLI进行管理，需要部署额外的KV存储，从Docker 1.6开始就有了，为了方便，我们姑且称之为Docker Swarm V1吧。

Docker Swarm V1由Discovery Service模块、Scheduler模块和Leadership模块组成。如下图所示，Discovery Service主要用于发现Swarm集群重的节点；Scheduler则主要负责给用户新创建的容器分配最优的节点，支持多种策略；Leadership则是提供了Swarm HA的功能。

目前来说Docker Swarm项目已经沉寂，不太建议新项目使用。

Docker 发展到1.12版本的时候，Docker官方又发布了一个项目称为Docker Swarmkit，它也是一个独立的容器编排项目，目前在github上开源，有2K Star，还在更新。Swarmkit有自己独立的CLI管理工具，容器编排和调度能力更强，支持节点发现，实现了Raft共识选主和安全访问，是一个比较完善的容器编排项目。为了方便，我们且称之为Docker Swarm V2。

运行SwarmKit的多台机器可以组合在一起形成Swarm集群，相互协调任务。一旦一台机器加入，它就自动成为一个Swarm 节点，而这个节点可以是工作节点或管理节点。它使用独立的CLI swarmd和swarmctl，swarmd部署在cluster中的每一个node上，彼此间互相通信，组成cluster；而swarmctl则用来控制整个集群。

例如使用swarmd初始化节点：

$ swarmd -d /tmp/node-1 --listen-control-api /tmp/node-1/swarm.sock --hostname node-1

例如使用swarmctl列出正在运行的服务：

$ swarmctl service ls
ID                         Name   Image        Replicas
--                         ----   -----        --------
08ecg7vc7cbf9k57qs722n2le  redis  redis:3.0.5  1/1

最后终于轮到了主角Swarm Mode，其实就是现在Docker官方建议使用的Docker容器编排模式，它的底层还是基于Swarmkit构建的，但是它将swarm的能力集成到了Docker Engine中，你只需要部署Docker Engine就自动获得了容器编排的能力，不需要额外的存储，使用Docker CLI，不需要额外的CLI工具，支持服务发现、滚动升级、负载均衡、路由和容器的扩缩容、安全通信等功能，算是非常完善且方便的。

swarm集群中所有的节点都是对等的，分为两个角色：manager和worker，manager服务集群的管理，worker负责容器的运行，两个角色可以相互转换，极为方便。目前推荐docker的容器编排使用swarm mode。

三、Docker Swarm的核心设计

我们再来仔细说说docker swarm（从这里开始指的都是swarm mode）的核心设计思想。

首先swarm的功能内嵌在了Docker Engine上，这样子一来除了Docker Engine无需再额外安装其他软件，相对于独立组件更加轻便。

swarm集群支持多个Manager，Manager之间通过raft协议实现高可用。它针对服务进行了抽象设计，抽象出了Service、Task和Container概念，如下图所示

Service代表一个作业，而Task则是swarm内调度的最小单位，每个task一般只调用一个Container，例如你指定了一个服务要运行三个实例，则会启动三个Task，每个Task负责运行一个Container实例。

在swarm中有两种不同的Service模式：

Replicated services（副本模式）
副本模式下，在定义service的时候指定任务的数量，一般也就是container实例的数量，集群会按照指定的数量运行任务。
global services（全局模式）
在每个节点上运行一个相同的任务，但是不预先指定任务数量，而是每增加一个节点到 swarm 中，协调器就新建一个任务，然后调度器把任务分配给新节点。

而对于Task，整个生命周期具有不同的状态，可以监控到任务执行的情况，Task生命周期状态有：

NEW       任务在初始化状态
PENDING   正在分配任务所用的资源
ASSIGNED  Docker分配任务给节点
ACCEPTED  任务被工作节点接受。如果工作节点拒接任务，状态将会转变成REJECTED
PREPARING Docker正在准备任务
STARTING  Docker正在开启任务
RUNNING   任务正在执行
COMPLETE  任务结束，不带错误代码
FAILED    任务结束，带着错误代码
SHUTDOWN  Docker请求任务关闭
REJECTED  工作节点拒绝任务
ORPHANED  节点宕机时间太长
REMOVE    该任务不是终端，但相关服务已被删除或缩小

一般的swarm使用流程为：用户在Docker Swarm上定义一个服务，包括服务名称、容器镜像、容器数量等信息，Docker Swarm manager会将服务的定义发送给集群中的所有Worker节点，每个Worker节点会启动指定数量的容器，并将容器注册到Swarm中,而Swarm会通过内置的负载均衡算法将请求分发到各个容器中，当用户需要更新容器时，只需更新服务定义，Swarm会自动将容器更新到最新版本。

四、Docker Swarm安装部署

由于Docker Swarm已经集成到了Docker Engine中，所以只要安装了Docker就可以通过以下步骤进行swarm集群的部署。

为了进行实验，我本地搭建了两个虚拟机：node1（192.168.56.11）和node2(192.168.56.12)。

4.1、初始化Swarm节点1

首先，选择一个节点作为manager节点，对swarm进群进行初始化，我这里选择node1，使用以下命令：

[docker@node1 ~]$ docker swarm init

结果如下：

可以看到这个节点已经成为了一个manager节点，且提示了如何加入新的manager节点和worker节点。

4.2、新节点加入Swarm集群

使用docker swarm join --token <token> <manager-ip>:<manager-port>命令可以作为worker节点加入集群。

[docker@node2 ~]$ docker swarm join --token SWMTKN-1-5h4jxvef4q4qhxb45saibjj3hgm8rsjm8otqc2x78m4ovinel7-2zm4q85rlavh59i1bdwbv5hwt 192.168.56.11:2377

正常情况下如下会提示作为worker节点加入成功。

4.3、使用swarm部署服务

使用docker service create --name <service-name> <image>命令可以创建service，在docker swarm中使用docker service进行服务部署和管理。

我们这里使用busybox镜像进行容器部署，首先拉去镜像到本地，并使用docker images查看确认镜像。

[docker@node1 ~]$ docker pull busybox:latest
[docker@node1 ~]$ docker images

创建service

[docker@node1 ~]$ docker service create --name helloworld busybox:latest sh -c "while true; do echo Hello; sleep 2; done"

查询service

[docker@node1 ~]$ docker service ls
ID             NAME         MODE         REPLICAS   IMAGE            PORTS
j1mtev8f7k05   helloworld   replicated   1/1        busybox:latest

可以看到服务ID以及副本的数量。

查看service详细信息

使用命令docker service inspect <service-name>可以查看service的详细信息，如下命令，可以看到输出内容信息非常丰富，包括service的定义等。

[docker@node1 ~]$ docker service inspect helloworld

扩展service

使用命令docker service scale <service-name>=<replicas>

[docker@node1 ~]$ docker service scale helloworld=2

再次使用docker service ls可以看到副本数量已经提升到了2。

更新service

可以使用docker service update --image <new-image> <service-name>更新service的定义，包括容器镜像和数量等信息，service将会被自动重新部署。

[docker@node1 ~]$ docker service update --image nginx:latest helloworld

重新查看service，可以发现image已经更换为了nginx:latest。

删除service

使用命令docker service rm <ID>或者docker service rm <service-name>

[docker@node1 ~]$ docker service rm helloworld

4.4、swarm集群管理

docker swarm还提供了一些命令用于swarm集群节点本身的管理，例如

查看 Swarm 集群节点：
```
[docker@node1 ~]$ docker node ls
```

从 Swarm 集群中删除一个节点：

[docker@node1 ~]$ docker node rm <node-id>

增加一个新的manager节点

在当前manager节点上执行命令docker swarm join-token manager，此时会输出以下内容：
```
docker swarm join --token SWMTKN-1-5h4jxvef4q4qhxb45saibjj3hgm8rsjm8otqc2x78m4ovinel7-3mxnl9pluz287gdo6ggefbr0r 192.168.56.11:2377
```
在新节点上执行此命令，即可轻松添加一个新的manager节点。

通过以上，总结一下，docker swarm集群无论是部署和维护都是相对简单的，而容器的编排功能却一点也不弱，满足中小公司和团队的容器编排部署需要一点问题也没有，相对于kubernetes的部署和维护流程，能够节省大量的投入，所以kubernetes适合大规模的容器编排，小规模的老老实实选择docker swarm轻轻松松不香么~

K8S太火了！花10分钟玩转它不香么？

我的Mall电商实战项目一直使用的是Docker容器化部署，有很多朋友建议搞个Kubernetes部署。最近正好在学习Kubernetes，准备更新一波！今天我们先来学习下Kubernetes的核心概念和基本使用，希望对大家有所帮助！

Kubernetes简介

Kubernetes（简称K8S，K和S之间有8个字母）是用于自动部署，扩展和管理容器化应用程序的开源系统。它将组成应用程序的容器组合成逻辑单元，以便于管理和服务发现。Kubernetes 源自Google 15 年生产环境的运维经验，同时凝聚了社区的最佳创意和实践。

Kubernetes具有如下特性：

服务发现与负载均衡：无需修改你的应用程序即可使用陌生的服务发现机制。
存储编排：自动挂载所选存储系统，包括本地存储。
Secret和配置管理：部署更新Secrets和应用程序的配置时不必重新构建容器镜像，且不必将软件堆栈配置中的秘密信息暴露出来。
批量执行：除了服务之外，Kubernetes还可以管理你的批处理和CI工作负载，在期望时替换掉失效的容器。
水平扩缩：使用一个简单的命令、一个UI或基于CPU使用情况自动对应用程序进行扩缩。
自动化上线和回滚：Kubernetes会分步骤地将针对应用或其配置的更改上线，同时监视应用程序运行状况以确保你不会同时终止所有实例。
自动装箱：根据资源需求和其他约束自动放置容器，同时避免影响可用性。
自我修复：重新启动失败的容器，在节点死亡时替换并重新调度容器，杀死不响应用户定义的健康检查的容器。

Minikube简介

Minikube是一种轻量级的Kubernetes实现，可在本地计算机上创建VM并部署仅包含一个节点的简单集群，Minikube可用于Linux、MacOS和Windows系统。Minikube CLI提供了用于引导集群工作的多种操作，包括启动、停止、查看状态和删除。

Kubernetes核心概念

由于Kubernetes有很多核心概念，学习它们对理解Kubernetes的使用很有帮助，所以我们先来学习下这些核心概念。

Node

Kubernetes集群是指Kubernetes协调一个高可用计算机集群，每个计算机作为独立单元互相连接工作。

一个Kubernetes集群包含两种类型的资源：

Master：负责管理整个集群。协调集群中的所有活动，例如调度应用、维护应用的所需状态、应用扩容以及推出新的更新。
Node：用于托管正在运行的应用。可以是一个虚拟机或者物理机，它在Kubernetes集群中充当工作机器的角色，每个Node都有Kubelet，它管理Node而且是Node与Master通信的代理，Node还具有用于处理容器操作的工具，例如Docker或rkt。

Deployment

Deployment负责创建和更新应用程序的实例。创建Deployment后，Kubernetes Master 将应用程序实例调度到集群中的各个节点上。如果托管实例的节点关闭或被删除，Deployment控制器会将该实例替换为群集中另一个节点上的实例。这提供了一种自我修复机制来解决机器故障维护问题。

可以使用Kubernetes命令行界面Kubectl创建和管理Deployment。Kubectl使用Kubernetes API与集群进行交互。

Pod

Pod相当于逻辑主机的概念，负责托管应用实例。包括一个或多个应用程序容器（如 Docker），以及这些容器的一些共享资源（共享存储、网络、运行信息等）。

Service

Service是一个抽象层，它定义了一组Pod的逻辑集，并为这些Pod支持外部流量暴露、负载平衡和服务发现。

ClusterIP（默认）：在集群的内部IP上公开Service。这种类型使得Service只能从集群内访问。
NodePort：使用NAT在集群中每个选定Node的相同端口上公开Service。使用 <NodeIP>:<NodePort>从集群外部访问Service。是ClusterIP的超集。
LoadBalancer：在当前云中创建一个外部负载均衡器(如果支持的话)，并为Service分配一个固定的外部IP。是NodePort的超集。
ExternalName：通过返回带有该名称的CNAME记录，使用任意名称（由spec中的externalName指定）公开Service。不使用代理。

Docker安装

由于Kubernetes运行需要依赖容器运行时（负责运行容器的软件），现比较通用的容器运行时有Docker、containerd和CRI-O。这里选择Docker，先在Linux服务器上安装好Docker环境。

安装 yum-utils：

yum install -y yum-utils device-mapper-persistent-data lvm2

为yum源添加docker仓库位置：

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装Docker：

yum install docker-ce

启动Docker：

systemctl start docker

Minikube安装

首先我们需要下载Minikube的二进制安装包并安装：

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

然后使用如下命令启动Minikube：

minikube start

如果你使用的是 root用户的话会无法启动并提示如下信息，那是因为Minikube不允许使用root权限启动，需要创建一个非root账号再启动；

* minikube v1.16.0 on Centos 7.6.1810
* Automatically selected the docker driver
* The "docker" driver should not be used with root privileges.
* If you are running minikube within a VM, consider using --driver=none:
*   https://minikube.sigs.k8s.io/docs/reference/drivers/none/

X Exiting due to DRV_AS_ROOT: The "docker" driver should not be used with root privileges.

这里创建了一个属于 docker用户组的 macro用户，并切换到该用户；

# 创建用户
useradd -u 1024 -g docker macro
# 设置用户密码
passwd macro
# 切换用户
su macro

再次使用 minikube start命令启动Minikube，启动成功后会显示如下信息：

* To pull new external images, you may need to configure a proxy: https://minikube.sigs.k8s.io/docs/reference/networking/proxy/
* Preparing Kubernetes v1.20.0 on Docker 20.10.0 ...
  - Generating certificates and keys ...
  - Booting up control plane ...
  - Configuring RBAC rules ...
* Verifying Kubernetes components...
* Enabled addons: default-storageclass, storage-provisioner
* kubectl not found. If you need it, try: 'minikube kubectl -- get pods -A'
* Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Kubernetes的使用

创建集群

通过Minikube我们可以创建一个单节点的K8S集群，集群管理Master和负责运行应用的Node都部署在此节点上。

查看Minikube的版本号：

minikube version

minikube version: v1.16.0
commit: 9f1e482427589ff8451c4723b6ba53bb9742fbb1

查看kubectl的版本号，第一次使用会直接安装kubectl：

minikube kubectl version

Client Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.0", GitCommit:"af46c47ce925f4c4ad5cc8d1fca46c7b77d13b38", GitTreeState:"clean", BuildDate:"2020-12-08T17:59:43Z", GoVersion:"go1.15.5", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.0", GitCommit:"af46c47ce925f4c4ad5cc8d1fca46c7b77d13b38", GitTreeState:"clean", BuildDate:"2020-12-08T17:51:19Z", GoVersion:"go1.15.5", Compiler:"gc", Platform:"linux/amd64"}

如果你想直接使用kubectl命令的话，可以将其复制到 /bin目录下去：

# 查找kubectl命令的位置
find / -name kubectl
# 找到之后复制到/bin目录下
cp /mydata/docker/volumes/minikube/_data/lib/minikube/binaries/v1.20.0/kubectl /bin/
# 直接使用kubectl命令
kubectl version

查看集群详细信息：

kubectl cluster-info

Kubernetes control plane is running at https://192.168.49.2:8443
KubeDNS is running at https://192.168.49.2:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

查看集群中的所有Node，可以发现Minikube创建了一个单节点的简单集群：

kubectl get nodes

NAME       STATUS   ROLES                  AGE   VERSION
minikube   Ready    control-plane,master   46m   v1.20.0

部署应用

一旦运行了K8S集群，就可以在其上部署容器化应用程序。通过创建Deployment对象，可以指挥K8S如何创建和更新应用程序的实例。

指定好应用镜像并创建一个Deployment，这里创建一个Nginx应用：

kubectl create deployment kubernetes-nginx --image=nginx:1.10

创建一个Deployment时K8S会产生如下操作：

选择一个合适的Node来部署这个应用；
将该应用部署到Node上；
当应用异常关闭或删除时重新部署应用。

查看所有Deployment：

kubectl get deployments

NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
kubernetes-nginx      1/1     1            1           21h

我们可以通过 kubectl proxy命令创建一个代理，这样就可以通过暴露出来的接口直接访问K8S的API了，这里调用了查询K8S版本的接口；

[macro@linux-local root]$ kubectl proxy
Starting to serve on 127.0.0.1:8001
[root@linux-local ~]# curl http://localhost:8001/version
{
  "major": "1",
  "minor": "20",
  "gitVersion": "v1.20.0",
  "gitCommit": "af46c47ce925f4c4ad5cc8d1fca46c7b77d13b38",
  "gitTreeState": "clean",
  "buildDate": "2020-12-08T17:51:19Z",
  "goVersion": "go1.15.5",
  "compiler": "gc",
  "platform": "linux/amd64"
}

查看应用

通过对运行应用的Pod进行操作，可以查看容器日志，也可以执行容器内部命令。

查看K8s中所有Pod的状态：

kubectl get pods

NAME                                   READY   STATUS             RESTARTS   AGE
kubernetes-nginx-78bcc44665-8fnnn      1/1     Running            1          21h

查看Pod的详细状态，包括IP地址、占用端口、使用镜像等信息；

kubectl describe pods

Name:         kubernetes-nginx-78bcc44665-8fnnn
Namespace:    default
Priority:     0
Node:         minikube/192.168.49.2
Start Time:   Tue, 05 Jan 2021 13:57:46 +0800
Labels:       app=kubernetes-nginx
              pod-template-hash=78bcc44665
              version=v1
Annotations:  <none>
Status:       Running
IP:           172.17.0.7
IPs:
  IP:           172.17.0.7
Controlled By:  ReplicaSet/kubernetes-nginx-78bcc44665
Containers:
  nginx:
    Container ID:   docker://31eb1277e507ec4cf8a27b66a9f4f30fb919d17f4cd914c09eb4cfe8322504b2
    Image:          nginx:1.10
    Image ID:       docker-pullable://nginx@sha256:6202beb06ea61f44179e02ca965e8e13b961d12640101fca213efbfd145d7575
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Wed, 06 Jan 2021 09:22:40 +0800
    Last State:     Terminated
      Reason:       Completed
      Exit Code:    0
      Started:      Tue, 05 Jan 2021 14:24:55 +0800
      Finished:     Tue, 05 Jan 2021 17:32:48 +0800
    Ready:          True
    Restart Count:  1
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-dhr4b (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-dhr4b:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-dhr4b
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:          <none>

将Pod的名称设置为环境变量，方便之后使用 $POD_NAME来应用Pod的名称：

export POD_NAME=kubernetes-nginx-78bcc44665-8fnnn

查看Pod打印的日志：

kubectl logs $POD_NAME

使用 exec可以在Pod的容器中执行命令，这里使用 env命令查看环境变量：

kubectl exec $POD_NAME -- env

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=kubernetes-nginx-78bcc44665-8fnnn
KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
KUBERNETES_SERVICE_HOST=10.96.0.1
KUBERNETES_SERVICE_PORT=443
KUBERNETES_SERVICE_PORT_HTTPS=443
KUBERNETES_PORT=tcp://10.96.0.1:443
KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
KUBERNETES_PORT_443_TCP_PROTO=tcp
KUBERNETES_PORT_443_TCP_PORT=443
NGINX_VERSION=1.10.3-1~jessie
HOME=/root

进入容器内部并执行 bash命令，如果想退出容器可以使用 exit命令：

kubectl exec -ti $POD_NAME -- bash

公开暴露应用

默认Pod无法被集群外部访问，需要创建Service并暴露端口才能被外部访问。

创建一个Service来暴露kubernetes-nginx这个Deployment：

kubectl expose deployment/kubernetes-nginx --type="NodePort" --port 80

查看K8S中所有Service的状态：

kubectl get services

NAME               TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes         ClusterIP   10.96.0.1        <none>        443/TCP        5h16m
kubernetes-nginx   NodePort    10.105.177.114   <none>        80:31891/TCP   5s

查看Service的详情，通过 NodePort属性可以得到暴露到外部的端口；

kubectl describe services/kubernetes-nginx

Name:                     kubernetes-nginx
Namespace:                default
Labels:                   app=kubernetes-nginx
Annotations:              <none>
Selector:                 app=kubernetes-nginx
Type:                     NodePort
IP Families:              <none>
IP:                       10.106.227.54
IPs:                      10.106.227.54
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  30158/TCP
Endpoints:                172.17.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

通过CURL命令通过 Minikube IP:NodePort IP可以访问Nginx服务，此时将打印Nginx主页信息；

curl $(minikube ip):30158

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

标签的使用

通过给资源添加Label，可以方便地管理资源（如Deployment、Pod、Service等）。

查看Deployment中所包含的Label；

kubectl describe deployment

Name:                   kubernetes-nginx
Namespace:              default
CreationTimestamp:      Tue, 05 Jan 2021 13:57:46 +0800
Labels:                 app=kubernetes-nginx
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=kubernetes-nginx
Replicas:               1 desired | 1 updated | 1 total | 1 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge

通过Label查询Pod：

kubectl get pods -l app=kubernetes-nginx

NAME                                READY   STATUS    RESTARTS   AGE
kubernetes-nginx-78bcc44665-8fnnn   1/1     Running   1          21h

通过Label查询Service：

kubectl get services -l app=kubernetes-nginx

NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes-nginx   NodePort   10.106.227.54   <none>        80:30158/TCP   4m44s

给Pod添加Label：

kubectl label pod $POD_NAME version=v1

查看Pod的详细信息，可以查看Label信息：

kubectl describe pods $POD_NAME

Name:         kubernetes-nginx-78bcc44665-8fnnn
Namespace:    default
Priority:     0
Node:         minikube/192.168.49.2
Start Time:   Tue, 05 Jan 2021 13:57:46 +0800
Labels:       app=kubernetes-nginx
              pod-template-hash=78bcc44665
              version=v1

通过Label查询Pod：

kubectl get pods -l version=v1

通过Label删除服务：

kubectl delete service -l app=kubernetes-nginx

NAME               TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes         ClusterIP   10.96.0.1       <none>        443/TCP        30h

可视化管理

Dashboard是基于网页的K8S用户界面。你可以使用Dashboard将容器应用部署到K8S集群中，也可以对容器应用排错，还能管理集群资源。

查看Minikube内置插件，默认情况下Dashboard插件未启用：

minikube addons list

|-----------------------------|----------|--------------|
|         ADDON NAME          | PROFILE  |    STATUS    |
|-----------------------------|----------|--------------|
| dashboard                   | minikube | disabled     |
| default-storageclass        | minikube | enabled ✅   |
|-----------------------------|----------|--------------|

启用Dashboard插件：

minikube addons enable dashboard

开启Dashboard，通过 --url参数不会打开管理页面，并可以在控制台获得访问路径：

minikube dashboard --url

* Verifying dashboard health ...
* Launching proxy ...
* Verifying proxy health ...
http://127.0.0.1:44469/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/

要想从外部访问Dashboard，需要从使用kubectl设置代理才行， --address设置为你的服务器地址；

kubectl proxy --port=44469 --address='192.168.5.94' --accept-hosts='^.*' &

从外部访问服务器需要开启防火墙端口；

# 切换到root用户
su -
# 开启端口
firewall-cmd --zone=public --add-port=44469/tcp --permanent
# 重启防火墙
firewall-cmd --reload

通过如下地址即可访问Dashboard：

http://192.168.5.94:44469/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/

查看K8S集群中的资源状态信息：

通过yaml脚本创建K8S资源：

查看K8S中所有Pod的状态信息，通过更多按钮可以查看容器日志和执行内部命令。

总结

当我们的应用需要部署在多个物理机上时，传统的做法是一个个物理机器去部署。如果我们使用了K8S的话，就可以把这些物理机认为是一个集群，只需通过K8S把应用部署到集群即可，无需关心物理机的部署细节。同时K8S提供了水平扩容、自动装箱、自动修复等功能，大大减少了应用集群化部署的工作量。

参考资料

官方文档：https://kubernetes.io/zh/docs/home/