^-^
【go云原生】Kubernetes：kubectl
最近更新：2025-01-02   |   字数总计：3.8k   |   阅读估时：16分钟   |   阅读量：次
  1. Kubernetes：kubectl
    1. kubectl基本语法
    2. kubectl基础操作命令
      1. api-resources
      2. api-versions
      3. create
      4. expose
      5. run
      6. set
      7. explain
      8. get
      9. edit
      10. delete
      11. label
      12. annotate
    3. kubectl应用部署命令
      1. diff
      2. apply
      3. replace
      4. rollout
        1. history
        2. pause与resume
        3. restart
        4. status
        5. undo
      5. scale
      6. autoscale
    4. kubectl集群管理
      1. cluster-info
        1. dump
      2. cordon
      3. uncordon
      4. drain
    5. kubectl故障排除和调试命令
      1. describe
      2. logs
      3. attach
      4. exec
      5. port-forward
      6. proxy
      7. cp
      8. debug

Kubernetes：kubectl

  • master节点与APIServer通信的命令行工具——kubectl。默认配置文件目录在$HOME/.kube/config。可以通过–kubeconfig参数来指定kubectl的配置文件。
  1. RC
  • myhello-rc.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    apiVersion: v1
    kind: ReplicationController # RC，副本控制器，资源类型是ReplicationController
    metadata:
        name: myhello-rc # RC名称，全局唯一
        labels:
            name: myhello-rc
    spec:
        relicas: 5 # 期待的pod数量
        selector:
            name: myhello-pod
        template:
            metadata:
                labels:
                    name: myhello-pod
            spec:
                containers: # pod内容的定义部分
                - name: myhello # 容器的名称
                  image: xlhmzch/hello:1.0.0 # 容器对应的 Docker Image
                  imagePullPolicy: IfNotPresent
                  ports:
                  - containerPort: 80
                  env: # 注入到容器的环境变量
                  - name: env1
                    value: "k8s-env1"
                  - name: env2
                    value: "k8s-env2"
  1. RC-Service
  • myhello-svc.ymal
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    apiVersion: v1
    kind: Service
    metadata:
        name: myhello-svc
        labels:
            name: myhello-svc
    spec:
        type: NodePort # 对外提供接口
        ports:
        - port: 80
          protocal: TCP
          targetPort: 80
          name: http
          nodePort: 30000
        selector:
          name: myhello-pod
  1. Deployment
  • myapp-deployment.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    apiVersion: apps/v1
    kind: Deployment
    metadata:
        name: myapp-deployment
        labels:
            name: myapp
    spec:
        replicas: 5
        selector:
            matchLabels:
                name: myapp
        template:
            metadata:
                labels:
                    name: myapp
            spec:
                containers:
                - name: myhello
                  image: xlhmzch/hello:1.0.0
                  imagePullPolicy: IfNotPresent
                  ports:
                  - containerPort: 80
                  env:
                  - name: env1
                    value: "k8s-env1"
                  - name: env2
                    value: "k8s-env2"
                - name: myredis
                  image: redis
                  imagePillPolicy: IfNotPresent
                  ports:
                  - containerPort: 6379
                  env:
                  - name: env1
                    value: "k8s-env1"
                  - name: env2
                    value: "k8s-env2"

  1. Deployment-Service
  • myapp-svc.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    apiVersion: v1
    kind: Service
    metadata:
        name: myapp-svc
        labels:
            name: myapp-svc
    spec:
        type: NodePort
        ports:
        - port: 80
          protocol: TCP
          targetPort: 80
          name: http
          nodePort: 30001
        selector:
          name: myapp
  1. DaemonSet
  • cadvisor-ds.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
        name: cadvisor
        namespace: default
        labels:
            app: cadvisor
    spec:
        selector:
            matchLabels:
                app: cadvisor
        template:
            metadata:
                labels:
                    app: cadvisor
            spec:
                tolerations:
                - key: node-role.kubernetes.io/control-plane
                  operator: Exists
                  effect: NoSchedule
                containers:
                - name: cadvisor
                  image: google/cadvisor:v0.32.0
                  ports:
                  - containerPort: 8080
                  resources:
                    limits:
                        memory: 200Mi
                    requests:
                        cpu: 100m
                        memory: 200Mi
                  volumeMounts:
                  - name: rootfs
                    mountPath: /rootfs
                  - name: run
                    mountPath: /var/run
                  - name: sys
                    mountPath: /sys
                  - name: varlibdocker
                    mountPath: /var/lib/docker/
                  - name: devdisk
                    mountPath: /dev/disk
                    readOnly: true
                  - name: localtime
                    mountPath: /etc/localtime
                    readOnly: true
                  terminationGroupPeriodseconds: 30
                  volumes:
                  - name: rootfs
                    hostPath:
                        path: /
                  - name: run
                    hostPath:
                        path: /var/run
                  - name: sys
                    hostPath:
                        path: /sys/
                  - name: varlibdocker
                    hostPath:
                        path: /var/lib/docker/
                  - name: devdisk
                    hostPath:
                        path: /dev/disk
                  - name: localtime
                    hostPath:
                        path: /etc/localtime
  1. DaemonSet-Service
  • cadvisor-svc.yaml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    apiVersion: v1
    kind: Service
    metadata:
        name: cadvisor-svc
        labels:
            name: cadvisor-svc
    spec:
        type: NodePort # 对外提供接口
        ports:
        - port: 80
          protocal: TCP
          targetPort: 8080
          name: http
          nodePort: 30002
        selector:
          name: cadvisor

kubectl基本语法

  • 安装命令自动补全
    1
    2
    3
    apt-get install -y bash-completion
    echo "source <(kubectl completion bash)" >> ~/.bashrc
    source ~/.bashrc
  • 基本语法 
    1
    2
    3
    4
    5
    6
    # 命令、资源类型、名称、参数
    kubectl [command] [type] [name] [flags]
    kubectl get node k8s-node1 # 查看节点
    kubectl get node k8s-node1 k8s-node2 # 查看多个节点
    kubectl get node/k8s-node1 svc/k8s-svc1 # 获取多组类型的资源
    kubectl get -f myhello-rc.yaml -f myhello-svc.yaml # 通过资源定义文件去获取资源
  • 实际操作
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    mkdir work
    cd work
    vim myhello-rc.yaml # 键入我们准备好的rc定义
    vim myhello-svc.yaml # rc-service定义
    vim myapp-deployment.yaml # deployment定义
    vim myapp-svc.ymal # deployment-service定义
    vim cadvisor-ds.yaml # daemonset定义
    vim cadvisor-svc.yaml # daemonset-service定义
    # 6个资源，4种资源
    kubectl create -f cadvisor-ds.yaml # 创建一个资源
    kubectl get -f cadvisor-ds.yaml # 查看刚创建的ds
    kubectl get ds cadvisor # 通过命令查看刚创建的ds
    kubectl get ds/cadvisor -o wide # -o wide显示更多信息

kubectl基础操作命令

api-resources

1
2
3
kubectl api-resources # 查看支持的api资源，有用的是看apiversion
kubectl api-resources -o wide # 显示更多信息
kubectl api-resources --namespaced=true # 查看打印支持命名空间的结果，就是支持隔离的资源，有些资源是属于集群的不能被命名空间隔离

api-versions

1
kubectl api-versions # 打印支持的api versions

create

1
2
kubectl create -f myhello-svc.yaml # 创建由文件定义的资源，不允许重复创建
cat myapp-svc.yaml | kubectl create -f - # 以标准输入来创建

expose

  • 给定副本控制器、服务、Deployment或Pod，将其暴露为新的k8s Service，其本质是通过现有资源对象的配置信息将新的Service与原有资源背后的Pod作关联。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    kubectl export rc myhello-rc --port=8000 -target-port=80 --name=myhello-svc-8000 # 为副本控制器myhello-rc创建service，端口为8000，容器端口为80 
    curl http://10.99.220.173:8000/ping # 我们可以看出service是直接找到rc的pod来处理请求的，中间不存在所谓的转发

    kubectl expose -f myhello-rc.yaml --port=8000 --target-port=80 --name=myhello-svc-8000-file # 使用rc定义文件来创建service

    kubectl expose pod myapp-deployment-b187eoin --port=444 --name=myhello-svc-444 # 根据指定的pod创建service，并指定service名称。我们可以发现虽然指定了一个具体的pod，但是实际上是找到了一组pod的所有副本，一组pod都可以服务。

    kubectl expose myhello-svc --port=8000 --target-port=80 --name=myhello-svc-8080 # 通过service创建新的service

    kubectl get svc # 查看所有service
    kubectl describe svc myhello-svc-444 # 查看某一个service的情况

run

  • 在集群中使用指定镜像启动容器
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    kubectl run nginx --image=nginx # 运行一个镜像是nginx的pod

    kubectl run myhello --image=xlhmzch/hello:1.0.0 # 通过镜像运行一个名为myhello的pod

    kubectl run redis --image=redis --port=6379 --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default" --labels="app=redis,env=prod" # 指定端口号、环境变量、labels

    kubectl describe pod/redis # 查看一下刚运行的pod

    kubectl run nginx --image=nginx --dry-run=client # 只打印命令执行结果，而不做实际操作，dry-run就是尝试运行的意思

    kubectl run -i -t busybox --image=busybox --restart=Never # 运行一个busybox容器，并进入交互，同时设置重启策略为never

    kubectl get pod # 查看命名空间下所有pod

set

  • 为对象设置功能特性（环境变量、镜像等）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    # ==============================================
    # env
    kubectl set env rc/myhello-rc STORAGE_DIR=/local # 为rc设置一个环境变量
    kubectl describe rc myhello-rc # 查看一下设置结果
    kubectl describe pod myhello-rc-w19815f # 看看rc管理的pod，有没有得到这个环境变量，我们发现并没有。这就是RC和deployment的不同指出，RC的改变只有在发生调度的时候才会生效。
    kubectl set env rc/myhello-rc --list # 查看rc的环境变量列表
    kubectl set env pods --all --list # 查看所有pod的环境变量列表
    kubectl set env rc/myhello-rc STORAGE_DIR- # 删除我们刚设置的环境变量
    kubectl set env rc --all ENV- # 删除所有rc上的环境变量
    # ==============================================
    # image
    kubectl set image deployment/myapp-deployment myhello=xlhmzch/hello:1.0.1 # 更改镜像，我们修改deployment，pod都会立即更新

    kubectl set image -f myapp-deployment.yaml myhello=xlhmzch/hello:1.0.1 --local -o yaml # 根据文件修改镜像，--local标识不向apiserver发送请求，仅本地修改文件并输出yaml格式内容，就是仅意思一下，不做真正的集群修改

    # 假如修改rc的image不会立即反应到pod，而deployment的image则会立即反应到pod。
    # ==============================================
    # resource
    kubectl set resources deployment myapp-deployment -c=myhello --limits=cpu=200m,memory=512Mi # 设置单个容器的资源，-c容器名称

    kubectl set resources deployment myapp-deployment --limits=cpu=200m,memory=512Mi --requests=cpu=100m,memory=256Mi # 设置deployment下所有容器的资源

    # ==============================================
    # selector
    kubectl set selector svc myhello-svc env=proc # 目前仅支持service的selector修改，将service的selector修改为env=proc，这个会影响到我们的service所选中的pod
    kubectl set selector svc myhello-svc name=myhello-pod # 将service的selector修改为name=myhello-pod，这个会影响到我们的service所选中的pod
    # ==============================================

explain

  • 显示资源文档说明
    1
    2
    kubectl explain pod # 看下pod的文档
    kubectl explain pod.spec.container # 看下这个文档

get

  • 显示一个或多个资源
    1
    2
    3
    4
    kubectl get pod # 命名空间下pod
    kubectl get ns # 查看有多少命名空间
    kubectl get pod -n kube-system # 指定命名空间查看pod
    kubectl get rc,services

edit

  • 修改服务器上的某资源
    1
    kubectl edit svc/myhello-svc # 修改在线资源，不是修改配置文件那种

delete

1
2
3
4
kubectl delete -f myhello-rc.yaml # 通过定义文件删除资源
cat myhello-rc.yaml | kubectl delete -f - # 以文件内容为参数，删除资源
kubectl delete pod,service myhello-pod myhello-svc # 删除两种指定名字的资源
kubectl delete pods,services -l name=myhello-pod # 删除标签为myhello-pod的pod和service

label

  • 更新资源标签
    1
    2
    3
    4
    5
    kubectl label pods nginx status=unhealthy # 为pod/nginx添加标签
    kubectl describe pod nginx 
    kubectl label --overwrite pods nginx status=healthy # 修改已存在的label
    kubectl label pods nginx status- # 删除label
    kubectl label pods --all status=unhealthy # 为当前命名空间下所有pod添加标签

annotate

  • 更新资源所关联的注解
    1
    2
    kubectl annotate rc myhello-rc description='my hello rc' # 添加注解
    kubectl annotate rc -f myhello-rc.yaml description1='hello rc1' # 为文件所定义的资源添加注解

kubectl应用部署命令

diff

  • 显示目前版本，也就是正在线上的内容，与将要应用的版本之间的差异
    1
    2
    3
    kubectl diff -f myapp-deployment.yaml # 通过文件对比
    cat myapp-deployment.yaml | kubectl diff -f - # 通过输入对比
    kubectl diff -f '*.yaml' # 对比当前目录yaml后缀的文件

apply

  • 基于文件或标准输入，将配置应用
    1
    2
    kubectl apply -f myapp-deployment.yaml
    cat myapp-deployment.yaml | kubectl apply -f -

replace

  • 基于文件或标准输入，将新的配置文件以替换的方式应用到资源上
    1
    2
    # replace 与 apply 的区别：假设我们的yaml里面没有定义一些字段，那么apply是不会更新这些内容的，但是replace是全量更新，没有的字段也会被删除
    kubectl replace -f myapp-deployment.yaml

rollout

  • 管理资源的上线。

history

  • 查看历史修订版本和配置。
    1
    kubectl rollout history deployment myapp-deployment # 查看历史版本和配置

pause与resume

  • 将提供的资源标记为已暂停或暂停结束。仅支持deployment
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # 我们的deployment，是随时修改就会随时更新的，除非我们暂停它。但是，有一种东西例外，就是伸缩容，这个不会被暂停，即使我们pause了它。
    kubectl rollout pause deployment myapp-deployment
    kubectl edit deployments.apps myapp-deployment # 我们修改一下镜像版本或环境变量
    kubectl describe pod myapp-15981qewrgeg # 可以发现pod没有被改变
    kubectl describe deployments.apps myapp-deployment # 但是我们的deployment已经被改变了
    # =======================================
    kubectl rollout resume deployment myapp-deployment # 停止暂停
    kubectl describe pod myapp-15981qewrgeg # 发现暂停结束后之前的更改生效了
    # =======================================
    kubectl rollout pause deployment myapp-deployment
    vim myapp-deployment # 改下镜像版本
    kubectl apply -f myapp-deployment.yaml # 会发生什么？
    kubectl describe pod myapp-15981qewrgeg # 发现pod没有改变
    kubectl replace -f myapp-deployment.yaml # 会发生什么？
    kubectl describe pod myapp-15981qewrgeg # 发现被修改了
    # 所以apply是受pause影响的，而replace是不受的

restart

  • 重启资源对象
    1
    2
    3
    # 什么时候需要重启？需要不仅仅是重新配置部署，而是想要deployment的的关联资源全部重启的时候，这会使得pod全部重新刷新一遍。
    kubectl rollout restart deployment myapp-deployment # 重启下deployment
    kubectl rollout restart ds cadvisor # 重启ds

status

  • 查看部署状态
    1
    kubectl rollout status deployment myapp-deployment # 查看部署状态

undo

  • 回滚到之前或指定版本
    1
    2
    3
    4
    5
    6
    kubectl edit deployments.apps myapp-deployment
    kubectl edit deployments.apps myapp-deployment
    kubectl edit deployments.apps myapp-deployment # 连续修改一下镜像版本
    kubectl rollout history deployment myapp-deployment # 查看历史版本
    kubectl rollout undo deployment myapp-deployment # 不指定就会回到上一个版本，注意undo一次会产生一个新的版本，所以一直undo时不会回到很之前的版本的，我们会在新旧两个版本里面打转 
    kubectl rollout undo deployment myapp-deployment --to-revision 22 # 指定版本回滚

scale

  • 为deployment、replica set、replication controller、statefulset设置pod的副本数
    1
    2
    3
    kubectl scale deployment myapp-deployment --replicas 30 # 扩容
    kubectl get pod # 查看效果
    kubectl scale deployment myapp-deployment --replicas 5 # 缩容

autoscale

  • 创建自动伸缩器，自动选择和设置在k8s集群中运行的pod数。
    1
    2
    3
    4
    5
    kubectl autoscale deployment myapp-deployment --min=2 --max=10 # 最少2个，最多10个，采用默认缩放策略

    kubectl autoscale deployment myapp-deployment --max=5 --cpu-percent=80 # 最多5个，目标pod cpu利用率80%
    # 自动伸缩容是如何做的？是帮我们生成了一个用来自动伸缩容的控制器。
    kubectl get horizontalpodautoscalers # 查看自动伸缩容器

kubectl集群管理

cluster-info

  • 显示集群信息
    1
    kubectl cluster-info

dump

  • 集群信息输出
    1
    2
    3
    kubectl cluster-info dump # 将当前集群信息输出
    kubectl cluster-info --output-directory=$HOME/cluster-state -o yaml # 指定输出位置
    kubectl cluster-info --output-directory=$HOME/cluster-state -o yaml --namespaces default,kube-system # 指定输出位置，指定命名空间

cordon

  • 标记节点为不可调度
    1
    2
    kubectl get node -o wide # 查看下节点
    kubectl cordon k8s-node1 # 新产生的pod不会再分配到k8s-node1上了，但是原来的pod可以被移走

uncordon

  • 标记节点为可调度
    1
    kubectl uncordon k8s-node1 # 现有的pod也不会被立马分配到node1上

drain

  • 腾空节点，准备维护，该操作会自动将节点设置为不可调度状态
    1
    2
    kubectl drain k8s-node1 --force --ignore-daemonsets # 所有的pod都会被调度走，除了守护进程（因为它是依附于节点的）
    kubectl uncordon k8s-node1 # 记得恢复状态

kubectl故障排除和调试命令

describe

  • 显示某个资源或某组资源的详细信息
    1
    2
    3
    kubectl describe nodes k8s-node1
    kubectl describe pod myapp-deployment-2981ewqt
    kubectl describe node k8s # 以k8s开头的节点

logs

  • 输出pod中某容器的日志，注意是容器
    1
    2
    3
    4
    5
    kubectl logs nginx # 获取pod中第一个容器的日志
    kubectl logs pod/myapp-deployment-1298qeqwrt # 注意这里是/不能是空格，大部分命令是都可以的，这里不行
    kubectl logs -l name=myapp --all-containers=true # 根据label来找到所有容器，将所有容器的日志输出
    kubectl logs --tail=5 nginx # 获取最近5行的日志
    kubectl logs --since=1h nginx # 获取一个小时的日志

attach

  • 连接到一个正在运行的容器，是针对容器的，所以无论是对deployment还是service都是找到一个容器的
    1
    kubectl attach deployments/myapp-deployment

exec

  • 在容器里面执行相关命令，是针对容器的，所以无论是对deployment还是service都是找到一个容器的
    1
    2
    kubectl exec myapp-deployment-oiqnetoiqhwpeotih --date # 查看pod的时间
    kubectl -it exec myapp-deployment-oiqnetoiqhwpeotih --sh # 开启pod的交互命令

port-forward

  • 将一个或多个本地端口转发到pod，如果多个符合条件，自动选择一个pod。是针对容器的，所以无论是对deployment还是service都是找到一个容器的
    1
    2
    3
    4
    5
    kubectl run nginx --image=nginx 
    kubectl port-forward pod/nginx 5000 6000 # 转发5000和6000端口到pod/nginx的5000或6000端口
    kubectl port-forward pod/nginx 5000:80 6000:81 # 转发5000和6000端口到pod/nginx的80或81端口 
    kubectl port-forward service/myapp-svc 8000:http # 转发8000端口到service/myapp-svc的http端口上，我们可以发现，做了之后就没有负载均衡了，证明port-forward是针对一个单独的容器的
    kubectl port-forward --address localhost,192.168.239.142 pod/nginx 8888:80 # 指定监听的地址和端口

proxy

  • 在本机主机和k8s api服务器之间创建代理服务器或应用程序网关。
    1
    2
    3
    kubectl prox --api-prefix=/custom/ --port=8011 --www=$HOME/ --www-prefix=/static/ 
    curl http://localhost:8011/custom/api/v1/pods # 可以拿到集群里所有的pods，也就是通过静态站点可以访问k8s api了，可以拿到集群的很多数据
    curl http://localhost:8011/static/ # 查看静态站点的列表

cp

  • 将文件和目录考入、考出容器
    1
    2
    kubectl cp /tmp/app myapp-deployment-nonot574:app1 # 把/tmp/app文件复制到pod的第一个容器当前工作目录下，命名为app1
    kubectl exec myapp-deployment-nonot574 ls # 看看结果

debug

  • 创建用于排查工作负载和节点故障的调试会话
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    kubectl run nginx --image=nginx # 运行一个nginx pod
    kubectl debug nginx -it --image=unbuntu --copy-to=my-debugger --share-processes # 创建一个新的pod my-debugger用来调试，将原来pod内的容器拷贝到新的pod，并添加一个镜像为ubuntu的容器并且通过进程共享，我们的my-debugger会和nginx共享进程空间
    kubectl get pod my-debugger -o yaml | grep shareProcessNamespace # 开启另一个终端，可以查看命名空间共享配置
    > ps # 查看一下进程

    # =========================================
    kubectl run myhello -image=xlhmzch/hello:1.0.0
    kubectl debug myhello -it --copy-to=my-debugger1 --container=myhello -- /bin/sh # 更改容器启动命令

    kubectl debug myhello -it --copy-to=my-debugger2 --set-image=hello=xlhmzch/hello:1.0.1 # 更改容器镜像
    # =========================================
    kubectl debug node/k8s-node1 -it --image=busybox # 使用debug调试节点
    # 一般情况下不需要使用debug进行调试，除非某个容器没有sh，没办法使用exec进行调试
2024-12-30 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go云原生】Kubernetes Pod 下一篇：【go云原生】Kubernetes基本使用
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题