【K8s】资源管理与实战入门

╰半夏微凉° 2023-10-09 22:12 76阅读 0赞

#### 文章目录 ####

*  一、资源管理
 *   *  1、资源管理介绍
     *  2、YAML语言语法
     *  3、资源管理方式
     *  4、命令式对象管理--kubectl
     *  5、命令式对象配置
     *  6、声明式对象配置
     *  7、报错
 *  二、实战入门
 *   *  1、namespace
     *  2、Pod
     *  3、Label
     *  4、deployment
     *  5、Service

## 一、资源管理 ##

### 1、资源管理介绍 ###

在kubernetes中，所有的内容都抽象为资源，用户需要通过操作资源来管理kubernetes。

> kubernetes的本质上就是一个集群系统，用户可以在集群中部署各种服务，所谓的部署服务，其实就是在kubernetes集群中运行一个个的容器，并将指定的程序跑在容器中。  
>   
>

> kubernetes的最小管理单元是pod而不是容器，所以只能将容器放在Pod中，而kubernetes一般也不会直接管理Pod，而是`通过Pod控制器来管理Pod`的。  
>   
>

> Pod可以提供服务之后，就要考虑如何访问Pod中服务，kubernetes提供了Service资源实现这个功能。

> Pod中程序的数据有的需要持久化，kubernetes还提供了各种存储系统。

![在这里插入图片描述][3d6f64039d4b48eebef431458ac96278.png]

### 2、YAML语言语法 ###

YAML是一个类似 XML、JSON 的标记性语言。它强调`以数据为中心`，并不是以标识语言为重点。因而YAML本身的定义比较简单，号称"一种人性化的数据格式语言"。

<code9527>
        <age>23</age>
        <address>tianjin</address>
    </code9527>

code9527:
      age: 23
      address: tianjin

以上两个例子，传达的信息一样，从这里可以看出yaml的"以数据为中心"。

YAML的语法比较简单，主要有下面几个：

*  大小写敏感
 *  使用缩进表示层级关系
 *  缩进不允许使用tab，只允许空格( 低版本限制 )
 *  缩进的空格数不重要，只要相同层级的元素左对齐即可
 *  '\#'表示注释

YAML支持以下几种数据类型：

*  纯量：单个的、不可再分的值
 *  对象：键值对的集合，又称为映射（mapping）/ 哈希（hash） / 字典（dictionary）
 *  数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）

# 纯量, 就是指的一个简单的值，字符串、布尔值、整数、浮点数、Null、时间、日期
    # 1 布尔类型
    c1: true (或者True)
    # 2 整型
    c2: 234
    # 3 浮点型
    c3: 3.14
    # 4 null类型 
    c4: ~  # 使用~表示null
    # 5 日期类型
    c5: 2018-02-17    # 日期必须使用ISO 8601格式，即yyyy-MM-dd
    # 6 时间类型
    c6: 2018-02-17T15:02:31+08:00  # 时间使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区
    # 7 字符串类型
    c7: code     # 简单写法，直接写值 , 如果字符串中间有特殊字符，必须使用双引号或者单引号包裹 
    c8: line1
        line2     # 字符串过多的情况可以拆成多行，每一行会被转化成一个空格

对象形式：

# 对象
    # 形式一(推荐):
    code9527:
      age: 23
      address: tianjin
    # 形式二(了解):
    code9527: {
        age: 23,address: tianjin}

数组形式：

# 数组
    # 形式一(推荐):
    address:
      - 滨海
      - 南开  
    # 形式二(了解):
    address: [滨海,南开]

需要注意的三点是：

*  书写yaml要记得在key后面要加一个空格
 *  如果需要将多段yaml配置放在一个文件中，中间要使用—分隔
 *  yaml转json的网站：[https://www.json2yaml.com/convert-yaml-to-json][https_www.json2yaml.com_convert-yaml-to-json]。可以通过它验证yaml是否书写正确

### 3、资源管理方式 ###

*  命令式对象管理：直接使用命令去操作kubernetes资源

kubectl run nginx-pod --image=nginx:1.17.1 --port=80

*  命令式对象配置：通过命令配置和配置文件去操作kubernetes资源

kubectl create/patch -f nginx-pod.yaml

*  声明式对象配置：通过apply命令和配置文件去操作kubernetes资源

kubectl apply -f nginx-pod.yaml

三者的优缺点比较：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>操作对象</th> 
   <th>适用环境</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>命令式对象管理</td> 
   <td>对象</td> 
   <td>测试</td> 
   <td>简单</td> 
   <td>只能操作活动对象，无法审计、跟踪</td> 
  </tr> 
  <tr> 
   <td>命令式对象配置</td> 
   <td>文件</td> 
   <td>开发</td> 
   <td>可以审计、跟踪</td> 
   <td>项目大时，配置文件多，操作麻烦</td> 
  </tr> 
  <tr> 
   <td>声明式对象配置</td> 
   <td>目录</td> 
   <td>开发</td> 
   <td>支持目录操作</td> 
   <td>意外情况下难以调试</td> 
  </tr> 
 </tbody> 
</table>

### 4、命令式对象管理–kubectl ###

kubectl是kubernetes集群的命令行工具，通过它能够对集群本身进行管理，并能够在集群上进行容器化应用的安装部署。语法：

kubectl [command] [type] [name] [flags]
    ----
    - comand：指定要对资源执行的操作，例如create、get、delete
    
    - type：指定资源类型，比如deployment、pod、service
    
    - name：指定资源的名称，名称大小写敏感
    
    - flags：指定额外的可选参数

举例：

# 查看所有pod
    kubectl get pod 
    
    # 查看某个pod
    kubectl get pod pod_name
    
    # 查看某个pod,以yaml格式展示结果
    kubectl get pod pod_name -o yaml

**kubernetes中所有的内容都抽象为资源**，查看资源类型：

kubectl api-resources

常用资源有：

<table> 
 <thead> 
  <tr> 
   <th>资源分类</th> 
   <th>资源名称</th> 
   <th>缩写</th> 
   <th>资源作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>集群级别资源</td> 
   <td>nodes</td> 
   <td>no</td> 
   <td>集群组成部分</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>namespaces</td> 
   <td>ns</td> 
   <td>隔离Pod</td> 
  </tr> 
  <tr> 
   <td>pod资源</td> 
   <td>pods</td> 
   <td>po</td> 
   <td>装载容器</td> 
  </tr> 
  <tr> 
   <td>pod资源控制器</td> 
   <td>replicationcontrollers</td> 
   <td>rc</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>replicasets</td> 
   <td>rs</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>deployments</td> 
   <td>deploy</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>daemonsets</td> 
   <td>ds</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>jobs</td> 
   <td></td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>cronjobs</td> 
   <td>cj</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>horizontalpodautoscalers</td> 
   <td>hpa</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>statefulsets</td> 
   <td>sts</td> 
   <td>控制pod资源</td> 
  </tr> 
  <tr> 
   <td>服务发现资源</td> 
   <td>services</td> 
   <td>svc</td> 
   <td>统一pod对外接口</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>ingress</td> 
   <td>ing</td> 
   <td>统一pod对外接口</td> 
  </tr> 
  <tr> 
   <td>存储资源</td> 
   <td>volumeattachments</td> 
   <td></td> 
   <td>存储</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>persistentvolumes</td> 
   <td>pv</td> 
   <td>存储</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>persistentvolumeclaims</td> 
   <td>pvc</td> 
   <td>存储</td> 
  </tr> 
  <tr> 
   <td>配置资源</td> 
   <td>configmaps</td> 
   <td>cm</td> 
   <td>配置</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>secrets</td> 
   <td></td> 
   <td>配置</td> 
  </tr> 
 </tbody> 
</table>

查看可以对资源能进行哪些操作：

kubectl --help

常用的有：

<table> 
 <thead> 
  <tr> 
   <th>命令分类</th> 
   <th>命令</th> 
   <th>翻译</th> 
   <th>命令作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本命令</td> 
   <td>create</td> 
   <td>创建</td> 
   <td>创建一个资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>edit</td> 
   <td>编辑</td> 
   <td>编辑一个资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>get</td> 
   <td>获取</td> 
   <td>获取一个资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>patch</td> 
   <td>更新</td> 
   <td>更新一个资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>delete</td> 
   <td>删除</td> 
   <td>删除一个资源</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>explain</td> 
   <td>解释</td> 
   <td>展示资源文档</td> 
  </tr> 
  <tr> 
   <td>运行和调试</td> 
   <td>run</td> 
   <td>运行</td> 
   <td>在集群中运行一个指定的镜像</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>expose</td> 
   <td>暴露</td> 
   <td>暴露资源为Service</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>describe</td> 
   <td>描述</td> 
   <td>显示资源内部信息</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>logs</td> 
   <td>日志输出容器在 pod 中的日志</td> 
   <td>输出容器在 pod 中的日志</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>attach</td> 
   <td>缠绕进入运行中的容器</td> 
   <td>进入运行中的容器</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>exec</td> 
   <td>执行容器中的一个命令</td> 
   <td>执行容器中的一个命令</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>cp</td> 
   <td>复制</td> 
   <td>在Pod内外复制文件</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>rollout</td> 
   <td>首次展示</td> 
   <td>管理资源的发布</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>scale</td> 
   <td>规模</td> 
   <td>扩(缩)容Pod的数量</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>autoscale</td> 
   <td>自动调整</td> 
   <td>自动调整Pod的数量</td> 
  </tr> 
  <tr> 
   <td>高级命令</td> 
   <td>apply</td> 
   <td>rc</td> 
   <td>通过文件对资源进行配置</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>label</td> 
   <td>标签</td> 
   <td>更新资源上的标签</td> 
  </tr> 
  <tr> 
   <td>其他命令</td> 
   <td>cluster-info</td> 
   <td>集群信息</td> 
   <td>显示集群信息</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>version</td> 
   <td>版本</td> 
   <td>显示当前Server和Client的版本</td> 
  </tr> 
 </tbody> 
</table>

实例：

# 创建一个namespace
    [root@master ~] kubectl create namespace dev
    namespace/dev created
    
    # 获取namespace
    [root@master ~] kubectl get ns
    NAME              STATUS   AGE
    default           Active   21h
    dev               Active   21s
    kube-node-lease   Active   21h
    kube-public       Active   21h
    kube-system       Active   21h
    
    # 在此namespace下创建并运行一个nginx的Pod
    [root@master ~] kubectl run pod --image=nginx:latest -n dev
    kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
    deployment.apps/pod created
    
    # 查看新创建的pod
    # 不指定ns，默认查看default命名空间下的
    [root@master ~] kubectl get pod -n dev
    NAME  READY   STATUS    RESTARTS   AGE
    pod   1/1     Running   0          21s
    
    # 删除指定的pod
    [root@master ~] kubectl delete pod pod
    pod "pod" deleted
    
    # 删除指定的namespace
    [root@master ~] kubectl delete ns dev
    namespace "dev" deleted

### 5、命令式对象配置 ###

即使用命令配合配置文件一起来操作kubernetes资源

*  创建一个nginxpod.yaml

apiVersion: v1
    kind: Namespace
    metadata:
      name: dev
    
    ---
    
    apiVersion: v1
    kind: Pod
    metadata:
      name: nginxpod
      namespace: dev
    spec:
      containers:
      - name: nginx-containers
        image: nginx:latest

*  执行create命令，创建资源：

[root@master ~] kubectl create -f nginxpod.yaml
    namespace/dev created
    pod/nginxpod created
    # 成功创建了两个资源对象，分别是namespace和pod

*  查看资源，注意后面的`-f xx.yaml`

[root@master ~]  kubectl get -f nginxpod.yaml
    NAME            STATUS   AGE
    namespace/dev   Active   18s
    
    NAME            READY   STATUS    RESTARTS   AGE
    pod/nginxpod    1/1     Running   0          17s

*  删除资源，注意后面的`-f xx.yaml`

[root@master ~] kubectl delete -f nginxpod.yaml
    namespace "dev" deleted
    pod "nginxpod" deleted

**总结:**

命令式对象配置的方式操作资源，可以简单的认为：kubeclt + 操作动词  +  yaml配置文件（里面是命令需要的各种参数）

### 6、声明式对象配置 ###

与命令式对象配置很相似，但是它只有一个命令apply，因此只能用于新增和更新

# 首先执行一次kubectl apply -f yaml文件，发现创建了资源
    [root@master ~]  kubectl apply -f nginxpod.yaml
    namespace/dev created
    pod/nginxpod created
    
    # 再次执行一次kubectl apply -f yaml文件，发现说资源没有变动
    [root@master ~]  kubectl apply -f nginxpod.yaml
    namespace/dev unchanged
    pod/nginxpod unchanged
    
    #可以看出创建/更新资源，直接用apply更方便

**总结：**

其实声明式对象配置就是使用apply描述一个资源最终的状态（在yaml中定义状态）
    
    使用apply操作资源：
        如果资源不存在，就创建，相当于 kubectl create
        如果资源已存在，就更新，相当于 kubectl patch

### 7、报错 ###

在node节点上执行kubectl指令操作资源：

[root@node1 ~] kubectl get nodes
    The connection to the server localhost:8080 was refused - did you specify the right host or port?

kubectl的运行是需要进行配置的，它的配置文件是$HOME/.kube，因此想要在node节点运行此命令，需将master上的.kube文件复制到node节点上：

scp  -r  HOME/.kube   node1: HOME/

## 二、实战入门 ##

在kubernetes集群中部署一个nginx服务，并且能够对其进行访问。先简单操作一下几个常用资源，后续章节分开整理每种资源。

### 1、namespace ###

namespace用来实现多套环境的资源隔离或者多租户的资源隔离：

*  默认情况下，kubernetes集群中的所有的Pod都是可以相互访问的。
 *  若不想让两个pod互相访问，可将pod划分到不同的namespace

> Kubernetes通过将集群内部的资源分配到不同的Namespace中，可以形成逻辑上的"组"，以方便不同的组的资源进行隔离使用和管理。  
>   
>   
> 可以通过kubernetes的`授权机制`，将不同的namespace交给不同租户进行管理，这样就实现了多租户的资源隔离。此时还能结合kubernetes的`资源配额机制，`限定不同租户能占用的资源，例如CPU使用量、内存使用量等等，来实现租户可用资源的管理。

![在这里插入图片描述][7a8da48b45cf43308ef955f07dead491.png]  
kubernetes在集群启动之后，会默认创建几个namespace：

[root@master ~]# kubectl  get namespace
    NAME              STATUS   AGE
    default           Active   45h     #  所有未指定Namespace的对象都会被分配在default命名空间
    kube-node-lease   Active   45h     #  集群的节点之间的心跳维护，v1.13开始引入
    kube-public       Active   45h     #  此命名空间下的资源可以被所有人访问（包括未认证用户）
    kube-system       Active   45h     #  所有由Kubernetes系统自身创建的资源都处于这个命名空间

> 查看namespace

# 1 查看所有的ns  命令：kubectl get ns
    [root@master ~] kubectl get ns
    NAME              STATUS   AGE
    default           Active   45h
    kube-node-lease   Active   45h
    kube-public       Active   45h     
    kube-system       Active   45h     
    
    # 2 查看指定的ns   命令：kubectl get ns ns名称
    [root@master ~] kubectl get ns default
    NAME      STATUS   AGE
    default   Active   45h
    
    # 3 指定输出格式  命令：kubectl get ns ns名称  -o 格式参数
    # kubernetes支持的格式有很多，比较常见的是wide、json、yaml
    [root@master ~] kubectl get ns default -o yaml
    apiVersion: v1
    kind: Namespace
    metadata:
      creationTimestamp: "2021-05-08T04:44:16Z"
      name: default
      resourceVersion: "151"
      selfLink: /api/v1/namespaces/default
      uid: 7405f73a-e486-43d4-9db6-145f1409f090
    spec:
      finalizers:
      - kubernetes
    status:
      phase: Active
      
    # 4 查看ns详情  命令：kubectl describe ns ns名称
    [root@master ~] kubectl describe ns default
    Name:         default
    Labels:       <none>
    Annotations:  <none>
    Status:       Active  # Active 命名空间正在使用中  Terminating 正在删除命名空间
    
    # ResourceQuota 针对namespace做的资源限制
    # LimitRange针对namespace中的每个组件做的资源限制
    No resource quota.
    No LimitRange resource.

> 创建namespace

# 创建namespace
    [root@master ~] kubectl create ns dev
    namespace/dev created

> 删除namespace

# 删除namespace
    [root@master ~] kubectl delete ns dev
    namespace "dev" deleted

> 以配置文件操作namespace

apiVersion: v1
    kind: Namespace
    metadata:
      name: dev

# 创建：
    kubectl create -f ns-dev.yaml
    #删除：
    kubectl delete -f ns-dev.yaml

### 2、Pod ###

Pod是kubernetes集群进行管理的`最小单元`，程序要运行必须部署在容器中，而容器必须存在于Pod中。

Pod可以认为是容器的封装，一个Pod中可以存在一个或者多个容器。

![在这里插入图片描述][954e4f02397441d0b89e71b21b232e07.png]  
图中最下面的容器是根容器，上面的是用户容器（后面章节详解）

kubernetes在集群启动之后，`集群中的各个组件也都是以Pod方式运行的`：

# Kubernetes系统自身创建的资源都在kube-system这个ns
    [root@master ~] kubectl get pod -n kube-system
    NAMESPACE     NAME                             READY   STATUS    RESTARTS   AGE
    kube-system   coredns-6955765f44-68g6v         1/1     Running   0          2d1h
    kube-system   coredns-6955765f44-cs5r8         1/1     Running   0          2d1h
    kube-system   etcd-master                      1/1     Running   0          2d1h
    kube-system   kube-apiserver-master            1/1     Running   0          2d1h
    kube-system   kube-controller-manager-master   1/1     Running   0          2d1h
    kube-system   kube-flannel-ds-amd64-47r25      1/1     Running   0          2d1h
    kube-system   kube-flannel-ds-amd64-ls5lh      1/1     Running   0          2d1h
    kube-system   kube-proxy-685tk                 1/1     Running   0          2d1h
    kube-system   kube-proxy-87spt                 1/1     Running   0          2d1h
    kube-system   kube-scheduler-master            1/1     Running   0          2d1h

> 创建pod

kubernetes没有提供单独运行Pod的命令，都`是通过Pod控制器来实现`的。

# 命令格式： kubectl run (pod控制器名称) [参数] 
    # --image  指定Pod的镜像
    # --port   指定端口
    # --namespace  指定namespace
    [root@master ~] kubectl run nginx --image=nginx:latest --port=80 --namespace dev 
    deployment.apps/nginx created

> 查看pod的信息

# 查看Pod基本信息
    # 1/1即一个容器（根容器不计算在内，默认就有）
    [root@master ~] kubectl get pods -n dev
    NAME    READY   STATUS    RESTARTS   AGE
    nginx   1/1     Running   0          43s
    
    # 查看更多，比如调度在哪个节点上运行
    [root@master ~] kubectl get pods -n dev
    NAME    READY   STATUS    RESTARTS   AGE   IP           NODE
    nginx   1/1     Running   0          43s   10.244.2.8   node2 
    # 查看Pod的详细信息
    [root@master ~] kubectl describe pod nginx -n dev
    Name:         nginx
    Namespace:    dev
    Priority:     0
    Node:         node1/192.168.5.4
    Start Time:   Wed, 08 May 2021 09:29:24 +0800
    Labels:       pod-template-hash=5ff7956ff6
                  run=nginx
    Annotations:  <none>
    Status:       Running
    IP:           10.244.1.23
    IPs:
      IP:           10.244.1.23
    Controlled By:  ReplicaSet/nginx
    Containers:
      nginx:
        Container ID:   docker://4c62b8c0648d2512380f4ffa5da2c99d16e05634979973449c98e9b829f6253c
        Image:          nginx:latest
        Image ID:       docker-pullable://nginx@sha256:485b610fefec7ff6c463ced9623314a04ed67e3945b9c08d7e53a47f6d108dc7
        Port:           80/TCP
        Host Port:      0/TCP
        State:          Running
          Started:      Wed, 08 May 2021 09:30:01 +0800
        Ready:          True
        Restart Count:  0
        Environment:    <none>
        Mounts:
          /var/run/secrets/kubernetes.io/serviceaccount from default-token-hwvvw (ro)
    Conditions:
      Type              Status
      Initialized       True
      Ready             True
      ContainersReady   True
      PodScheduled      True
    Volumes:
      default-token-hwvvw:
        Type:        Secret (a volume populated by a Secret)
        SecretName:  default-token-hwvvw
        Optional:    false
    QoS Class:       BestEffort
    Node-Selectors:  <none>
    Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                     node.kubernetes.io/unreachable:NoExecute for 300s
    Events:
      Type    Reason     Age        From               Message
      ----    ------     ----       ----               -------
      Normal  Scheduled  <unknown>  default-scheduler  Successfully assigned dev/nginx-5ff7956ff6-fg2db to node1
      Normal  Pulling    4m11s      kubelet, node1     Pulling image "nginx:latest"
      Normal  Pulled     3m36s      kubelet, node1     Successfully pulled image "nginx:latest"
      Normal  Created    3m36s      kubelet, node1     Created container nginx
      Normal  Started    3m36s      kubelet, node1     Started container nginx

> 访问pod

# 获取podIP
    # 注意这个IP会随着pod的重新创建而改变
    [root@master ~] kubectl get pods -n dev -o wide
    NAME    READY   STATUS    RESTARTS   AGE    IP             NODE    ... 
    nginx   1/1     Running   0          190s   10.244.1.23   node1   ...
    
    #访问POD
    [root@master ~] curl http://10.244.1.23:80
    <!DOCTYPE html>
    <html>
    <head>
    	<title>Welcome to nginx!</title>
    </head>
    <body>
    	<p><em>Thank you for using nginx.</em></p>
    </body>
    </html>

> 删除pod

# 删除指定Pod
    [root@master ~] kubectl delete pod nginx -n dev
    pod "nginx" deleted
    
    # 此时，显示删除Pod成功，但是再查询，发现又新产生了一个 
    [root@master ~] kubectl get pods -n dev
    NAME    READY   STATUS    RESTARTS   AGE
    nginx   1/1     Running   0          21s
    
    # 这是因为当前Pod是由Pod控制器创建的，控制器会监控Pod状况，一旦发现Pod死亡，会立即重建
    # 此时要想删除Pod，必须删除Pod控制器
    
    # 先来查询一下当前namespace下的Pod控制器
    [root@master ~] kubectl get deploy -n  dev
    NAME    READY   UP-TO-DATE   AVAILABLE   AGE
    nginx   1/1     1            1           9m7s
    
    # 接下来，删除此PodPod控制器
    [root@master ~] kubectl delete deploy nginx -n dev
    deployment.apps "nginx" deleted
    
    # 稍等片刻，再查询Pod，发现Pod被删除了
    [root@master ~] kubectl get pods -n dev
    No resources found in dev namespace.

> 配置操作pod

创建一个pod-nginx.yaml：

apiVersion: v1
    kind: Pod
    metadata:
      name: nginx
      namespace: dev
    spec:
      containers:
      - image: nginx:latest
        name: pod
        ports:
        - name: nginx-port
          containerPort: 80
          protocol: TCP

# 创建：
    kubectl create -f pod-nginx.yaml
    
    # 删除：
    kubectl delete -f pod-nginx.yaml

### 3、Label ###

Label的作用就是在资源上添加标识，用来对它们进行`区分和选择`。特点：

*  一个Label会以key/value键值对的形式附加到各种对象上，如Node、Pod、Service等等
 *  一个资源对象可以定义任意数量的Label ，同一个Label也可以被添加到任意数量的资源对象上去
 *  Label通常在资源对象定义时确定，当然也可以在对象创建后动态添加或者删除

![在这里插入图片描述][f7ca3f8a85904e92b108501995411273.png]

一些常用的Label 示例如下：
    
    版本标签："version":"release", "version":"stable"......
    环境标签："environment":"dev"，"environment":"test"，"environment":"pro"
    架构标签："tier":"frontend"，"tier":"backend"

给资源打上标签后，怎么按标签去挑：

*  Label用于给某个资源对象定义标识
 *  `Label Selector，标签选择器。`用于查询和筛选拥有某些标签的资源对象

当前有两种Label Selector：
    
    1）基于等式的Label Selector
    
    name = slave: 选择所有包含Label中key="name"且value="slave"的对象
    
    env != production: 选择所有包括Label中的key="env"且value不等于"production"的对象
    
    2）基于集合的Label Selector
    
    name in (master, slave): 选择所有包含Label中的key="name"且value="master"或"slave"的对象
    
    name not in (frontend): 选择所有包含Label中的key="name"且value不等于"frontend"的对象

标签的选择条件可以使用多个，此时将多个Label Selector进行组合，使用逗号","进行分隔即可。例如：

name=slave，env!=production
    
    name not in (frontend)，env!=production

> 命令方式对标签进行：增删改查

# 为pod资源打标签
    [root@master ~] kubectl label pod nginx-pod version=1.0 -n dev
    pod/nginx-pod labeled
    
    # 为pod资源更新标签
    [root@master ~] kubectl label pod nginx-pod version=2.0 -n dev --overwrite
    pod/nginx-pod labeled
    
    # 查看标签
    [root@master ~] kubectl get pod nginx-pod  -n dev --show-labels
    NAME        READY   STATUS    RESTARTS   AGE   LABELS
    nginx-pod   1/1     Running   0          10m   version=2.0
    
    # 筛选标签
    [root@master ~] kubectl get pod -n dev -l version=2.0  --show-labels
    NAME        READY   STATUS    RESTARTS   AGE   LABELS
    nginx-pod   1/1     Running   0          17m   version=2.0
    [root@master ~] kubectl get pod -n dev -l version!=2.0 --show-labels
    No resources found in dev namespace.
    
    #删除标签
    # key-
    [root@master ~] kubectl label pod nginx-pod version- -n dev
    pod/nginx-pod labeled

> 通过配置操作标签

apiVersion: v1
    kind: Pod
    metadata:
      name: nginx
      namespace: dev
      labels:
        version: "3.0" 
        env: "test"
    spec:
      containers:
      - image: nginx:latest
        name: pod
        ports:
        - name: nginx-port
          containerPort: 80
          protocol: TCP

# 创建对应的资源
    kubectl apply -f pod-nginx.yaml

### 4、deployment ###

在kubernetes中，Pod是最小的控制单元，但是kubernetes很少直接控制Pod，一般都是通过Pod控制器来完成的。

Pod控制器用于pod的管理，确保pod资源符合预期的状态（比如维持pod的数量），当pod的资源出现故障时，会尝试进行重启或重建pod。

deployment就是控制器的一种。

![在这里插入图片描述][aa982e323c974b9d9359b3fafe218532.png]

> 命令方式对deployment进行：增删改查

命令格式: kubectl create deployment 名称  [参数] 
    
    # --port   指定端口
    # --replicas  指定创建pod数量
    # 不同的版本run指令有出入，这个了解一下就行
    [root@master ~] kubectl run nginx --image=nginx:latest --port=80 --replicas=3 -n dev
    deployment.apps/nginx created
    
    # 查看deployment的信息
    [root@master ~] kubectl get deploy,pods -n dev
    NAME    READY   UP-TO-DATE   AVAILABLE   AGE
    nginx   3/3     3            3           2m42s
    
    
    NAME                     READY   STATUS    RESTARTS   AGE
    nginx-5ff7956ff6-6k8cb   1/1     Running   0          19s
    nginx-5ff7956ff6-jxfjt   1/1     Running   0          19s
    nginx-5ff7956ff6-v6jqw   1/1     Running   0          19s

# UP-TO-DATE：成功升级的副本数量
    # AVAILABLE：可用副本的数量
    [root@master ~] kubectl get deploy -n dev -o wide
    NAME    READY UP-TO-DATE  AVAILABLE   AGE     CONTAINERS   IMAGES              SELECTOR
    nginx   3/3     3         3           2m51s   nginx        nginx:latest        run=nginx
    
    # 查看deployment的详细信息
    [root@master ~] kubectl describe deploy nginx -n dev
    Name:                   nginx
    Namespace:              dev
    CreationTimestamp:      Wed, 08 May 2021 11:14:14 +0800
    Labels:                 run=nginx
    Annotations:            deployment.kubernetes.io/revision: 1
    Selector:               run=nginx
    Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
    StrategyType:           RollingUpdate
    MinReadySeconds:        0
    RollingUpdateStrategy:  25% max unavailable, 25% max 违规词汇
    Pod Template:
      Labels:  run=nginx
      Containers:
       nginx:
        Image:        nginx:latest
        Port:         80/TCP
        Host Port:    0/TCP
        Environment:  <none>
        Mounts:       <none>
      Volumes:        <none>
    Conditions:
      Type           Status  Reason
      ----           ------  ------
      Available      True    MinimumReplicasAvailable
      Progressing    True    NewReplicaSetAvailable
    OldReplicaSets:  <none>
    NewReplicaSet:   nginx-5ff7956ff6 (3/3 replicas created)
    Events:
      Type    Reason             Age    From                   Message
      ----    ------             ----   ----                   -------
      Normal  ScalingReplicaSet  5m43s  deployment-controller  Scaled up replicaset nginx-5ff7956ff6 to 3

# 删除 
    [root@master ~] kubectl delete deploy nginx -n dev
    deployment.apps "nginx" deleted

> 使用配置文件操作deployment

创建一个deploy-nginx.yaml：

apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
      namespace: dev
    spec:
      replicas: 3  # 副本数
      selector:
        matchLabels:
          run: nginx  # 标签选择器，通过和pod的标签建立起deploy和pod的关联
      template:
        metadata:
          labels:
            run: nginx
        spec:
          containers:
          - image: nginx:latest
            name: nginx  # pod的标签
            ports:
            - containerPort: 80
              protocol: TCP

# 创建：
    kubectl create -f deploy-nginx.yaml
    
    # 删除：
    kubectl delete -f deploy-nginx.yaml

### 5、Service ###

虽然每个Pod都会分配一个单独的Pod IP，然而却存在如下两问题：

*  Pod IP 会随着Pod的重启产生变化
 *  Pod IP 仅仅是`集群内可见的虚拟IP`，外部无法访问。简单说就是集群内的那几个机器能访问到这个IP。

由此，服务的访问出现困难 ⇒ Service出现。

**Service可以看作是一组同类Pod对外的访问接口。** 借助Service，应用可以方便地实现服务发现和负载均衡。

![在这里插入图片描述][72d3219043e149fbb222c7992c0bfb43.png]

> 创建集群`内部可访问`的Service

# 暴露Service
    # --port=80 --target-port=80 即访问Service的80端口转发到pod的80端口
    [root@master ~] kubectl expose deploy nginx --name=svc-nginx1 --type=ClusterIP --port=80 --target-port=80 -n dev
    service/svc-nginx1 exposed
    
    # 查看service
    [root@master ~] kubectl get svc svc-nginx1 -n dev -o wide
    NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE     SELECTOR
    svc-nginx1   ClusterIP   10.109.179.231   <none>        80/TCP    3m51s   run=nginx

这里产生了一个CLUSTER-IP，这就是service的IP，在Service的生命周期中，这个地址是不会变动的

# 可以通过这个IP访问当前service对应的pod
    [root@master ~] curl 10.109.179.231:80
    <!DOCTYPE html>
    <html>
    <head>
    <title>Welcome to nginx!</title>
    </head>
    <body>
    <h1>Welcome to nginx!</h1>
    .......
    </body>
    </html>

注意：–type=ClusterIP指定的，service的IP也是只能在集群内部访问

> 创建集群`外部也可访问`的Service

如果需要创建外部也可以访问的Service，需要修改`type为NodePort`

# 上面创建的Service的type类型为ClusterIP，这个ip地址只用集群内部可访问
     
    [root@master ~] kubectl expose deploy nginx --name=svc-nginx2 --type=NodePort --port=80 --target-port=80 -n dev
    service/svc-nginx2 exposed

此时查看，会发现出现了NodePort类型的Service，而且有一对Port（80:31556/TC）

[root@master ~] kubectl get svc  svc-nginx2  -n dev -o wide
    NAME          TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE    SELECTOR
    svc-nginx2    NodePort    10.106.91.234      <none>        80:31556/TCP   9s     run=nginx

来直观感受下两种type的Service的区别：

![在这里插入图片描述][bfca8a3f03204bf7a166e12c53437784.png]

接下来就可以通过集群外的主机访问 节点IP:31556访问服务了

# 例如在集群外的服务器中访问下面的地址
    curl 节点IP:31556/

![在这里插入图片描述][abfbe7608c7a40cea78995216bed686a.png]

> 删除Service

[root@master ~] kubectl delete svc svc-nginx-1 -n dev 
    service "svc-nginx-1" deleted

> 通过配置文件操作Service

创建一个svc-nginx.yaml：

apiVersion: v1
    kind: Service
    metadata:
      name: svc-nginx
      namespace: dev
    spec:
      clusterIP: 10.109.179.231 #type: ClusterIP，不写则随机分配
      ports:
      - port: 80
        protocol: TCP
        targetPort: 80
      selector:
        run: nginx
      type: ClusterIP

# 创建：
    kubectl create -f svc-nginx.yaml
    
    # 删除：
    kubectl delete -f svc-nginx.yaml

到此，完成了Namespace、Pod、Deployment、Service资源的基本操作。下一篇对每种资源详细展开。

[3d6f64039d4b48eebef431458ac96278.png]: https://img-blog.csdnimg.cn/3d6f64039d4b48eebef431458ac96278.png
[https_www.json2yaml.com_convert-yaml-to-json]: https://www.json2yaml.com/convert-yaml-to-json
[7a8da48b45cf43308ef955f07dead491.png]: https://img-blog.csdnimg.cn/7a8da48b45cf43308ef955f07dead491.png
[954e4f02397441d0b89e71b21b232e07.png]: https://img-blog.csdnimg.cn/954e4f02397441d0b89e71b21b232e07.png
[f7ca3f8a85904e92b108501995411273.png]: https://img-blog.csdnimg.cn/f7ca3f8a85904e92b108501995411273.png
[aa982e323c974b9d9359b3fafe218532.png]: https://img-blog.csdnimg.cn/aa982e323c974b9d9359b3fafe218532.png
[72d3219043e149fbb222c7992c0bfb43.png]: https://img-blog.csdnimg.cn/72d3219043e149fbb222c7992c0bfb43.png
[bfca8a3f03204bf7a166e12c53437784.png]: https://img-blog.csdnimg.cn/bfca8a3f03204bf7a166e12c53437784.png
[abfbe7608c7a40cea78995216bed686a.png]: https://img-blog.csdnimg.cn/abfbe7608c7a40cea78995216bed686a.png