03-K8S Basic-kubernetes应用快速入门

Posted Devops代哲

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了03-K8S Basic-kubernetes应用快速入门相关的知识,希望对你有一定的参考价值。

回顾

  • k8s有三个网络
    • 节点网络
    • pod网络
    • service网络
  • 整个K8S系统不过是在master上控制层面有三个核心组件
    • 1.平面控制 API Server(唯一可以接入API Server就是master主机的6443端口)
      • 部署完成后默认监控在master节点的6443端口上
      • 唯一可以介入到API Server的接口就是master主机节点地址的6443端口
      • API Server默认情况下要做用户认证
    • 2、Scheduler负责调度某一node节点来运行pod
    • 3、Contorller 控制器(统称)
    • 4、Service

一、kubectl就是API Server客户端程序

1.1、API Server介绍

  • k8s API Server提供了k8s各类资源对象(pod,RC,Service等)的增删改查及watch等HTTP Rest接口,是整个系统的数据总线和数据中心。

1.1.1、API Server的功能

  • API资源类型

image

  • kubernetes API Server的功能(唯一可以接入API Server就是master主机的6443端口):

    • 提供了集群管理的REST API接口(包括认证授权、数据校验以及集群状态变更); (REST API表征状态转移)
    • 提供其他模块之间的数据交互和通信的枢纽(其他模块通过API Server查询或修改数据,只有API Server才直接操作etcd);
    • 是资源配额控制的入口;
    • 拥有完备的集群安全机制.
  • API Server资源

    • api接口中的资源分成多个逻辑组合
    • 每个组合:API Group,api群组
    • 每个组可以独立演进
    • 每个组还可以多版本并存
  • 资源对象的配置格式

    • API Server接受和返回的所有JSON对象都遵循同一个模式,它们都具有“Kind" 和 “api version” 字段,用于标识对象所属的资源类型、API群组及相关的版本
    • 大多数的对象或列表类型的资源还具有三个嵌套型的字典 metadata、apec和status
      • metadata : 字段为资源提供的元数据信息,例如:名称、隶属的名称空间和标签等
      • apec:用于定义用户期望的状态,不同的资源类型,其状态的意义各有不同,例如pod资源最为核心的功能在于运行容器
      • stats :则记录着活动对象当前的状态,它由kubernetes系统自行维护,对于用户来说为只读字段
    • kubectl api-resources 命令可以获取集群支持使用的所有资源类型
  • 和解循环(Reconciliation Loop)

    • 客户端向API Server提交POST请求以创建对象
      • 通过JSON格式的body提交
      • YAML格式需要事先完成向JSON的转换
      • 对象配置信息保存于etcd中,其定义出的状态也成为“期望的状态(Spec)”
    • stats由控制器通过各界循环(loop)不间断地监控着相关地对象地状态,在对象地当前状态发生改变时运行合适地操作当前状态无限接近期望地状态

image

  • 管理资源对象

image

1.1.2、kube-apiserver工作原理

  • kube-apiserver提供了k8s的rest api,实现了认证、授权和准入控制等安全功能,同时也负责了集群状态的存储操作。
  • kube-apiserver工作原理图

image

  • rest api

    • kube-apiserver支持同时提供https和http api,其中http api是非安全接口,不做任何认证授权机制,不建议生产环境启用,但两个接口提供的rest api格式相同。
    • https api 默认监听在6443端口(–secure-port=6443);
    • http api 默认监听在127.0.0.1的8080端口(使用参数 --insecure-port=8080);
  • 访问控制说明

    • k8s api 每个请求都会经过多阶段的访问控制才会被接受,包括认证、授权及准入控制等。
    • 认证
      • 开启TLS情况下,所有请求都需要首先认证。k8s支持多种认证机制,并且支持同时开启多个认证插件(仅一个认证通过即可),如认证成功,则用户的username会传入授权模块做进一步的授权验证,而认证失败的请求则返回http 401
    • 授权
      • 认证之后的请求就到了授权模块,和认证类似,k8s也支持多种授权机制,并支持同时开启多个授权插件(仅一个验证通过即可)。如授权成功,则用户的请求会发送到准入控制模块做进一步的请求验证,失败的请求则返回http403
    • 准入控制
      • 用来对请求做进一步的验证或添加默认参数,不同于认证和授权只关心请求的用户和操作,准入控制还会处理请求的内容,并且仅对创建、更新、删除或连接(如代理)等有效,而对读操作无效。准入控制也支持同时开启多个插件,但他们是依次调用的,只有全部插件都通过的请求才可以允许进入系统

1.1.3、访问kubernetes API

k8s通过kube-apiserver这个进程提供服务,该进程运行在单个k8s-master节点上,默认有两个端口。

  • 本地端口

    • 1.该端口用于接收HTTP请求;
    • 2.该端口默认值为8080,可以通过API Server的启动参数“–insecure-port”的值来修改默认值;
    • 3.默认的IP地址为“localhost”,可以通过启动参数“–insecure-bind-address”的值来修改该IP地址;
    • 4.非认证或授权的HTTP请求通过该端口访问API Server;
  • 安全端口

    • 1.该端口默认值为6443,可通过启动参数“–secure-port”的值来修改默认值;
    • 2.默认IP地址为非本地(Non-Localhost)网络端口,通过启动参数“–bind-address”设置该值;
    • 3.该端口用于接收HTTPS请求;
    • 4.用于基于Tocken文件或客户端证书及HTTP Base的认证;
    • 5.用于基于策略的授权;
    • 6.默认不启动HTTPS安全访问控制
1.1.3.1、直接访问api(了解即可)
  • 通过本地8080端口使用curl命令能直接获取REST api的信息,例如:
查看所有支持的api
    ~]# kubectl api-versions
        admissionregistration.k8s.io/v1
        admissionregistration.k8s.io/v1beta1
        apiextensions.k8s.io/v1
        apiextensions.k8s.io/v1beta1
        apiregistration.k8s.io/v1
        apiregistration.k8s.io/v1beta1
        apps/v1                    # 控制器API群组
        authentication.k8s.io/v1
        authentication.k8s.io/v1beta1
        authorization.k8s.io/v1
        authorization.k8s.io/v1beta1
        autoscaling/v1
        autoscaling/v2beta1
        autoscaling/v2beta2
        batch/v1
        batch/v1beta1
        certificates.k8s.io/v1beta1
        coordination.k8s.io/v1
        coordination.k8s.io/v1beta1
        csi.storage.k8s.io/v1alpha1
        events.k8s.io/v1beta1
        extensions/v1beta1
        metrics.k8s.io/v1beta1
        networking.k8s.io/v1
        networking.k8s.io/v1beta1
        node.k8s.io/v1beta1
        policy/v1beta1
        rbac.authorization.k8s.io/v1
        rbac.authorization.k8s.io/v1beta1
        scheduling.k8s.io/v1
        scheduling.k8s.io/v1beta1
        storage.k8s.io/v1
        storage.k8s.io/v1beta1
        v1                       #pod为api核心版本的v1当中
 
 
 
 
 
查看版本:
       curl  127.0.0.1:8080/api
查看支持的资源对象:
       curl  127.0.0.1:8080/api/v1
查看资源对象信息:
       curl  127.0.0.1:8080/api/v1/nodes
       curl  127.0.0.1:8080/api/v1/pods
       curl  127.0.0.1:8080/api/v1/services
       curl  127.0.0.1:8080/api/v1/replicationcontrollers
具体到某一个具体的对象:
       curl 127.0.0.1:8080/api/v1/nodes/10.0.0.3
指定不同namespace中的对象进行访问:
       curl  http://127.0.0.1:8080/api/v1/namespaces/default/services/php-apache
直接访问后端服务内容:
       curl  http://127.0.0.1:8080/api/v1/namespaces/default/services/http:tomcat-service:/proxy/
       curl  http://127.0.0.1:8080/api/v1/namespaces/default/services/http:php-apache:/proxy/
其他的API信息:
       curl 127.0.0.1:8080/apis/batch/v1

1.1.3.2、Kubernetes Proxy

  • Kubernetes Proxy主要用于代理REST请求。 可以通过这种代理方式将API Server收到的REST请求转发到某个Node上的kubelet上,由Kubelet负责响应。
创建一个Proxy 接口(此处创建一个监听本地10.0.0.1上的8001端口):
    kubectl proxy --port=8001 --accept-hosts=\'.*\' --address=\'10.0.0.1\' &
 
 
 如果需要对访问的资源和源地址进行限制,可以使用正则进行匹配,限制对services进行访问:
     kubectl  proxy --port=8001  --accept-hosts=\'.*\'  --address=10.0.0.1  --reject-paths=\'^/api/v1/services\'
 
 
通过此端口可以在外部直接访问此api代理,在新的版本中,访问方式和常规访问的URL一致:
    curl  http://10.0.0.1:8001/api/v1/pods
    curl  http://10.0.0.1:8001/api/v1/nodes
    curl  http://10.0.0.1:8001/api/v1/services
    curl  http://10.0.0.1:8001/api/v1/replicationcontrollers
    curl  http://10.0.0.1:8001/api/v1/namespaces/default/pods/tomcat-deployment-65799d5fc4-5dx4h
    curl  http://10.0.0.1:8001/api/v1/namespaces/default/services/http:php-apache:/proxy/
    curl  10.0.0.1:8001/apis/batch/v1

1.2、API Server客户端-kubectl

1.2.1、kubectl概述

  • kubectl是Kubernetes集群的命令行工具,通过kubectl能够对集群本身进行管理,并能够在集群上进行容器化应用的安装部署。运行kubectl命令的语法如下所示:
$ kubectl [command] [TYPE] [NAME] [flags]
 
 
#comand:
    指定要对资源执行的操作,例如:create、get、describe和delete
 
 
#type:
    指定资源类型,资源类型是大小敏感的。开发者能够以单数、复数和缩略的形式,例如:
    $ kubectl get pod pod1
    $ kubectl get pods pod1
    $ kubectl get po pod1
 
 
#name:
    指定资源的名称,名称也是大小写敏感的,如果省略名称,则会显示所有资源,例如:
    $ kubectl get pods
 
 
#flags:
    指定可选的参数,例如,使用-s或者--server参数指定kubernetes API Server的地址和端口
    另外,可以通过kubectl help获取更多的信息
 
 
~]# kubectl
#新手使用的基本命令
Basic Commands (Beginner):
  create         Create a resource from a file or from stdin.  在服务器上增加一个资源
  expose         使用 replication controller, service, deployment 或者 pod 并暴露它作为一个 新的Kubernetes Service
  run            在集群中运行一个指定的镜像
  set            为 objects 设置一个指定的特征
  
#中级基础命令
Basic Commands (Intermediate):
  explain        查看资源的文档
  get            显示一个或更多 resources
  edit           在服务器上编辑一个资源
  delete         Delete resources by filenames, stdin, resources and names, or by resources and label selector  在服务器上删除一个资源
  
#部署应用程序相关的命令
Deploy Commands:
  rollout        Manage the rollout of a resource  滚动、回滚
  scale          为 Deployment, ReplicaSet, Replication Controller 或者 Job 设置一个新的副本数量
  autoscale      自动调整一个 Deployment, ReplicaSet, 或者 ReplicationController 的副本数量
  
#集群管理相关的命令
Cluster Management Commands:
  certificate    修改 certificate(证书) 资源.
  cluster-info   显示集群信息
  top            Display Resource (CPU/Memory/Storage) usage.   cpu、内存、存储
  cordon         标记 node 为 unschedulable       标记一个节点不可被调用
  uncordon       标记 node 为 schedulable         标记一个节点可被调用
  drain          Drain node in preparation for maintenance   排干模式
  taint          更新一个或者多个 node 上的 taints           给节点增加污点
  
#疑难解答和调试命令
Troubleshooting and Debugging Commands:
  describe       显示一个指定 resource 或者 group 的 resources 详情     描述一个资源的详细信息
  logs           输出容器在 pod 中的日志
  attach         Attach 到一个运行中的 container
  exec           在一个 container 中执行一个命令
  port-forward   Forward one or more local ports to a pod    端口转发
  proxy          运行一个 proxy 到 Kubernetes API server
  cp             复制 files 和 directories 到 containers 和从容器中复制 files 和 directories.    容器之间复制数据,跨容器复制数据
  auth           Inspect authorization    测试认证
  
#高级命令
Advanced Commands:
  apply          通过文件名或标准输入流(stdin)对资源进行配置           创建修改
  patch          使用 strategic merge patch 更新一个资源的 field(s)    打补丁
  replace        通过 filename 或者 stdin替换一个资源                  替换
  wait           Experimental: Wait for one condition on one or many resources
  convert        在不同的 API versions 转换配置文件
  
#设置命令
Settings Commands:
  label          更新在这个资源上的 labels                             打标签
  annotate       更新一个资源的注解                                    #注解,比labels简单,可打上长度不受限制的K/V对
  completion     Output shell completion code for the specified shell (bash or zsh)     命令补全
  
#其余的命令
Other Commands:
  alpha          Commands for features in alpha
  api-resources  Print the supported API resources on the server
  api-versions   Print the supported API versions on the server, in the form of "group/version"
  config         修改 kubeconfig 文件
  plugin         Runs a command-line plugin      关于插件
  version        输出 client 和 server 的版本信息

1.3、kubectl常用命令表格

  • kubectl作为kubernetes的命令行工具,主要的职责就是对集群中的资源的对象进行操作,这些操作包括对资源对象的创建、删除和查看等。下表中显示了kubectl支持的所有操作,以及这些操作的语法和描述信息:
操作 语法 描述
annotate kubectl annotate (-f FILENAME | TYPE NAME | TYPE/NAME) KEY_1=VAL_1 … KEY_N=VAL_N [–overwrite] [–all] [–resource-version=version] [flags] 添加或更新一个或多个资源的注释
api-versions kubectl api-versions [flags] 列出可用的API版本
apply kubectl apply -f FILENAME [flags] 将来自于文件或stdin的配置变更应用到主要对象中
attach kubectl attach POD -c CONTAINER [-i] [-t] [flags] 连接到正在运行的容器上,以查看输出流或与容器交互(stdin)
autoscale kubectl autoscale (-f FILENAME | TYPE NAME | TYPE/NAME) [–min=MINPODS] –max=MAXPODS [–cpu-percent=CPU] [flags] 自动扩宿容由副本控制器管理的Pod
cluster-info kubectl cluster-info [flags] 显示群集中的主节点和服务的的端点信息
config kubectl config SUBCOMMAND [flags] 修改kubeconfig文件
create kubectl create -f FILENAME [flags] 从文件或stdin中创建一个或多个资源对象
delete kubectl delete (-f FILENAME | TYPE [NAME | /NAME | -l label | –all]) [flags] 删除资源对象
describe kubectl describe (-f FILENAME | TYPE [NAME_PREFIX | /NAME | -l label]) [flags] 显示一个或者多个资源对象的详细信息
edit kubectl edit (-f FILENAME | TYPE NAME | TYPE/NAME) [flags] 通过默认编辑器编辑和更新服务器上的一个或多个资源对象
exec kubectl exec POD [-c CONTAINER] [-i] [-t] [flags] [– COMMAND [args…]] 在Pod的容器中执行一个命令
explain kubectl explain [–include-extended-apis=true] [–recursive=false] [flags] 获取Pod、Node和服务等资源对象的文档
expose kubectl expose (-f FILENAME | TYPE NAME | TYPE/NAME) [–port=port] [–protocol=TCP|UDP] [–target-port=number-or-name] [–name=name] [—-external-ip=external-ip-of-service] [–type=type] [flags] 为副本控制器、服务或Pod等暴露一个新的服务
get kubectl get (-f FILENAME | TYPE [NAME | /NAME | -l label]) [–watch] [–sort-by=FIELD] [[-o | –output]=OUTPUT_FORMAT] [flags] 列出一个或多个资源
label kubectl label (-f FILENAME | TYPE NAME | TYPE/NAME) KEY_1=VAL_1 … KEY_N=VAL_N [–overwrite] [–all] [–resource-version=version] [flags] 添加或更新一个或者多个资源对象的标签
logs kubectl logs POD [-c CONTAINER] [–follow] [flags] 显示Pod中一个容器的日志
patch kubectl patch (-f FILENAME | TYPE NAME | TYPE/NAME) –patch PATCH [flags] 使用策略合并补丁过程更新资源对象中的一个或多个字段
port-forward kubectl port-forward POD [LOCAL_PORT:]REMOTE_PORT […[LOCAL_PORT_N:]REMOTE_PORT_N] [flags] 将一个或多个本地端口转发到Pod
proxy kubectl proxy [–port=PORT] [–www=static-dir] [–www-prefix=prefix] [–api-prefix=prefix] [flags] 为kubernetes API服务器运行一个代理
replace kubectl replace -f FILENAME 从文件或stdin中替换资源对象
rolling-update kubectl rolling-update OLD_CONTROLLER_NAME ([NEW_CONTROLLER_NAME] –image=NEW_CONTAINER_IMAGE | -f NEW_CONTROLLER_SPEC) [flags] 通过逐步替换指定的副本控制器和Pod来执行滚动更新
run kubectl run NAME –image=image [–env=”key=value”] [–port=port] [–replicas=replicas] [–dry-run=bool] [–overrides=inline-json] [flags] 在集群上运行一个指定的镜像
scale kubectl scale (-f FILENAME | TYPE NAME | TYPE/NAME) –replicas=COUNT [–resource-version=version] [–current-replicas=count] [flags] 扩宿容副本集的数量
version kubectl version [–client] [flags] 显示运行在客户端和服务器端的Kubernetes版本

1.4、kubectl实战命令

1.4.1、集群信息查看

1.4.1.1、显示集群信息及节点详细信息 kubectl get

1、显示集群节点信息
    ~]# kubectl get nodes
    NAME            STATUS   ROLES    AGE   VERSION
    192.168.1.141   Ready    <none>   41m   v1.16.4
    192.168.1.185   Ready    <none>   37m   v1.16.4
    192.168.1.211   Ready    <none>   42m   v1.16.4
    192.168.1.247   Ready    <none>   36m   v1.16.4
    192.168.1.51    Ready    <none>   33m   v1.16.4
 
2、查看kubectl和apiserver各自的版本
    ~]# kubectl version
    Client Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.4", GitCommit:"224be7bdce5a9dd0c2fd0d46b83865648e2fe0ba", GitTreeState:"clean", BuildDate:"2019-12-11T12:47:40Z", GoVersion:"go1.12.12", Compiler:"gc",   Platform:"linux/amd64"}
    Server Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.4", GitCommit:"224be7bdce5a9dd0c2fd0d46b83865648e2fe0ba", GitTreeState:"clean", BuildDate:"2019-12-11T12:37:43Z", GoVersion:"go1.12.12", Compiler:"gc", Platform:"linux/amd64"}
 
3、查看整个集群的信息
    ~]# kubectl cluster-info
    #向外输出的API地址
    Kubernetes master is running at https://192.168.1.129:6443
    #coredns  从集群外部运行获取路径,集群外部的端口转发的访问方式
    CoreDNS is running at https://192.168.1.129:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
    To further debug and diagnose cluster problems, use \'kubectl cluster-info dump\'.
 
 
 
4、查看一个node节点的详细信息
~]# kubectl describe node 192.168.1.141
Name:               192.168.1.141
Roles:              <none>
Labels:             UhostID=uhost-jjckmq54
                    beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    failure-domain.beta.kubernetes.io/region=cn-bj2
                    failure-domain.beta.kubernetes.io/zone=cn-bj2-05
                    kubernetes.io/arch=amd64
                    kubernetes.io/hostname=192.168.1.141
                    kubernetes.io/os=linux
                    node.uk8s.ucloud.cn/instance_type=uhost
                    node.uk8s.ucloud.cn/resource_id=uhost-jjckmq54
                    role.node.kubernetes.io/k8s-node=true
                    topology.udisk.csi.ucloud.cn/region=cn-bj2
                    topology.udisk.csi.ucloud.cn/zone=cn-bj2-05
Annotations:        csi.volume.kubernetes.io/nodeid: {"udisk.csi.ucloud.cn":"192.168.1.141","ufile.csi.ucloud.cn":"192.168.1.141"}
                    node.alpha.kubernetes.io/ttl: 0
CreationTimestamp:  Mon, 17 Feb 2020 10:13:18 +0800
Taints:             <none>
Unschedulable:      false
Conditions:
  Type             Status  LastHeartbeatTime                 LastTransitionTime                Reason                       Message
  ----             ------  -----------------                 ------------------                ------                       -------
  MemoryPressure   False   Mon, 17 Feb 2020 10:55:19 +0800   Mon, 17 Feb 2020 10:13:18 +0800   KubeletHasSufficientMemory   kubelet has sufficient memory available
  DiskPressure     False   Mon, 17 Feb 2020 10:55:19 +0800   Mon, 17 Feb 2020 10:13:18 +0800   KubeletHasNoDiskPressure     kubelet has no disk pressure
  PIDPressure      False   Mon, 17 Feb 2020 10:55:19 +0800   Mon, 17 Feb 2020 10:13:18 +0800   KubeletHasSufficientPID      kubelet has sufficient PID available
  Ready            True    Mon, 17 Feb 2020 10:55:19 +0800   Mon, 17 Feb 2020 10:13:18 +0800   KubeletReady                 kubelet is posting ready status
Addresses:
  InternalIP:  192.168.1.141
  Hostname:    192.168.1.141
Capacity:
 cpu:                2
 ephemeral-storage:  41931756Ki
 hugepages-1Gi:      0
 hugepages-2Mi:      0
 memory:             3900272Ki
 pods:               110
Allocatable:
 cpu:                1800m
 ephemeral-storage:  38644306266
 hugepages-1Gi:      0
 hugepages-2Mi:      0
 memory:             2745608599
 pods:               110
System Info:
 Machine ID:                 60bda943e80613c2542b9b1dadb10720
 System UUID:                26179467-6182-4bd3-85be-337cbfbade88
 Boot ID:                    abcb11eb-c85f-4f6b-b93a-867b95794a61
 Kernel Version:             4.19.0-3.el7.ucloud.x86_64
 OS Image:                   CentOS Linux 7 (Core)
 Operating System:           linux
 Architecture:               amd64
 Container Runtime Version:  docker://18.9.9
 Kubelet Version:            v1.16.4
 Kube-Proxy Version:         v1.16.4
ProviderID:                  UCloud://cn-bj2-05//uk8s-z3zv2xip-n-x6oha
Non-terminated Pods:         (2 in total)
  Namespace                  Name               CPU Requests  CPU Limits  Memory Requests  Memory Limits  AGE
  ---------                  ----               ------------  ----------  ---------------  -------------  ---
  kube-system                csi-udisk-qprnf    0 (0%)        0 (0%)      0 (0%)           0 (0%)         42m
  kube-system                csi-ufile-fkvwt    0 (0%)        0 (0%)      0 (0%)           0 (0%)         42m
Allocated resources:
  (Total limits may be over 100 percent, i.e., overcommitted.)
  Resource           Requests  Limits
  --------           --------  ------
  cpu                0 (0%)    0 (0%)
  memory             0 (0%)    0 (0%)
  ephemeral-storage  0 (0%)    0 (0%)
Events:
  Type    Reason                   Age                From                       Message
  ----    ------                   ----               ----                       -------
  Normal  Starting                 42m                kubelet, 192.168.1.141     Starting kubelet.
  Normal  NodeHasSufficientMemory  42m (x2 over 42m)  kubelet, 192.168.1.141     Node 192.168.1.141 status is now: NodeHasSufficientMemory
  Normal  NodeHasNoDiskPressure    42m (x2 over 42m)  kubelet, 192.168.1.141     Node 192.168.1.141 status is now: NodeHasNoDiskPressure
  Normal  NodeHasSufficientPID     42m (x2 over 42m)  kubelet, 192.168.1.141     Node 192.168.1.141 status is now: NodeHasSufficientPID
  Normal  NodeAllocatableEnforced  42m                kubelet, 192.168.1.141     Updated Node Allocatable limit across pods
  Normal  Starting                 42m                kube-proxy, 192.168.1.141  Starting kube-proxy.
 
 
5、查看当前集群中的名称空间
    在k8s上资源有两个级别
        集群级别的资源,整个集群可以划分为名称空间
        节点级别的资源
     
    ~]# kubectl get ns     #初始安装完生成的名称空间     kubectl get namespaces
    NAME              STATUS   AGE
    default           Active   3h9m   #默认的名称空间
    kube-node-lease   Active   3h9m  
    kube-public       Active   3h9m   #公共的名称空间,任何人都可以访问的名称空间
    kube-system       Active   3h9m   #系统级别的pod都运行在此名称空间
 
     
6、当使用get pods命令获取系统上的pod时,实际的意思是列出当前系统上pod,但是pod是名称空间级别的资源,没有指定名称空间,默认的为defaults   #(当我们创建pod时没有指定名称空间时默认都会运行在defaults名称空间中)
    kubectl get pods -n 名称空间    #使用-n选项指定查看的名称空间下的pod
    ~]# kubectl get pods -n kube-system
    NAME                                    READY   STATUS    RESTARTS   AGE
    cloudprovider-ucloud-5679f4ff69-flc64   1/1     Running   0          3h14m
    coredns-68cccdd88-7g46d                 1/1     Running   0          3h14m
    coredns-68cccdd88-q8gmg                 1/1     Running   0          3h14m
    csi-udisk-7h7x2                         2/2     Running   0          3h6m
    csi-udisk-controller-0                  4/4     Running   0          3h14m
    csi-udisk-ps2qb                         2/2     Running   0          3h4m
    csi-udisk-qprnf                         2/2     Running   0          3h9m
    csi-udisk-vnf4j                         2/2     Running   0          3h10m
    csi-udisk-z4lhv                         2/2     Running   0          3h1m
    csi-ufile-8bnst                         2/2     Running   0          3h4m
    csi-ufile-controller-0                  4/4     Running   0          3h14m
    csi-ufile-fd4r2                         2/2     Running   0          3h10m
    csi-ufile-fkvwt                         2/2     Running   0          3h9m
    csi-ufile-hkwpn                         2/2     Running   0          3h1m
    csi-ufile-kmbpc                         2/2     Running   0          3h6m
    metrics-server-c84754b6-ncqvf           1/1     Running   0          3h14m
    uk8s-kubectl-6585dbb994-6vbss           1/1     Running   0          3h14m
 
  
7、显示指定名称空间下的pod资源,并显示详细格式即长格式信息
    -o wide
    ~]# kubectl get pods -n kube-system -o wide
                                                                                 #pod自己的IP地址    #pod运行的node节点信息
    NAME                                    READY   STATUS    RESTARTS   AGE     IP                  NODE            NOMINATED NODE   READINESS GATES
    cloudprovider-ucloud-5679f4ff69-flc64   1/1     Running   0          3h16m   192.168.1.211   192.168.1.211   <none>           <none>
    coredns-68cccdd88-7g46d                 1/1     Running   0          3h16m   192.168.1.148   192.168.1.211   <none>           <none>
    coredns-68cccdd88-q8gmg                 1/1     Running   0          3h16m   192.168.1.103   192.168.1.211   <none>           <none>
    csi-udisk-7h7x2                         2/2     Running   0          3h7m    192.168.1.185   192.168.1.185   <none>  

1.4.2、Namespace名称空间操作

1.4.2.1、k8s名称空间资源增删改查

#创建
1、使用kubectl create 查看可以创建的资源类型
    ~]# kubectl create -h    或者  ~]# kubectl api-resources  可以查看到当前系统上所有的资源类型
        Available Commands:
            clusterrole         Create a ClusterRole.
            clusterrolebinding  Create a ClusterRoleBinding for a particular ClusterRole
            configmap           Create a configmap from a local file, directory or literal value
            cronjob             Create a cronjob with the specified name.
            deployment          Create a deployment with the specified name.         #创建控制器
            job                 Create a job with the specified name.
            namespace           Create a namespace with the specified name           #创建名称空间
            poddisruptionbudget Create a pod disruption budget with the specified name.
            priorityclass       Create a priorityclass with the specified name.
            quota               Create a quota with the specified name.
            role                Create a role with single rule.
            rolebinding         Create a RoleBinding for a particular Role or ClusterRole
            secret              Create a secret using specified subcommand
            service             Create a service using specified subcommand.          #创建service
            serviceaccount      Create a service account with the specified name
 
2、示例创建一个名称空间
    ~]# kubectl create namespace develop
        namespace/develop created
 
    ~]# kubectl get ns
        NAME              STATUS   AGE
        default           Active   3h34m
        develop           Active   27s
 
#删除
3、删除这个名称空间     #引用资源删除,要先指定类型,在指明资源名,当删除名称空间时,名称空间下的所有资源都将被删除,此名称空间下的pod也会被删除
    ~]# kubectl delete namespaces develop           #等价命令   kubectl delete ns/develop      =   kubectl delete namespaces/develop
            namespace "develop" deleted
 
 
#查询
4、查询默认的default名称空间信息
    ~]# kubectl get ns
    ~]# kubectl get ns/default    #指定名称空间显示
     
5、查看名称空间的详细信息yaml格式
    ~]# kubectl get ns/default -o yaml
    apiVersion: v1                             #api版本
    kind: Namespace                            #类型为名称空间
    metadata:                                  #元数据
      creationTimestamp: "2020-02-17T02:07:43Z"
      name: default
      resourceVersion: "147"
      selfLink: /api/v1/namespaces/default
      uid: 844c83d8-5d9d-4787-b0fc-ba088c55f8b1
    spec:                                      #用户期望的状态
      finalizers:
      - kubernetes
    status:                                    #当前状态
      phase: Active
 
6、看名称空间的详细信息json格式
    ~]# kubectl get ns/default -o json
    {
        "apiVersion": "v1",
        "kind": "Namespace",
        "metadata": {
            "creationTimestamp": "2020-02-17T02:07:43Z",
            "name": "default",
            "resourceVersion": "147",
            "selfLink": "/api/v1/namespaces/default",
            "uid": "844c83d8-5d9d-4787-b0fc-ba088c55f8b1"
        },
        "spec": {
            "finalizers": [
                "kubernetes"
            ]
        },
        "status": {
            "phase": "Active"
        }
    }
 
#描述信息
7、查看指定的名称空间的描述信息
    ~]# kubectl describe ns/default
    Name:         default
    Labels:       <none>
    Annotations:  <none>
    Status:       Active
    No resource quota.
    No resource limits.

1.4.3、deployment控制器创建pod资源

1.4.3.1、k8s名称deployment控制器创建pod资源

#创建
1、查看创建帮助deployment控制器
    ~]# kubectl create deployment -h
        --image=[]: Image name to run.    #指定使用哪个镜像运行为一个容器
        --save-config=false/true          #是否保存创建时的命令信息进行保存
        --dry-run=false                   #干跑、测试一下
         
 
2、创建一个deployment控制器靠 nginx镜像运行 pod
    ~]# kubectl create deploy ngx-dep --image=nginx:1.14-alpine   #此时会创建一个ngx-dep控制器,未知定名称空间则为default,这个控制器则试图创建一个pod,pod中会靠nginx镜像运行
        deployment.apps/ngx-dep created
 
3、显示default名称空间下的所有资源  
    #(已经创建了三个资源:1、deployment.apps/ngx-dep 控制器, 2、中间层replicaset.apps/ngx-dep-d554574bd 3、pod/ngx-dep-d554574bd-q59fj)
    ~]# kubectl get all
        NAME                                READY   STATUS    RESTARTS   AGE
        pod/ngx-dep-d554574bd-q59fj         1/1     Running   0          29m
 
        NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
        service/kubernetes   ClusterIP   10.2.0.1     <none>        443/TCP   4h57m
 
        NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
        deployment.apps/ngx-dep        1/1     1            1           29m
 
        NAME                                      DESIRED   CURRENT   READY   AGE
        replicaset.apps/ngx-dep-d554574bd         1         1         1       29m
 
#信息
4、查看当前defaults中的pods以及详细信息
    ~]# kubectl get pods
    NAME                            READY   STATUS    RESTARTS   AGE
    ngx-dep-d554574bd-q59fj         1/1     Running   0          40m
 
    ~]# kubectl get pods -o wide
    NAME                            READY   STATUS    RESTARTS   AGE     IP     pod地址         NODE            NOMINATED NODE   READINESS GATES
    ngx-dep-d554574bd-q59fj         1/1     Running   0          41m     192.168.1.125      192.168.1.51         <none>           <none>
     
5、访问此pod IP
    ~]# curl -I 192.168.1.125
        HTTP/1.1 200 OK
        Server: nginx/1.14.2
        Date: Mon, 17 Feb 2020 07:17:39 GMT
        Content-Type: text/html
        Content-Length: 612
        Last-Modified: Wed, 10 Apr 2019 01:08:42 GMT
        Connection: keep-alive
        ETag: "5cad421a-264"
        Accept-Ranges: bytes
 
 
#删除pod
5、删除defalut资源下的pod
    删除此pod发生的结果,此pod由deployment.apps/ngx-dep 控制器控制着此pod,一删除此pod,控制器发现此pod没了,但是控制器已经定义必须要有一个pod,则会重新启动一个pod
    ~]# kubectl delete pods/ngx-dep-d554574bd-q59fj    
        pod "ngx-dep-d554574bd-q59fj" deleted
 
    ~]# kubectl get pods
        NAME                            READY   STATUS    RESTARTS   AGE
        ngx-dep-d554574bd-c5sjp         1/1     Running   0          2m41s
    ~]# kubectl get pods -o wide
        NAME                            READY   STATUS    RESTARTS   AGE     IP              NODE            NOMINATED NODE   READINESS GATES
        ngx-dep-d554574bd-c5sjp         1/1     Running   0          3m36s   192.168.1.160   192.168.1.247   <none>           <none>
 
    ~]# curl -I 192.168.1.160    访问新的pod地址
        HTTP/1.1 200 OK
 
 
 
总结:由于创建pod,没有添加service直接供用户访问,则如果pod出现问题时会生成一个全新的pod,则用户访问的IP则会发生变化,如果使得Pod资源发生变化时用户访问的还是一个地址则需要添加service中间层(调度)
    在创建service时明确指定自身使用什么端口,后端pod上使用什么端口(端口可以一致,但是也可以不一致,但是在一般情况下都保持一致),创建一个service就是创建一个iptables规则或者ipvs规则
    类似一个DNET规则,但是此规则在每一个node节点上都会生成

1.4.4、service类型示例

1.4.4.1、k8s名称deployment控制器下创建一个service绑定pod资源 (类型为clusterip)

  • service有四种类型:
    • clusterip :最简单也是最常用
    • externalname
    • loadbalancer
    • nodeport
1、查看创建一个service帮助
    ~]# kubectl create service -h
        Create a service using specified subcommand.
 
        Aliases:
        service, svc
 
        Available Commands:
          clusterip    Create a ClusterIP service.
          externalname Create an ExternalName service.
          loadbalancer Create a LoadBalancer service.
          nodeport     Create a NodePort service.
 
        Usage:
          kubectl create service [flags] [options]
 
2、查看创建clusterip类型的service的帮助
    ~]# kubectl create service clusterip -h
        --tcp=[]: Port pairs can be specified as \'<port>:<targetPort>\'.    # 创建service时要指定本地ip及远端ip  (service端口称为本地端口,targetPort指的是被代理的后端的pod的端口)
        --dry-run=false   #干跑
        --clusterip=\'\'    #指定集群的ip,如果不指定则动态指定
 
 
 
 
------------------------------------------------------------------------------------------错误示例由于没有指定后端pod--------------------------------------------------------------------------------
3、为了运行一个nginx创建一个clusterip类型的service
    ~]# kubectl create service clusterip ngx-svc --tcp=80:80 --dry-run
        service/ngx-svc created (dry run)
    ~]# kubectl create service clusterip ngx-svc --tcp=80:80
        service/ngx-svc created
 
4、查看已经创建的service
    ~]# kubectl get svc
                                #创建时未指定--clusterip=\'\'则为动态生成的
        NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
        kubernetes   ClusterIP   10.2.0.1       <none>        443/TCP   5h45m
        ngx-svc      ClusterIP   10.2.135.254   <none>        80/TCP    41s
 
    #显示详细信息
    ~]# kubectl get svc/ngx-svc -o yaml
        apiVersion: v1
        kind: Service
        metadata:
          creationTimestamp: "2020-02-17T07:52:16Z"
          labels:
            app: ngx-svc
          name: ngx-svc
          namespace: default
          resourceVersion: "66291"
          selfLink: /api/v1/namespaces/default/services/ngx-svc
          uid: c6b6062e-fd7b-4363-ac30-c53816ffb147
        spec:
          clusterIP: 10.2.135.254
          ports:
          - name: 80-80
            port: 80         #本地service端口
            protocol: TCP
            targetPort: 80   #远端pod端口
          selector:
            app: ngx-svc
          sessionAffinity: None
          type: ClusterIP
        status:
          loadBalancer: {}
 
5、删除已经创建的service
    ~]# kubectl delete svc/ngx-svc
        service "ngx-svc" deleted
 
    ~]# kubectl get service
        NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
        kubernetes   ClusterIP   10.2.0.1     <none>        443/TCP   5h50m
 
------------------------------------------------------------------------------------------以上为错误示例--------------------------------------------------------------------------------
------------------------------------------------------------------------------------------以下为正确示例--------------------------------------------------------------------------------
 
6、正确的创建一个clusterip类型的service   #当创建的service与deployment同名时,会自动将此deployment 下的pod自动关联
    # 查看已经创建的deployment控制器
    ~]# kubectl get deployment
        NAME           READY   UP-TO-DATE   AVAILABLE   AGE
        ngx-dep        1/1     1            1           104m
 
 
    # 创建一个和deployment控制同名的service
    ~]# kubectl create service clusterip ngx-dep --tcp=80:80            # <port>:<targetport> 指定本地端口及远端被代理的pods端口
        service/ngx-dep created
 
7、查看已经创建的service
    ~]# kubectl get svc/ngx-dep -o yaml
        apiVersion: v1
        kind: Service
        metadata:
          creationTimestamp: "2020-02-17T08:20:16Z"
          labels:                           #service labels
            app: ngx-dep
          name: ngx-dep
          namespace: default
          resourceVersion: "71648"
          selfLink: /api/v1/namespaces/default/services/ngx-dep
          uid: e9332ba6-29f7-4407-8c7e-6927d0e23d45
        spec:
          clusterIP: 10.2.138.37           # service地址
          ports:
          - name: 80-80
            port: 80
            protocol: TCP
            targetPort: 80
          selector:
            app: ngx-dep
          sessionAffinity: None
          type: ClusterIP
        status:
          loadBalancer: {}
 
    #可以查看到后端被自动关联的pod
    ~]# kubectl describe svc/ngx-dep
        Name:              ngx-dep
        Namespace:         default
        Labels:            app=ngx-dep
        Annotations:       <none>
        Selector:          app=ngx-dep
        Type:              ClusterIP
        IP:                10.2.138.37
        Port:              80-80  80/TCP
        TargetPort:        80/TCP
        Endpoints:         192.168.1.160:80      #自动被关联的pod(当创建的service与deployment同名时,会自动将此deployment 下的pod自动关联)
        Session Affinity:  None
        Events:            <none>
 
8、此时访问service地址则会被映射到访问到后端的pod资源
    ~]# curl -I 10.2.138.37
        HTTP/1.1 200 OK
        Server: nginx/1.14.2
 
 
9、测试手动删除当前运行的pod,则控制器则会自动创建一个新的pod,新的pod和之前的pod地址完全不相同,此时再次访问service
    ~]# kubectl get pods
        NAME                            READY   STATUS    RESTARTS   AGE
        ngx-dep-d554574bd-c5sjp         1/1     Running   0          67m
     
    ~]# kubectl delete pods ngx-dep-d554574bd-c5sjp
        pod "ngx-dep-d554574bd-c5sjp" deleted
 
 
    ~]# kubectl get pods -o wide
        NAME                            READY   STATUS    RESTARTS   AGE     IP              NODE            NOMINATED NODE   READINESS GATES
        ngx-dep-d554574bd-mg7jg         1/1     Running   0          3m57s   192.168.1.68    192.168.1.51    <none>           <none>
 
    ~]# kubectl describe svc/ngx-dep
        Name:              ngx-dep
        Namespace:         default
        Labels:            app=ngx-dep
    Annotations:       <none>
        Selector:          app=ngx-dep
        Type:              ClusterIP
        IP:                10.2.138.37
        Port:              80-80  80/TCP
        TargetPort:        80/TCP
        Endpoints:         192.168.1.68:80    #新的pod地址
        Session Affinity:  None
        Events:            <none>
 
    ~]# curl -I 10.2.138.37                   #访问service可以正常访问
        HTTP/1.1 200 OK
        Server: nginx/1.14.2
 
 
#总结:在控制器的控制下,pod被干掉时,生成一个新的pod,重建的结果还会响应的反应到service上,所以用户可以通过service的地址固定的来访问pod资源

1.4.4.2、如果service的发生改变时用户访问地址改变则使用service的名称空间来访问

1、名称空间访问原理
    ~]# kubectl get svc
        NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
        kubernetes   ClusterIP   10.2.0.1      <none>        443/TCP   6h31m
        ngx-dep      ClusterIP   10.2.138.37   <none>        80/TCP    19m
     
    ~]# curl ngx-dep
        curl: (6) Could not resolve host: ngx-dep; Unknown error
    # ~]# curl ngx-dep.default.svc.cluster.local
 
 
    # 这个名称空间为默认在k8s中运行的dns即 coredns
    ~]# kubectl get pods -n kube-system
        NAME                                    READY   STATUS    RESTARTS   AGE
        coredns-68cccdd88-7g46d                 1/1     Running   0          6h33m
        coredns-68cccdd88-q8gmg                 1/1     Running   0          6h33m
 
    # coredns也有一个ip地址
    ~]# kubectl get svc -n kube-system
        NAME                   TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                  AGE
        csi-udisk-controller   ClusterIP   10.2.235.189   <none>        12345/TCP                6h35m
        csi-ufile-controller   ClusterIP   10.2.77.27     <none>        12345/TCP                6h35m
        kube-dns               ClusterIP   10.2.0.2       <none>        53/UDP,53/TCP,9153/TCP   6h35m   ##
        metrics-server         ClusterIP   10.2.190.58    <none>        443/TCP                  6h35m
     
    #所以即使service地址变了,但是service名称没变,都可以通过service的名称访问

1.4.4.3、deployment可以按需求对后端的pod伸缩资源 (kubectl scale)

1、创建一个deployment     ##此时会创建一个myapp控制器,未知定名称空间则为default,这个控制器则试图创建一个pod,pod中会靠myapp:v1镜像运行
    ~]#  kubectl create deploy myapp --image=ikubernetes/myapp:v1
        deployment.apps/myapp created
     
2、查看已经创建的deploy控制器
    ~]# kubectl get deploy
        NAME           READY   UP-TO-DATE   AVAILABLE   AGE
        myapp          1/1     1            1           91s
 
3、查看此控制器下的pod
    ~]# kubectl get pods
        NAME                            READY   STATUS    RESTARTS   AGE
        myapp-5c6976696c-8kpqh          1/1     Running   0          2m22s
 
    ~]# kubectl get pods -o wide
        NAME                            READY   STATUS    RESTARTS   AGE     IP              NODE            NOMINATED NODE   READINESS GATES
        myapp-5c6976696c-8kpqh          1/1     Running   0          3m14s   192.168.1.236   192.168.1.141   <none>           <none>
 
 
 
4、访问此pod
    ~]# curl 192.168.1.236
        Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>
 
    ~]# curl 192.168.1.236/hostname.html
        myapp-5c6976696c-8kpqh
 
5、给myapp的控制器创建一个对应的service
    ~]# kubectl create service clusterip myapp --tcp=80:80
        service/myapp created
 
6、由于创建的service和控制器名称一致,则自动被关联的此控制器下的pod
    ~]# kubectl get svc
        NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
        kubernetes   ClusterIP   10.2.0.1      <none>        443/TCP   6h55m
        myapp        ClusterIP   10.2.35.177   <none>        80/TCP    2m8s
        ngx-dep      ClusterIP   10.2.138.37   <none>        80/TCP    42m
 
7、查看此service的详细信息
    ~]# kubectl get svc/myapp -o yaml
 
 
    ~]# kubectl describe svc/myapp
        Name:              myapp
        Namespace:         default
        Labels:            app=myapp
        Annotations:       <none>
        Selector:          app=myapp
        Type:              ClusterIP
        IP:                10.2.35.177
        Port:              80-80  80/TCP
        TargetPort:        80/TCP
        Endpoints:         192.168.1.236:80
        Session Affinity:  None
        Events:            <none>
 
8、通过service的ip访问后端的pod
    ~]# curl 10.2.35.177
        Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>
 
    ~]# curl 10.2.35.177/hostname.html
        myapp-5c6976696c-8kpqh
    # curl myapp.default.svc.cluster.local.
 
 
9、控制器可以对后端的pod扩缩容
    ~]# kubectl scale -h
        kubectl scale [--resource-version=version] [--current-replicas=count] --replicas=COUNT (-f FILENAME | TYPE NAME) [options]
 
    #指定扩容的pod资源数量, 控制器名称
    ~]# kubectl scale --replicas=3 deployment myapp
        deployment.apps/myapp scaled
 
10、查看已经扩展的pod资源
    ~]# kubectl get pods
        NAME                            READY   STATUS    RESTARTS   AGE
        myapp-5c6976696c-8kpqh          1/1     Running   0          23m
        myapp-5c6976696c-sxt79          1/1     Running   0          2m7s
        myapp-5c6976696c-xsvn2          1/1     Running   0          2m7s
 
    ~]# kubectl get pods -o wide
        NAME                            READY   STATUS    RESTARTS   AGE     IP              NODE            NOMINATED NODE   READINESS GATES
        myapp-5c6976696c-8kpqh          1/1     Running   0          24m     192.168.1.236   192.168.1.141   <none>           <none>
        myapp-5c6976696c-sxt79          1/1     Running   0          2m43s   192.168.1.67    192.168.1.247   <none>           <none>
        myapp-5c6976696c-xsvn2          1/1     Running   0          2m43s   192.168.1.233   192.168.1.51    <none>           <none>
 
 
 
11、查看service,会自动的将新创建pod关联到service的Endpoints地址
    ~]# kubectl describe svc/myapp
        Name:              myapp
        Namespace:         default
        Labels:            app=myapp
        Annotations:       <none>
        Selector:          app=myapp
        Type:              ClusterIP
        IP:                10.2.35.177
        Port:              80-80  80/TCP
        TargetPort:        80/TCP
        Endpoints:         192.168.1.233:80,192.168.1.236:80,192.168.1.67:80
        Session Affinity:  None
        Events:            <none>
 
12、此时访问service地址会实现pod的资源调度  #默认的调度方式是随机调度
    ~]# curl 10.2.35.177/hostname.html
            myapp-5c6976696c-sxt79
    ~]# curl 10.2.35.177/hostname.html
            myapp-5c6976696c-xsvn2
    ~]# curl 10.2.35.177/hostname.html
            myapp-5c6976696c-8kpqh
 
 
 
13、pod资源缩容
    ~]# kubectl scale --replicas=2 deployment myapp
        deployment.apps/myapp scaled
 
    ~]# kubectl get pods
        NAME                            READY   STATUS    RESTARTS   AGE
        myapp-5c6976696c-8kpqh          1/1     Running   0          34m
        myapp-5c6976696c-sxt79          1/1     Running   0          13m

1.4.4.5、deployment控制器下创建一个service绑定pod资源 (类型为nodeport即节点端口类型)使得集群外部访问

1、删除之前创建的service
    ~]# kubectl delete svc/myapp
        service "myapp" deleted
 
     ~]# kubectl get service
     ~]# kubectl get deploy
        NAME    READY   UP-TO-DATE   AVAILABLE   AGE
        myapp   3/3     3            3           42s
 
 
2、创建一个nodeport类型的service
    ~]# kubectl create service nodeport -h
        kubectl create service nodeport NAME [--tcp=port:targetPort] [--dry-run] [options]
 
    ~]# kubectl create service nodeport myapp --tcp=80:80
        service/myapp created
    ~]# kubectl get service
        NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
        kubernetes   ClusterIP   10.2.0.1       <none>        443/TCP        8h
        myapp        NodePort    10.2.236.100   <none>        80:34765/TCP   4s      #80为service端口,34765为宿主机的端口
 
 
3、由于创建的service和控制器名称一致,则自动被关联的此控制器下的pod
    ~]# kubectl get deploy
        NAME           READY   UP-TO-DATE   AVAILABLE   AGE
        myapp          2/2     2            2           77m
 
    ~]# kubectl describe service/myapp
        Name:                     myapp
        Namespace:                default
        Labels:                   app=myapp
        Annotations:              <none>
        Selector:                 app=myapp
        Type:                     NodePort
        IP:                       10.2.236.100
        Port:                     80-80  80/TCP
        TargetPort:               80/TCP
        NodePort:                 80-80  34765/TCP
        Endpoints:                192.168.1.236:80,192.168.1.67:80
        Session Affinity:         None
        External Traffic Policy:  Cluster
        Events:                   <none>
 
 
4、通过集群中任何节点主机访问34765端口 (其实是反应在每一个主机的iptables规则中  ~]# iptables -t nat -vnL)
    ~]# curl 192.168.1.141:34765
        Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>
    ~]# curl 192.168.1.185:34765
        Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>
    ~]# curl 192.168.1.211:34765
        Hello MyApp | Version: v1 | <a href="hostname.html">Pod Name</a>
 
 
 
5、防火墙策略查看
    会生成NodePort类型的防火墙规则,这些都是kube-proxy自动转换的iptable或ipvs规则
~]# iptables -t nat -vnL
Chain KUBE-NODEPORTS (1 references)
 pkts bytes target     prot opt in     out     source               destination        
    0     0 KUBE-MARK-MASQ  tcp  --  *      *       0.0.0.0/0            0.0.0.0/0            /* default/myapp:80-80 */ tcp dpt:32474
    0     0 KUBE-SVC-IJFIQBSXQ4XPPRV7  tcp  --  *      *       0.0.0.0/0            0.0.0.0/0            /* default/myapp:80-80 */ tcp dpt:32474

以上是关于03-K8S Basic-kubernetes应用快速入门的主要内容,如果未能解决你的问题,请参考以下文章

2022-04-03:k8s安装srs,yaml如何写?

应用宝和应用商店怎么区别

苹果应用商店的应用商店视图和应用单元是啥意思?

Windows 应用商店应用标准样式与 Windows 应用商店应用字体指南

向应用添加应用内购买会影响已购买该应用的用户吗?

应用商店拒绝应用后如何再次上传应用