安装源

# 安装其中一个源即可
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.163.com/.help/CentOS7-Base-163.repo
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
yum makecache

1、配置hostname

# 1、配置主机名
# 根据规划设置主机名【master节点上操作】
hostnamectl set-hostname m1
# 根据规划设置主机名【node01节点操作】
hostnamectl set-hostname s1

# 2、配置host
cat >> /etc/hosts << EOF
192.168.245.139 m1
192.168.245.137 s1
EOF

# 3.关闭防火墙与SELINUX
# 关闭防火墙
systemctl stop firewalld
systemctl disable firewalld
# 关闭selinux
sed -i 's/enforcing/disabled/' /etc/selinux/config
setenforce 0

# 4、时间同步配置
yum install chrony -y
systemctl start chronyd && systemctl enable chronyd && chronyc sources
date

# 5、关闭swap分区
sed -ri 's/.*swap.*/#&/' /etc/fstab  
swapoff -a
grep swap /etc/fstab

# 6、配置内核路由转发及网桥过滤
cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward=1
vm.swappiness=0
EOF
sysctl --system

# 加载br_netfilter模块
modprobe  br_netfilter
lsmod |grep  br_netfilter

# 7、配置ipvs转发
yum -y install ipset ipvsadm

# 配置ipvsadm模块加载方式
# 添加需要加载的模块
$ mkdir -p /etc/sysconfig/ipvsadm
cat > /etc/sysconfig/ipvsadm/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack
EOF

# 授权、运行、检查是否加载
$ chmod 755 /etc/sysconfig/ipvsadm/ipvs.modules && bash /etc/sysconfig/ipvsadm/ipvs.modules && lsmod | grep -e ip_vs -e nf_conntrack

2、安装k8s的Runtime

本文使用Docker作为k8s的Runtime，docker安装时，会自动安装containerd，本文只配置Docker运行时

2.1、安装Docker

yum -y install wget && wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
yum -y install docker-ce-26.1.*

# 配置cgroup驱动及镜像下载加速器：
cat > /etc/docker/daemon.json << EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
   "registry-mirrors": [
        "https://atomhub.openatom.cn",
        "https://registry.dockermirror.com"
	]
}
EOF

systemctl enable docker && systemctl start docker && systemctl status docker && docker info|grep systemd

2.2 安装cri-dockerd

在 Kubernetes v1.24之后的版本使用使用cri-dockerd适配器才能使用Docker Engine。

# 下载安装cri-dockerd
curl -LO https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.14/cri-dockerd-0.3.14-3.el7.x86_64.rpm
rpm -ivh cri-dockerd-0.3.14-3.el7.x86_64.rpm
     
## 指定用作Pod 的基础容器的容器镜像（“pause 镜像”）
vi /usr/lib/systemd/system/cri-docker.service
ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:// --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9

systemctl daemon-reload 
systemctl enable cri-docker && systemctl start cri-docker && systemctl status cri-docker

将 Docker Engine 节点从 dockershim 迁移到 cri-dockerd

3、安装k8s

3.1、安装k8s组件

安装kubelet、kubeadm、kubectl

# 配置k8s源
cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.29/rpm/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.29/rpm/repodata/repomd.xml.key
EOF

#更新yum缓存
$ yum clean all  && yum makecache

# yum install -y kubelet kubeadm kubectl
yum install -y kubelet-1.29.6 kubectl-1.29.6 kubeadm-1.29.6


# 配置 cgroup 驱动与docker一致
cat > /etc/sysconfig/kubelet <<EOF
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"
EOF
#--container-runtime-endpoint 标志，将其设置为 unix:///var/run/cri-dockerd.sock
# KUBELET_KUBEADM_ARGS="--container-runtime-endpoint=/run/cri-dockerd.sock"

# 添加配置
cat > /var/lib/kubelet/kubeadm-flags.env <<EOF
KUBELET_KUBEADM_ARGS="--container-runtime-endpoint=unix:///var/run/cri-dockerd.sock --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9"
EOF

systemctl enable kubelet
sudo systemctl daemon-reload
sudo systemctl restart kubelet

3.2、初始化k8s

3.2.1、拉取k8s相关镜像

# 查看配置镜像
kubeadm config images list --image-repository registry.aliyuncs.com/google_containers --kubernetes-version=v1.29.6

# 拉取配置镜像
kubeadm config images pull  --image-repository registry.aliyuncs.com/google_containers --kubernetes-version=v1.29.6 \
--cri-socket=unix:///var/run/cri-dockerd.sock

3.2.2、集群初始化

# 初始化集群
kubeadm init \
--apiserver-advertise-address 192.168.245.139  \
--kubernetes-version v1.29.6 \
--pod-network-cidr=10.244.0.0/16 \
--image-repository registry.aliyuncs.com/google_containers \
--ignore-preflight-errors=all \
--cri-socket=unix:///var/run/cri-dockerd.sock

成功后，会提示如下信息

###############
Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.245.139:6443 --token a41jge.uvsihnzemuo0kuer \
        --discovery-token-ca-cert-hash sha256:6986aea3fb42c28a194b451b54b1b2d7cf461c56583667f7d345a108b8d96fa9 \
        --cri-socket=unix:///var/run/cri-dockerd.sock

报错提示registry.k8s.io/pause:3.9镜像未找到
解决方案：

$ docker pull registry.aliyuncs.com/google_containers/pause:3.9
$ docker tag registry.aliyuncs.com/google_containers/pause:3.9 registry.k8s.io/pause:3.9

3.3、安装网络组件calico

网络组件可以选用calico或flannel

3.3.1、在线安装calico

wget https://raw.githubusercontent.com/projectcalico/calico/v3.27.3/manifests/calico.yaml
# 安装
kubectl apply -f calico.yaml

# 删除网络
# kubectl delete -f calico.yaml 
# kubectl get pods -n kube-system

3.3.2、离线安装calico

上边的安排可能会因为网络原因无法下载镜像导致出错，下边介绍calico离线安装的方法

#查看查看calico所需的镜像包:https://raw.githubusercontent.com/projectcalico/calico/v3.27.3/manifests/calico.yaml
[root@m1 ~]# cat calico.yaml |grep image:
image: docker.io/calico/cni:v3.27.3
image: docker.io/calico/cni:v3.27.3
image: docker.io/calico/node:v3.27.3
image: docker.io/calico/node:v3.27.3
image: docker.io/calico/kube-controllers:v3.27.3

# 下载https://github.com/projectcalico/calico/releases/download/v3.27.3/release-v3.27.3.tgz
# release-v3.27.3.tgz:包含docker镜像,编译程序和kubernetes配置, binaries, and kubernetes manifests.
# 上传release-v3.27.3.tgz到m1、s1服务器，通过docker导入到本地
# 导入镜像到本地
docker load -i release-v3.27.3/images/calico-cni.tar
docker load -i release-v3.27.3/images/calico-node.tar
docker load -i release-v3.27.3/images/calico-kube-controllers.tar

# m1服务器安装calico
kubectl apply -f calico.yaml

#查看 calico-node Pod 的详细状态和事件信息，通过
kubectl describe pod calico-node-bjw5m -n kube-system

在 Linux 系统中安装并设置 kubectl
命令行工具 kubectl

3.4、节点加入

# 添加节点
kubeadm join 192.168.245.139:6443 --token a41jge.uvsihnzemuo0kuer \
        --discovery-token-ca-cert-hash sha256:6986aea3fb42c28a194b451b54b1b2d7cf461c56583667f7d345a108b8d96fa9 \
        --cri-socket=unix:///var/run/cri-dockerd.sock

#默认token有效期为24小时，当过期之后，该token就不可用了。这时就需要重新创建token，可以直接使用命令快捷生成：
kubeadm token create --print-join-command
# 获取token信息
kubeadm  token list
#在node节点重置kubeadm
kubeadm reset --cri-socket=unix:///var/run/cri-dockerd.sock
#在master节点删除node节点
kubectl delete nodes s1

4、部署应用

4.1、命令发布

[root@m1 ~]# kubectl create deployment nginx --image=nginx
deployment.apps/nginx created
[root@m1 ~]# kubectl expose deployment nginx --port=80 --type=NodePort
service/nginx exposed
# [root@m1 ~]# kubectl get pod,svc
[root@m1 ~]# kubectl get pods,svc -o wide
NAME                         READY   STATUS    RESTARTS   AGE     IP               NODE   NOMINATED NODE   READINESS GATES
pod/nginx-7854ff8877-928pw   1/1     Running   0          6d17h   10.244.152.196   s1     <none>           <none>

NAME                 TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE     SELECTOR
service/kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP        6d23h   <none>
service/nginx        NodePort    10.107.193.156   <none>        80:31150/TCP   6d17h   app=nginx

# 其它命令删除应用
[root@m1 ~]# kubectl delete deployment  nginx
# 其它命令删除服务
[root@m1 ~]# kubectl delete service nginx

浏览器访问http://192.168.245.144:31150，

4.2、通过配置发布

# 文件deployment.yaml配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app
  labels:
    app: nginx-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-app
  template:
    metadata:
      labels:
        app: nginx-app
    spec:
      containers:
      - name: nginx-containers
        imagePullPolicy: IfNotPresent
        image: nginx
        ports:
        - containerPort: 80
 
# 文件service.yaml配置
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-service
spec:
  selector:
    app: nginx-app
  ports:
    - protocol: TCP
      port: 81
      targetPort: 80
      nodePort: 30080
  type: NodePort

发布

# 发布
kubectl create -f deployment_nginx.yml
kubectl create -f service_nginx.yml
# 删除
kubectl delete -f deployment_nginx.yml
kubectl delete -f service_nginx.yml

5、常用yaml详解

5.1、Deployment yaml 详解

apiVersion: apps/v1        # 指定api版本，此值必须在kubectl api-versions中。业务场景一般首选”apps/v1“
kind: Deployment        # 指定创建资源的角色/类型   
metadata:          # 资源的元数据/属性 
  name: demo      # 资源的名字，在同一个namespace中必须唯一
  namespace: default     # 部署在哪个namespace中。不指定时默认为default命名空间
  labels:          # 自定义资源的标签
    app: demo
    version: stable
  annotations:  # 自定义注释列表
    name: string
spec:     # 资源规范字段，定义deployment资源需要的参数属性，诸如是否在容器失败时重新启动容器的属性
  replicas: 1     # 声明副本数目
  revisionHistoryLimit: 3     # 保留历史版本
  selector:     # 标签选择器
    matchLabels:     # 匹配标签，需与上面的标签定义的app保持一致
      app: demo
      version: stable
  strategy:     # 策略
    type: RollingUpdate     # 滚动更新策略
      # ecreate：删除所有已存在的pod,重新创建新的
      # RollingUpdate：滚动升级，逐步替换的策略，同时滚动升级时，支持更多的附加参数，
    # 例如设置最大不可用pod数量，最小升级间隔时间等等
    rollingUpdate:             # 滚动更新
      maxSurge: 1             # 滚动升级时最大额外可以存在的副本数，可以为百分比，也可以为整数
      maxUnavailable: 0     # 在更新过程中进入不可用状态的 Pod 的最大值，可以为百分比，也可以为整数
  template:     # 定义业务模板，如果有多个副本，所有副本的属性会按照模板的相关配置进行匹配
    metadata:     # 资源的元数据/属性 
      annotations:         # 自定义注解列表
        sidecar.istio.io/inject: "false"     # 自定义注解名字
      labels:     # 自定义资源的标签
        app: demo    # 模板名称必填
        version: stable
    spec:     # 资源规范字段
      restartPolicy: Always        # Pod的重启策略。[Always | OnFailure | Nerver]
        # Always ：在任何情况下，只要容器不在运行状态，就自动重启容器。默认
        # OnFailure ：只在容器异常时才自动容器容器。
        # 对于包含多个容器的pod，只有它里面所有的容器都进入异常状态后，pod才会进入Failed状态
      # Nerver ：从来不重启容器
      nodeSelector:       # 将该Pod调度到包含这个label的node上，仅能基于简单的等值关系定义标签选择器
        caas_cluster: work-node
      containers:        # Pod中容器列表
        - name: demo         # 容器的名字   
          image: demo:v1         # 容器使用的镜像地址   
          imagePullPolicy: IfNotPresent     # 每次Pod启动拉取镜像策略
            # IfNotPresent ：如果本地有就不检查，如果没有就拉取。默认 
            # Always : 每次都检查
          # Never : 每次都不检查（不管本地是否有）
          command: [string]     # 容器的启动命令列表，如不指定，使用打包时使用的启动命令
          args: [string]         # 容器的启动命令参数列表
            # 如果command和args均没有写，那么用Docker默认的配置
            # 如果command写了，但args没有写，那么Docker默认的配置会被忽略而且仅仅执行.yaml文件的command（不带任何参数的）
            # 如果command没写，但args写了，那么Docker默认配置的ENTRYPOINT的命令行会被执行，但是调用的参数是.yaml中的args
          # 如果如果command和args都写了，那么Docker默认的配置被忽略，使用.yaml的配置
          workingDir: string      # 容器的工作目录
          volumeMounts:        # 挂载到容器内部的存储卷配置
            - name: string         # 引用pod定义的共享存储卷的名称，需用volumes[]部分定义的的卷名
              mountPath: string        # 存储卷在容器内mount的绝对路径，应少于512字符
              readOnly: boolean        # 是否为只读模式
            - name: string
              configMap:         # 类型为configMap的存储卷，挂载预定义的configMap对象到容器内部
                name: string
                items:
                  - key: string
                    path: string
          ports:    # 需要暴露的端口库号列表
            - name: http     # 端口号名称
              containerPort: 8080     # 容器开放对外的端口 
              # hostPort: 8080    # 容器所在主机需要监听的端口号，默认与Container相同
              protocol: TCP     # 端口协议，支持TCP和UDP，默认TCP
          env:    # 容器运行前需设置的环境变量列表
            - name: string     # 环境变量名称
              value: string    # 环境变量的值
          resources:     # 资源管理。资源限制和请求的设置
            limits:     # 资源限制的设置，最大使用
              cpu: "1"         # CPU，"1"(1核心) = 1000m。将用于docker run --cpu-shares参数
              memory: 500Mi     # 内存，1G = 1024Mi。将用于docker run --memory参数
            requests:  # 资源请求的设置。容器运行时，最低资源需求，也就是说最少需要多少资源容器才能正常运行
              cpu: 100m
              memory: 100Mi
          livenessProbe:     # pod内部的容器的健康检查的设置。当探测无响应几次后将自动重启该容器
            # 检查方法有exec、httpGet和tcpSocket，对一个容器只需设置其中一种方法即可
            httpGet: # 通过httpget检查健康，返回200-399之间，则认为容器正常
              path: /healthCheck     # URI地址。如果没有心跳检测接口就为/
              port: 8089         # 端口
              scheme: HTTP     # 协议
              # host: 127.0.0.1     # 主机地址
            # 也可以用这两种方法进行pod内容器的健康检查
            # exec:         # 在容器内执行任意命令，并检查命令退出状态码，如果状态码为0，则探测成功，否则探测失败容器重启
            #   command:   
            #     - cat   
            #     - /tmp/health   
            # 也可以用这种方法   
            # tcpSocket: # 对Pod内容器健康检查方式设置为tcpSocket方式
            #   port: number 
            initialDelaySeconds: 30     # 容器启动完成后首次探测的时间，单位为秒
            timeoutSeconds: 5     # 对容器健康检查等待响应的超时时间，单位秒，默认1秒
            periodSeconds: 30     # 对容器监控检查的定期探测间隔时间设置，单位秒，默认10秒一次
            successThreshold: 1     # 成功门槛
            failureThreshold: 5     # 失败门槛，连接失败5次，pod杀掉，重启一个新的pod
          readinessProbe:         # Pod准备服务健康检查设置
            httpGet:
              path: /healthCheck    # 如果没有心跳检测接口就为/
              port: 8089
              scheme: HTTP
            initialDelaySeconds: 30
            timeoutSeconds: 5
            periodSeconds: 10
            successThreshold: 1
            failureThreshold: 5
          lifecycle:        # 生命周期管理  
            postStart:    # 容器运行之前运行的任务  
              exec:
                command:
                  - 'sh'
                  - 'yum upgrade -y'
            preStop:        # 容器关闭之前运行的任务  
              exec:
                command: ['service httpd stop']
      initContainers:        # 初始化容器
        - command:
            - sh
            - -c
            - sleep 10; mkdir /wls/logs/nacos-0
          env:
          image: {{ .Values.busyboxImage }}
          imagePullPolicy: IfNotPresent
          name: init
          volumeMounts:
            - mountPath: /wls/logs/
              name: logs
      volumes:
        - name: logs
          hostPath:
            path: {{ .Values.nfsPath }}/logs
      volumes:     # 在该pod上定义共享存储卷列表
        - name: string         # 共享存储卷名称 （volumes类型有很多种）
          emptyDir: {}         # 类型为emtyDir的存储卷，与Pod同生命周期的一个临时目录。为空值
        - name: string
          hostPath:          # 类型为hostPath的存储卷，表示挂载Pod所在宿主机的目录
            path: string    # Pod所在宿主机的目录，将被用于同期中mount的目录
        - name: string
          secret:             # 类型为secret的存储卷，挂载集群与定义的secre对象到容器内部
            scretname: string
            items:
              - key: string
                path: string
      imagePullSecrets:     # 镜像仓库拉取镜像时使用的密钥，以key：secretkey格式指定
        - name: harbor-certification
      hostNetwork: false    # 是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
      terminationGracePeriodSeconds: 30     # 优雅关闭时间，这个时间内优雅关闭未结束，k8s 强制 kill
      dnsPolicy: ClusterFirst    # 设置Pod的DNS的策略。默认ClusterFirst
        # 支持的策略：[Default | ClusterFirst | ClusterFirstWithHostNet | None]
        # Default : Pod继承所在宿主机的设置，也就是直接将宿主机的/etc/resolv.conf内容挂载到容器中
        # ClusterFirst : 默认的配置，所有请求会优先在集群所在域查询，如果没有才会转发到上游DNS
        # ClusterFirstWithHostNet : 和ClusterFirst一样，不过是Pod运行在hostNetwork:true的情况下强制指定的
      # None : 1.9版本引入的一个新值，这个配置忽略所有配置，以Pod的dnsConfig字段为准
      affinity:  # 亲和性调试
        nodeAffinity:     # 节点亲和性。满足特定条件的pod对象运行在同一个node上。效果同nodeSelector，但功能更强大
          requiredDuringSchedulingIgnoredDuringExecution:     # 硬亲和性
            nodeSelectorTerms:         # 节点满足任何一个条件就可以
              - matchExpressions:     # 有多个选项时，则只有同时满足这些逻辑选项的节点才能运行 pod
                  - key: beta.kubernetes.io/arch
                    operator: In
                    values:
                      - amd64
        podAffinity:     # pod亲和性。满足特定条件的pod对象运行在同一个node上
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - nginx
              topologyKey: kubernetes.io/hostname
        podAntiAffinity:     # pod反亲和性。满足特定条件（相同pod标签）的pod对象不能运行在同一个node上
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - nginx
              topologyKey: kubernetes.io/hostname        # 反亲和性的节点标签 key
      tolerations:        # 污点容忍度。允许pod可以运行在匹配的污点上
        - operator: "Equal"        # 匹配类型。支持[Exists | Equal(默认值)]。Exists为容忍所有污点
          key: "key1"
          value: "value1"
          effect: "NoSchedule"        # 污点类型：[NoSchedule | PreferNoSchedule | NoExecute]
            # NoSchedule ：不会被调度 
            # PreferNoSchedule：尽量不调度
          # NoExecute：驱逐节点

5.2、Service yaml 详解

apiVersion: v1     # 指定api版本，此值必须在kubectl api-versions中 
kind: Service     # 指定创建资源的角色/类型 
metadata:     # 资源的元数据/属性
  name: demo     # 资源的名字，在同一个namespace中必须唯一
  namespace: default     # 部署在哪个namespace中。不指定时默认为default命名空间
  labels:         # 设定资源的标签
  - app: demo
  annotations:  # 自定义注解属性列表
  - name: string
spec:     # 资源规范字段
  type: ClusterIP     # service的类型，指定service的访问方式，默认ClusterIP。
      # ClusterIP类型：虚拟的服务ip地址，用于k8s集群内部的pod访问，在Node上kube-porxy通过设置的iptables规则进行转发
      # NodePort类型：使用宿主机端口，能够访问各个Node的外部客户端通过Node的IP和端口就能访问服务器
      # LoadBalancer类型：使用外部负载均衡器完成到服务器的负载分发，需要在spec.status.loadBalancer字段指定外部负载均衡服务器的IP，并同时定义nodePort和clusterIP用于公有云环境。
  clusterIP: string        #虚拟服务IP地址，当type=ClusterIP时，如不指定，则系统会自动进行分配，也可以手动指定。当type=loadBalancer，需要指定
  sessionAffinity: string    #是否支持session，可选值为ClietIP，默认值为空。ClientIP表示将同一个客户端(根据客户端IP地址决定)的访问请求都转发到同一个后端Pod
  ports:
    - port: 8080     # 服务监听的端口号
      targetPort: 8080     # 容器暴露的端口
      nodePort: int        # 当type=NodePort时，指定映射到物理机的端口号
      protocol: TCP     # 端口协议，支持TCP或UDP，默认TCP
      name: http     # 端口名称
  selector:     # 选择器。选择具有指定label标签的pod作为管理范围
    app: demo
status:    # 当type=LoadBalancer时，设置外部负载均衡的地址，用于公有云环境    
  loadBalancer:    # 外部负载均衡器    
    ingress:
      ip: string    # 外部负载均衡器的IP地址
      hostname: string    # 外部负载均衡器的主机名

5.3、ingress.yaml 文件详解

apiVersion: extensions/v1beta1         # 创建该对象所使用的 Kubernetes API 的版本     
kind: Ingress         # 想要创建的对象的类别，这里为Ingress
metadata:
  name: showdoc        # 资源名字，同一个namespace中必须唯一
  namespace: op     # 定义资源所在命名空间
  annotations:         # 自定义注解
    kubernetes.io/ingress.class: nginx        # 声明使用的ingress控制器
spec:
  rules:
  - host: showdoc.example.cn     # 服务的域名
    http:
      paths:
      - path: /      # 路由路径
        backend:     # 后端Service
          serviceName: showdoc        # 对应Service的名字
          servicePort: 80           # 对应Service的端口

6、kubectl命令快速参考

6.1、kubectl 自动补全

BASH

source <(kubectl completion bash) # 在 bash 中设置当前 shell 的自动补全，要先安装 bash-completion 包
echo "source <(kubectl completion bash)" >> ~/.bashrc # 在你的 bash shell 中永久地添加自动补全

你还可以在补全时为 kubectl 使用一个速记别名：

alias k=kubectl
complete -o default -F __start_kubectl k

ZSH

source <(kubectl completion zsh)  # 在 zsh 中设置当前 shell 的自动补全
echo '[[ $commands[kubectl] ]] && source <(kubectl completion zsh)' >> ~/.zshrc # 在你的 zsh shell 中永久地添加自动补全

FISH
说明： 需要 kubectl 版本 1.23 或更高版本。

echo 'kubectl completion fish | source' > ~/.config/fish/completions/kubectl.fish && source ~/.config/fish/completions/kubectl.fish

关于 --all-namespaces 的一点说明
我们经常用到 --all-namespaces 参数，你应该要知道它的简写：

kubectl -A

6.2、kubectl 上下文和配置

设置 kubectl 与哪个 Kubernetes 集群进行通信并修改配置信息。 查看使用 kubeconfig 跨集群授权访问 文档获取配置文件详细信息。

kubectl config view # 显示合并的 kubeconfig 配置

# 同时使用多个 kubeconfig 文件并查看合并的配置
KUBECONFIG=~/.kube/config:~/.kube/kubconfig2

kubectl config view

# 显示合并的 kubeconfig 配置和原始证书数据以及公开的 Secret
kubectl config view --raw

# 获取 e2e 用户的密码
kubectl config view -o jsonpath='{.users[?(@.name == "e2e")].user.password}'

# 获取 e2e 用户的证书
kubectl config view --raw -o jsonpath='{.users[?(.name == "e2e")].user.client-certificate-data}' | base64 -d

kubectl config view -o jsonpath='{.users[].name}'    # 显示第一个用户
kubectl config view -o jsonpath='{.users[*].name}'   # 获取用户列表
kubectl config get-contexts                          # 显示上下文列表
kubectl config get-contexts -o name                  # 获取所有上下文的名称
kubectl config current-context                       # 展示当前所处的上下文
kubectl config use-context my-cluster-name           # 设置默认的上下文为 my-cluster-name

kubectl config set-cluster my-cluster-name           # 在 kubeconfig 中设置集群条目

# 在 kubeconfig 中配置代理服务器的 URL，以用于该客户端的请求
kubectl config set-cluster my-cluster-name --proxy-url=my-proxy-url

# 添加新的用户配置到 kubeconf 中，使用 basic auth 进行身份认证
kubectl config set-credentials kubeuser/foo.kubernetes.com --username=kubeuser --password=kubepassword

# 在指定上下文中持久性地保存名字空间，供所有后续 kubectl 命令使用
kubectl config set-context --current --namespace=ggckad-s2

# 使用特定的用户名和名字空间设置上下文
kubectl config set-context gce --user=cluster-admin --namespace=foo \
&& kubectl config use-context gce

kubectl config unset users.foo                       # 删除用户 foo

# 设置或显示 context / namespace 的短别名
# （仅适用于 bash 和 bash 兼容的 shell，在使用 kn 设置命名空间之前要先设置 current-context）
alias kx='f() { [ "$1" ] && kubectl config use-context $1 || kubectl config current-context ; } ; f'
alias kn='f() { [ "$1" ] && kubectl config set-context --current --namespace $1 || kubectl config view --minify | grep namespace | cut -d" " -f6 ; } ; f'

6.3、kubectl apply

apply 通过定义 Kubernetes 资源的文件来管理应用。 它通过运行 kubectl apply 在集群中创建和更新资源。 这是在生产中管理 Kubernetes 应用的推荐方法。 参见 kubectl 文档。

6.4、创建对象

Kubernetes 配置可以用 YAML 或 JSON 定义。可以使用的文件扩展名有 .yaml、.yml 和 .json。

kubectl apply -f ./my-manifest.yaml                  # 创建资源
kubectl apply -f ./my1.yaml -f ./my2.yaml            # 使用多个文件创建
kubectl apply -f ./dir                               # 基于目录下的所有清单文件创建资源
kubectl apply -f https://example.com/manifest.yaml   # 从 URL 中创建资源（注意：这是一个示例域名，不包含有效的清单）
kubectl create deployment nginx --image=nginx        # 启动单实例 nginx

# 创建一个打印 “Hello World” 的 Job
kubectl create job hello --image=busybox:1.28 -- echo "Hello World"

# 创建一个打印 “Hello World” 间隔 1 分钟的 CronJob
kubectl create cronjob hello --image=busybox:1.28   --schedule="*/1 * * * *" -- echo "Hello World"

kubectl explain pods                          # 获取 Pod 清单的文档说明

# 从标准输入创建多个 YAML 对象
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep
spec:
containers:
- name: busybox
  image: busybox:1.28
  args:
    - sleep
    - "1000000"
---
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep-less
spec:
containers:
- name: busybox
  image: busybox:1.28
  args:
    - sleep
    - "1000"
      EOF

# 创建有多个 key 的 Secret
kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
name: mysecret
type: Opaque
data:
password: $(echo -n "s33msi4" | base64 -w0)
username: $(echo -n "jane" | base64 -w0)
EOF

6.5、查看和查找资源

# get 命令的基本输出
kubectl get services                          # 列出当前命名空间下的所有 Service
kubectl get pods --all-namespaces             # 列出所有命名空间下的全部的 Pod
kubectl get pods -o wide                      # 列出当前命名空间下的全部 Pod 并显示更详细的信息
kubectl get deployment my-dep                 # 列出某个特定的 Deployment
kubectl get pods                              # 列出当前命名空间下的全部 Pod
kubectl get pod my-pod -o yaml                # 获取一个 Pod 的 YAML

# describe 命令的详细输出
kubectl describe nodes my-node
kubectl describe pods my-pod

# 列出当前名字空间下所有 Service，按名称排序
kubectl get services --sort-by=.metadata.name

# 列出 Pod，按重启次数排序
kubectl get pods --sort-by='.status.containerStatuses[0].restartCount'

# 列举所有 PV 持久卷，按容量排序
kubectl get pv --sort-by=.spec.capacity.storage

# 获取包含 app=cassandra 标签的所有 Pod 的 version 标签
kubectl get pods --selector=app=cassandra -o \
jsonpath='{.items[*].metadata.labels.version}'

# 检索带有 “.” 键值，例如 'ca.crt'
kubectl get configmap myconfig \
-o jsonpath='{.data.ca\.crt}'

# 检索一个 base64 编码的值，其中的键名应该包含减号而不是下划线
kubectl get secret my-secret --template='{{index .data "key-name-with-dashes"}}'

# 获取所有工作节点（使用选择算符以排除标签名称为 'node-role.kubernetes.io/control-plane' 的结果）
kubectl get node --selector='!node-role.kubernetes.io/control-plane'

# 获取当前命名空间中正在运行的 Pod
kubectl get pods --field-selector=status.phase=Running

# 获取全部节点的 ExternalIP 地址
kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'

# 列出属于某个特定 RC 的 Pod 的名称
# 在转换对于 jsonpath 过于复杂的场合，"jq" 命令很有用；可以在 https://jqlang.github.io/jq/ 找到它
sel=${$(kubectl get rc my-rc --output=json | jq -j '.spec.selector | to_entries | .[] | "\(.key)=\(.value),"')%?}
echo $(kubectl get pods --selector=$sel --output=jsonpath={.items..metadata.name})

# 显示所有 Pod 的标签（或任何其他支持标签的 Kubernetes 对象）
kubectl get pods --show-labels

# 检查哪些节点处于就绪状态
JSONPATH='{range .items[*]}{@.metadata.name}:{range @.status.conditions[*]}{@.type}={@.status};{end}{end}' \
&& kubectl get nodes -o jsonpath="$JSONPATH" | grep "Ready=True"

# 使用自定义列检查哪些节点处于就绪状态
kubectl get node -o custom-columns='NODE_NAME:.metadata.name,STATUS:.status.conditions[?(@.type=="Ready")].status'

# 不使用外部工具来输出解码后的 Secret
kubectl get secret my-secret -o go-template='{{range $k,$v := .data}}{{"### "}}{{$k}}{{"\n"}}{{$v|base64decode}}{{"\n\n"}}{{end}}'

# 列出被一个 Pod 使用的全部 Secret
kubectl get pods -o json | jq '.items[].spec.containers[].env[]?.valueFrom.secretKeyRef.name' | grep -v null | sort | uniq

# 列举所有 Pod 中初始化容器的容器 ID（containerID）
# 可用于在清理已停止的容器时避免删除初始化容器
kubectl get pods --all-namespaces -o jsonpath='{range .items[*].status.initContainerStatuses[*]}{.containerID}{"\n"}{end}' | cut -d/ -f3

# 列出事件（Event），按时间戳排序
kubectl get events --sort-by=.metadata.creationTimestamp

# 列出所有警告事件
kubectl events --types=Warning

# 比较当前的集群状态和假定某清单被应用之后的集群状态
kubectl diff -f ./my-manifest.yaml

# 生成一个句点分隔的树，其中包含为节点返回的所有键
# 在复杂的嵌套JSON结构中定位键时非常有用
kubectl get nodes -o json | jq -c 'paths|join(".")'

# 生成一个句点分隔的树，其中包含为 Pod 等返回的所有键
kubectl get pods -o json | jq -c 'paths|join(".")'

# 假设你的 Pod 有默认的容器和默认的名字空间，并且支持 'env' 命令，可以使用以下脚本为所有 Pod 生成 ENV 变量。
# 该脚本也可用于在所有的 Pod 里运行任何受支持的命令，而不仅仅是 'env'。
for pod in $(kubectl get po --output=jsonpath={.items..metadata.name}); do echo $pod && kubectl exec -it $pod -- env; done

# 获取一个 Deployment 的 status 子资源
kubectl get deployment nginx-deployment --subresource=status

6.5、更新资源

kubectl set image deployment/frontend www=image:v2               # 滚动更新 "frontend" Deployment 的 "www" 容器镜像
kubectl rollout history deployment/frontend                      # 检查 Deployment 的历史记录，包括版本
kubectl rollout undo deployment/frontend                         # 回滚到上次部署版本
kubectl rollout undo deployment/frontend --to-revision=2         # 回滚到特定部署版本
kubectl rollout status -w deployment/frontend                    # 监视 "frontend" Deployment 的滚动升级状态直到完成
kubectl rollout restart deployment/frontend                      # 轮替重启 "frontend" Deployment

cat pod.json | kubectl replace -f -                              # 通过传入到标准输入的 JSON 来替换 Pod

# 强制替换，删除后重建资源。会导致服务不可用。
kubectl replace --force -f ./pod.json

# 为多副本的 nginx 创建服务，使用 80 端口提供服务，连接到容器的 8000 端口
kubectl expose rc nginx --port=80 --target-port=8000

# 将某单容器 Pod 的镜像版本（标签）更新到 v4
kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | kubectl replace -f -

kubectl label pods my-pod new-label=awesome                      # 添加标签
kubectl label pods my-pod new-label-                             # 移除标签
kubectl label pods my-pod new-label=new-value --overwrite        # 覆盖现有的值
kubectl annotate pods my-pod icon-url=http://goo.gl/XXBTWq       # 添加注解
kubectl annotate pods my-pod icon-url-                           # 移除注解
kubectl autoscale deployment foo --min=2 --max=10                # 对 "foo" Deployment 自动扩缩容

6.6、部分更新资源

# 部分更新某节点
kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'

# 更新容器的镜像；spec.containers[*].name 是必需的。因为它是一个合并性质的主键。
kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'

# 使用带位置数组的 JSON patch 更新容器的镜像
kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'

# 使用带位置数组的 JSON patch 禁用某 Deployment 的 livenessProbe
kubectl patch deployment valid-deployment  --type json   -p='[{"op": "remove", "path": "/spec/template/spec/containers/0/livenessProbe"}]'

# 在带位置数组中添加元素
kubectl patch sa default --type='json' -p='[{"op": "add", "path": "/secrets/1", "value": {"name": "whatever" } }]'

# 通过修正 scale 子资源来更新 Deployment 的副本数
kubectl patch deployment nginx-deployment --subresource='scale' --type='merge' -p '{"spec":{"replicas":2}}'

6.7、编辑资源

使用你偏爱的编辑器编辑 API 资源。

kubectl edit svc/docker-registry                      # 编辑名为 docker-registry 的服务
KUBE_EDITOR="nano" kubectl edit svc/docker-registry   # 使用其他编辑器

6.8、对资源进行扩缩

kubectl scale --replicas=3 rs/foo                                 # 将名为 'foo' 的副本集扩缩到 3 副本
kubectl scale --replicas=3 -f foo.yaml                            # 将在 "foo.yaml" 中的特定资源扩缩到 3 个副本
kubectl scale --current-replicas=2 --replicas=3 deployment/mysql  # 如果名为 mysql 的 Deployment 的副本当前是 2，那么将它扩缩到 3
kubectl scale --replicas=5 rc/foo rc/bar rc/baz                   # 扩缩多个副本控制器

6.9、删除资源

kubectl delete -f ./pod.json                                              # 删除在 pod.json 中指定的类型和名称的 Pod
kubectl delete pod unwanted --now                                         # 删除 Pod 且无宽限期限（无优雅时段）
kubectl delete pod,service baz foo                                        # 删除名称为 "baz" 和 "foo" 的 Pod 和服务
kubectl delete pods,services -l name=myLabel                              # 删除包含 name=myLabel 标签的 Pod 和服务
kubectl -n my-ns delete pod,svc --all                                     # 删除在 my-ns 名字空间中全部的 Pod 和服务
# 删除所有与 pattern1 或 pattern2 awk 模式匹配的 Pod
kubectl get pods  -n mynamespace --no-headers=true | awk '/pattern1|pattern2/{print $1}' | xargs  kubectl delete -n mynamespace pod

6.10、与运行中的 Pod 进行交互

kubectl logs my-pod                                 # 获取 Pod 日志（标准输出）
kubectl logs -l name=myLabel                        # 获取含 name=myLabel 标签的 Pod 的日志（标准输出）
kubectl logs my-pod --previous                      # 获取上个容器实例的 Pod 日志（标准输出）
kubectl logs my-pod -c my-container                 # 获取 Pod 容器的日志（标准输出, 多容器场景）
kubectl logs -l name=myLabel -c my-container        # 获取含 name=myLabel 标签的 Pod 容器日志（标准输出, 多容器场景）
kubectl logs my-pod -c my-container --previous      # 获取 Pod 中某容器的上个实例的日志（标准输出, 多容器场景）
kubectl logs -f my-pod                              # 流式输出 Pod 的日志（标准输出）
kubectl logs -f my-pod -c my-container              # 流式输出 Pod 容器的日志（标准输出, 多容器场景）
kubectl logs -f -l name=myLabel --all-containers    # 流式输出含 name=myLabel 标签的 Pod 的所有日志（标准输出）
kubectl run -i --tty busybox --image=busybox:1.28 -- sh  # 以交互式 Shell 运行 Pod
kubectl run nginx --image=nginx -n mynamespace      # 在 “mynamespace” 命名空间中运行单个 nginx Pod
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
# 为运行 nginx Pod 生成规约并将其写入到名为 pod.yaml 的文件

kubectl attach my-pod -i                            # 挂接到一个运行的容器中
kubectl port-forward my-pod 5000:6000               # 在本地计算机上侦听端口 5000 并转发到 my-pod 上的端口 6000
kubectl exec my-pod -- ls /                         # 在已有的 Pod 中运行命令（单容器场景）
kubectl exec --stdin --tty my-pod -- /bin/sh        # 使用交互 shell 访问正在运行的 Pod (一个容器场景)
kubectl exec my-pod -c my-container -- ls /         # 在已有的 Pod 中运行命令（多容器场景）
kubectl debug my-pod -it --image=busybox:1.28       # 在现有 Pod 中创建交互式调试会话并立即附加到此 Pod 上
kubectl debug node/my-node -it --image=busybox:1.28 # 在节点上创建交互式调试会话并立即附加到此节点上
kubectl top pod                                     # 显示默认命名空间中所有 Pod 的度量值
kubectl top pod POD_NAME --containers               # 显示给定 Pod 和其中容器的度量值
kubectl top pod POD_NAME --sort-by=cpu              # 显示给定 Pod 的指标并且按照 'cpu' 或者 'memory' 排序

6.11、从容器中复制文件和目录

kubectl cp /tmp/foo_dir my-pod:/tmp/bar_dir            # 将 /tmp/foo_dir 本地目录复制到远程当前命名空间中 Pod 中的 /tmp/bar_dir
kubectl cp /tmp/foo my-pod:/tmp/bar -c my-container    # 将 /tmp/foo 本地文件复制到远程 Pod 中特定容器的 /tmp/bar 下
kubectl cp /tmp/foo my-namespace/my-pod:/tmp/bar       # 将 /tmp/foo 本地文件复制到远程 “my-namespace” 命名空间内指定 Pod 中的 /tmp/bar
kubectl cp my-namespace/my-pod:/tmp/foo /tmp/bar       # 将 /tmp/foo 从远程 Pod 复制到本地 /tmp/bar
# 说明：
# kubectl cp 要求容器镜像中存在 “tar” 二进制文件。如果 “tar” 不存在，kubectl cp 将失败。 对于进阶用例，例如符号链接、通配符扩展或保留文件权限，请考虑使用 kubectl exec。

tar cf - /tmp/foo | kubectl exec -i -n my-namespace my-pod -- tar xf - -C /tmp/bar  # 将 /tmp/foo 本地文件复制到远程 “my-namespace” 命名空间中 Pod 中的 /tmp/bar
kubectl exec -n my-namespace my-pod -- tar cf - /tmp/foo | tar xf - -C /tmp/bar    # 将 /tmp/foo 从远程 Pod 复制到本地 /tmp/bar

6.12、与 Deployments 和 Services 进行交互

kubectl logs deploy/my-deployment                         # 获取一个 Deployment 的 Pod 的日志（单容器例子）
kubectl logs deploy/my-deployment -c my-container         # 获取一个 Deployment 的 Pod 的日志（多容器例子）

kubectl port-forward svc/my-service 5000                  # 侦听本地端口 5000 并转发到 Service 后端端口 5000
kubectl port-forward svc/my-service 5000:my-service-port  # 侦听本地端口 5000 并转发到名字为 <my-service-port> 的 Service 目标端口

kubectl port-forward deploy/my-deployment 5000:6000       # 侦听本地端口 5000 并转发到 <my-deployment> 创建的 Pod 里的端口 6000
kubectl exec deploy/my-deployment -- ls                   # 在 Deployment 里的第一个 Pod 的第一个容器里运行命令（单容器和多容器例子）

6.13、与节点和集群进行交互

kubectl cordon my-node                                                # 标记 my-node 节点为不可调度
kubectl drain my-node                                                 # 对 my-node 节点进行清空操作，为节点维护做准备
kubectl uncordon my-node                                              # 标记 my-node 节点为可以调度
kubectl top node                                                      # 显示所有节点的度量值
kubectl top node my-node                                              # 显示给定节点的度量值
kubectl cluster-info                                                  # 显示主控节点和服务的地址
kubectl cluster-info dump                                             # 将当前集群状态转储到标准输出
kubectl cluster-info dump --output-directory=/path/to/cluster-state   # 将当前集群状态输出到 /path/to/cluster-state

# 查看当前节点上存在的现有污点
kubectl get nodes -o='custom-columns=NodeName:.metadata.name,TaintKey:.spec.taints[*].key,TaintValue:.spec.taints[*].value,TaintEffect:.spec.taints[*].effect'

# 如果已存在具有指定键和效果的污点，则替换其值为指定值
kubectl taint nodes foo dedicated=special-user:NoSchedule

6.14、资源类型

列出所支持的全部资源类型和它们的简称、 API 组、 是否是名字空间作用域和 Kind。

kubectl api-resources

用于探索 API 资源的其他操作：

kubectl api-resources --namespaced=true      # 所有命名空间作用域的资源
kubectl api-resources --namespaced=false     # 所有非命名空间作用域的资源
kubectl api-resources -o name                # 用简单格式列举所有资源（仅显示资源名称）
kubectl api-resources -o wide                # 用扩展格式列举所有资源（又称 "wide" 格式）
kubectl api-resources --verbs=list,get       # 支持 "list" 和 "get" 请求动词的所有资源
kubectl api-resources --api-group=extensions # "extensions" API 组中的所有资源

6.15、格式化输出

要以特定格式将详细信息输出到终端窗口，将 -o（或者 --output）参数添加到支持的 kubectl 命令中。

# 集群中运行着的所有镜像
kubectl get pods -A -o=custom-columns='DATA:spec.containers[*].image'

# 列举 default 名字空间中运行的所有镜像，按 Pod 分组
kubectl get pods --namespace default --output=custom-columns="NAME:.metadata.name,IMAGE:.spec.containers[*].image"

# 除 "registry.k8s.io/coredns:1.6.2" 之外的所有镜像
kubectl get pods -A -o=custom-columns='DATA:spec.containers[?(@.image!="registry.k8s.io/coredns:1.6.2")].image'

# 输出 metadata 下面的所有字段，无论 Pod 名字为何
kubectl get pods -A -o=custom-columns='DATA:metadata.*'

有关更多示例，请参看 kubectl 参考文档。

kubectl 日志输出详细程度和调试
kubectl 日志输出详细程度是通过 -v 或者 --v 来控制的，参数后跟一个数字表示日志的级别。 Kubernetes 通用的日志习惯和相关的日志级别在 这里有相应的描述。

kubectl 快速参考(https://kubernetes.io/zh-cn/docs/reference/kubectl/quick-reference/)