# 一、Service概念
在Kubernetes(K8s)中，Service是一种核心资源对象，主要用于将一组Pod抽象为网络服务，提供稳定的访问入口和负载均衡功能

1.其核心作用包括

- ‌服务发现与稳定性‌
- 为动态变化的Pod提供固定IP和DNS名称，即使Pod因扩缩容或故障导致IP变化，客户端仍可通过Service稳定访问
- 通过Label Selector自动关联匹配标签的Pod，实现服务自动发现

‌2.负载均衡‌

- 将请求均匀分发到后端多个Pod副本，提高系统扩展性和可靠性

- 支持轮询、最少连接数等多种调度策略

‌3.故障隔离‌

- 自动检测故障Pod并将其从服务池中剔除，确保请求不被故障节点处理

‌4.网络抽象‌

- 对内：屏蔽Pod细节，客户端只需访问Service的Cluster IP

- 对外：通过Ingress配合可将HTTP/HTTPS流量路由到Service

‌5.服务类型‌

- ClusterIP（默认）：集群内部访问

- NodePort：通过节点端口暴露服务

- LoadBalancer：集成云提供商负载均衡器

- ExternalName：映射外部服务

Service通过kube-proxy组件实现流量转发，支持userspace（用户空间代理）和iptables/IPVS等模式
，是K8s微服务架构的关键组件

# 二、使用Service
## NodePort
```yml
# 定义Kubernetes API版本和资源类型
apiVersion: apps/v1  # 使用apps/v1版本的API
kind: Deployment     # 定义这是一个Deployment资源

# 元数据部分
metadata:
  name: example-app  # Deployment的名称为example-app
  labels:            # 为Deployment添加标签
    name: songxuan01 # 键值对标签，标识这个应用

# Deployment的规格定义
spec:

  replicas: 3  # 指定需要运行的Pod副本数量为3个

  # 选择器，用于匹配要管理的Pod
  selector:
    matchLabels:
      name: songxuan01  # 选择带有name=songxuan01标签的Pod

  # Pod模板，定义如何创建Pod
  template:
    metadata:
      labels:
        name: songxuan01 # 为Pod添加标签，与selector匹配
    spec:
      # 容器定义
      containers:
      - name: nginx       # 容器名称
        image: nginx:1.19 # 使用nginx 1.19版本的镜像
        ports:
        - containerPort: 80  # 容器暴露的端口号

      # 亲和性调度规则
      affinity:
        nodeAffinity:  # 节点亲和性规则
          # 必须满足的条件(硬性要求)
          requiredDuringSchedulingIgnoredDuringExecution:

            nodeSelectorTerms:
            - matchExpressions:
              - key: name  # 节点区域标签
                operator: In  # 操作符，表示值必须在指定列表中
                values:
                - songxuan01  # 必须部署在songxuan01


          # 优先满足的条件(软性偏好)
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 80  # 权重为80(相对权重)
            preference:
              matchExpressions:
              - key: name # 磁盘类型标签
                operator: In
                values:
                - songxuan02  # 优先选择有songxuan02磁盘的节点

---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP      # 协议选择TCP
      port: 80           # Service暴露的端口
      targetPort: 80     # Pod中Nginx容器监听的端口
  type: NodePort         # Service类型为NodePort 通过节点端口暴露服务
```

通过该yml文件配置了service服务，属于该命名空间下的pod都能互相访问

创建一个测试的pod用于测试

```yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: xuan
  labels:
    app: xuan
spec:
  replicas: 1
  selector:
    matchLabels:
      app: xuan
  template:
    metadata:
      name: xuan
      labels:
        app: xuan
    spec:
      containers:
        - name: alpine
          image: alpine:3.18
          command: ["/bin/sh", "-c"]
          args: ["apk add --no-cache curl && while true; do sleep 30; done"]
          imagePullPolicy: IfNotPresent
      restartPolicy: Always

```






当我进入测试pod去访问NGINX做了service的pod是能成功访问的（pod内部访问）

![image.png](/static/img/6bdaef46dd8a197a311af72a368a3b27.image.webp)


![image.png](/static/img/2686e9b4dea06525ae8fa92f1e071c8c.image.webp)


当我用浏览器访问外部暴露端口时也是成功的

访问pod分配的是哪个工作节点的IP（该pod策略分配的是NODE1，IP就是192.168.201.101），外部端口没有固定是随机分配的固定在 30000-32767 之间

![image.png](/static/img/02a79ec69f7661fc5b2ec8b676537bad.image.webp)
![image.png](/static/img/5a37415d43a74597a51051aed5bf5b4f.image.webp)


## 多端口使用

```yml
# 定义Kubernetes API版本和资源类型
apiVersion: apps/v1  # 使用apps/v1版本的API
kind: Deployment     # 定义这是一个Deployment资源

# 元数据部分
metadata:
  name: example-app  # Deployment的名称为example-app
  labels:            # 为Deployment添加标签
    name: songxuan01 # 键值对标签，标识这个应用

# Deployment的规格定义
spec:

  replicas: 3  # 指定需要运行的Pod副本数量为3个

  # 选择器，用于匹配要管理的Pod
  selector:
    matchLabels:
      name: songxuan01  # 选择带有name=songxuan01标签的Pod

  # Pod模板，定义如何创建Pod
  template:
    metadata:
      labels:
        name: songxuan01 # 为Pod添加标签，与selector匹配
    spec:
      # 容器定义
      containers:
      - name: nginx       # 容器名称
        image: nginx:1.19 # 使用nginx 1.19版本的镜像
        ports:
        - containerPort: 80  # 容器暴露的端口号

      # 亲和性调度规则
      affinity:
        nodeAffinity:  # 节点亲和性规则
          # 必须满足的条件(硬性要求)
          requiredDuringSchedulingIgnoredDuringExecution:

            nodeSelectorTerms:
            - matchExpressions:
              - key: name  # 节点区域标签
                operator: In  # 操作符，表示值必须在指定列表中
                values:
                - songxuan01  # 必须部署在songxuan01


          # 优先满足的条件(软性偏好)
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 80  # 权重为80(相对权重)
            preference:
              matchExpressions:
              - key: name # 磁盘类型标签
                operator: In
                values:
                - songxuan02  # 优先选择有songxuan02磁盘的节点

---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP      # 协议选择TCP
      port: 8080           # Service暴露的端口
      targetPort: 80     # Pod中Nginx容器监听的端口
      name: songxuan01
      nodePort: 30001    # 通过节点端口暴露服务
    - protocol: TCP
      port: 8081
      targetPort: 80
      name: songxuan02
      nodePort: 30002
  type: NodePort         # Service类型为NodePort 通过节点端口暴露服务
```

多端口访问指定的30001和30002
![image.png](/static/img/feac2562bdd98b672fb20474be9bf803.image.webp)

## ClusterIP
直接用回之前StatefulSet搭建NFS服务的
```yml
# ==================== 命名空间配置 ====================
apiVersion: v1                   # Kubernetes核心API版本标识
kind: Namespace                  # 声明资源类型为命名空间
metadata:                        # 资源元数据开始
  name: ems                      # 定义命名空间名称为ems（Enterprise Management System）
---
# ==================== 存储类配置 ====================
apiVersion: storage.k8s.io/v1    # 存储类API版本标识
kind: StorageClass               # 声明资源类型为存储类
metadata:                        # 资源元数据开始
  name: mysql-nfs-sc             # 存储类命名（MySQL专用NFS存储类）
  namespace: ems                 # 归属ems命名空间
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner  # 指定NFS子目录动态供应器
parameters:                      # 供应器参数配置开始
  onDelete: "remain"             # 数据保留策略：删除时不清理
---
# ==================== 有状态应用配置 ====================
apiVersion: apps/v1              # 应用API版本标识
kind: StatefulSet                # 声明资源类型为有状态副本集
metadata:                        # 资源元数据开始
  name: mysql                    # StatefulSet名称
  namespace: ems                 # 归属ems命名空间
  labels:                        # 标签集合开始
    app: mysql                   # 应用标识标签
spec:                            # 规格定义开始
  serviceName: mysql-headless    # 关联的无头服务名（用于DNS解析）
  replicas: 1                    # 副本数配置（MySQL单实例部署）

  template:                      # Pod模板定义开始
    metadata:                    # Pod元数据开始
      labels:                    # Pod标签集合开始
        app: mysql               # 应用标识标签（需与selector匹配）
    spec:                        # Pod规格定义开始
      containers:                # 容器定义列表开始
      - name: mysql              # 容器名称标识
        image: mysql/mysql-server:8.0  # 官方MySQL 8.0镜像
        ports:                   # 端口映射列表开始
        - containerPort: 3306    # MySQL服务默认端口
        env:                     # 环境变量列表开始
        - name: MYSQL_ROOT_PASSWORD  # root密码变量名
          value: "root"          # 密码明文值（测试环境使用）
        volumeMounts:            # 存储卷挂载列表开始
        - name: data             # 引用下方PVC模板名称
          mountPath: /var/lib/mysql  # MySQL数据存储路径

  volumeClaimTemplates:          # PVC模板列表开始
  - metadata:                    # PVC元数据开始
      name: data                 # PVC资源名称
    spec:                        # PVC规格定义开始
      accessModes: [ "ReadWriteMany" ]  # 存储访问模式（多节点读写）
      storageClassName: "mysql-nfs-sc"  # 绑定前文定义的存储类
      resources:                 # 资源请求定义开始
        requests:                # 资源请求参数开始
          storage: 2Gi           # 存储空间大小请求值

  selector:                      # Pod选择器定义开始
    matchLabels:                 # 标签匹配规则开始
      app: mysql                 # 需匹配的Pod标签键值

---
# ==================== 无头服务配置 ====================
apiVersion: v1                   # 服务API版本标识
kind: Service                    # 声明资源类型为服务
metadata:                        # 资源元数据开始
  name: mysql-headless          # 无头服务名称
  namespace: ems                 # 归属ems命名空间
spec:                            # 规格定义开始
  ports:                         # 端口映射列表开始
    - port: 3306                 # MySQL服务默认端口
  clusterIP: None                # 无头服务标识（无集群IP）
  selector:                      # Pod选择器定义开始
    app: mysql                   # 需匹配的Pod标签
```

再创建一个属于该命名空间的yml做测试
```yml
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: ems
  name: xuan
  labels:
    app: xuan
spec:
  replicas: 1
  selector:
    matchLabels:
      app: xuan
  template:
    metadata:
      name: xuan
      labels:
        app: xuan
    spec:
      containers:
        - name: alpine
          image: alpine:3.18
          command: ["/bin/sh", "-c"]
          args: ["apk add --no-cache curl busybox-extras && while true; do sleep 30; done"]
          imagePullPolicy: IfNotPresent
      restartPolicy: Always
```
telnet 内部网络Mysql的3306端口，发现数据库拒绝访问，说明端口是能访问到的

![image.png](/static/img/0b32f41c9cdfc53d4c9c525d4b685337.image.webp)

![image.png](/static/img/b7913fa35bbb8edb9d2ecb23b7136f7e.image.webp)

13.Service

# 一、概念
Job控制器主要用于管理一次性任务或批处理任务，确保Pod成功运行并完成任务后终止。

‌1.任务执行保障‌

创建指定数量的Pod并监控其状态，直到任务成功完成（退出码为0）
适用于非持久性任务，如数据处理、压缩文件等一次性操作

‌2.关键特性‌

‌并行控制‌：支持配置并行运行的Pod数量，提高任务效率

‌失败重试‌：自动重启失败的Pod或创建新Pod替代，确保任务最终完成

‌成功计数‌：记录成功完成的Pod数量，达到阈值后标记Job为完成状态

‌自动清理‌：任务完成后自动回收相关资源（如Pod）

‌3.与常规控制器的区别‌

Deployment/ReplicaSet等控制器用于持久运行服务，而Job专注于短期任务

Job不要求Pod持续运行，任务结束即终止


‌4.典型使用场景‌

批处理作业（如日志分析、数据导出）

定时任务的基础单元（与CronJob结合实现周期性任务）

# 二、Jbo使用

```yml
# Kubernetes Job配置示例 - 计算π到2000位小数
apiVersion: batch/v1  # 使用Batch API的v1版本
kind: Job             # 资源类型为Job（一次性任务）
metadata:
  name: pi            # Job名称设置为"pi"
spec:
  template:           # Pod模板定义
    spec:
      containers:
      - name: pi      # 容器名称
        image: perl:5.34.0  # 使用官方Perl镜像
        command: 
          - "perl"
          - "-Mbignum=bpi"   # 加载高精度数学计算模块
          - "-wle"           # 启用警告和自动换行
          - "print bpi(2000)" # 输出π的2000位小数
      restartPolicy: Never  # 失败时不重启容器（Job专用策略）
  backoffLimit: 4     # 最大重试次数（含首次尝试）
```

可以看出运行Job执行完任务结束后，处于一个ContainerCreating状态,并不会删除pod
![image.png](/static/img/e92028ef0aa9c261337533ebf9acb8fe.image.webp)


可以定义ttlSecondsAfterFinished定义执行完任务后多少秒后删除pod
```yml
# Kubernetes Job配置示例 - 计算π到2000位小数
apiVersion: batch/v1  # 使用Batch API的v1版本
kind: Job             # 资源类型为Job（一次性任务）
metadata:
  name: pi            # Job名称设置为"pi"
  
spec:
  ttlSecondsAfterFinished: 10    #定义执行完成任务后10S删除pod
  template:           # Pod模板定义
    spec:
      containers:
      - name: pi      # 容器名称
        image: perl:5.34.0  # 使用官方Perl镜像
        command: 
          - "perl"
          - "-Mbignum=bpi"   # 加载高精度数学计算模块
          - "-wle"           # 启用警告和自动换行
          - "print bpi(2000)" # 输出π的2000位小数
      restartPolicy: Never  # 失败时不重启容器（Job专用策略）
  backoffLimit: 4     # 最大重试次数（含首次尝试）
```

12.Job

# 一、概念
**DaemonSet确保全部（或者某些）节点上运行一个 Pod 的副本。 当有节点加入集群时， 也会为他们新增一个 Pod 。 当有节点从集群移除时，这些 Pod 也会被回收。删除 DaemonSet 将会删除它创建的所有 Pod。

DaemonSet 的一些典型用法：

- 在每个节点上运行集群守护进程
- 在每个节点上运行日志收集守护进程
- 在每个节点上运行监控守护进程

一种简单的用法是为每种类型的守护进程在所有的节点上都启动一个 DaemonSet。 一个稍微复杂的用法是为同一种守护进程部署多个 DaemonSet；每个具有不同的标志， 并且对不同硬件类型具有不同的内存、CPU 要求。**


# 二、DaemonSet使用

```yml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  labels:
    app: nginx
  name: nginx
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.19
        imagePullPolicy: IfNotPresent
        name: nginx
        resources: {}
      restartPolicy: Always
```


```js
kubectl get daemonset
```
我有两个工作节点，就会给两个工作节点都创建一个pod。
![image.png](/static/img/06410cdabe47257745678bb653c72fd7.image.webp)

11.DaemonSet

# 一、概念

**StatefulSet 是用来管理有状态应用的工作负载 API 对象。

无状态应用: 应用本身不存储任何数据的应用称之为无状态应用。

有状态应用: 应用本身需要存储相关数据应用称之为有状态应用。

博客: 前端vue 后端 java mysql redis es ....

数据采集: 采集程序 有状态应用

StatefulSet 用来管理某 Pod 集合的部署和扩缩， 并为这些 Pod 提供持久存储和持久标识符。

和 Deployment 类似， StatefulSet 管理基于相同容器规约的一组 Pod。但和 Deployment 不同的是， StatefulSet 为它们的每个 Pod 维护了一个有粘性的 ID。这些 Pod 是基于相同的规约来创建的， 但是不能相互替换：无论怎么调度，每个 Pod 都有一个永久不变的 ID。

如果希望使用存储卷为工作负载提供持久存储，可以使用 StatefulSet 作为解决方案的一部分。 尽管 StatefulSet 中的单个 Pod 仍可能出现故障， 但持久的 Pod 标识符使得将现有卷与替换已失败 Pod 的新 Pod 相匹配变得更加容易。
**

```js
StatefulSet 对于需要满足以下一个或多个需求的应用程序很有价值：

稳定的、唯一的网络标识符。
稳定的、持久的存储。
有序的、优雅的部署和扩缩。
有序的、自动的滚动更新。
```

**给定 Pod 的存储必须由 PersistentVolume Provisioner 基于所请求的 storage class 来制备，或者由管理员预先制备。

删除或者扩缩 StatefulSet 并不会删除它关联的存储卷。 这样做是为了保证数据安全，它通常比自动清除 StatefulSet 所有相关的资源更有价值。

StatefulSet 当前需要无头服务来负责 Pod 的网络标识。你需要负责创建此服务。

当删除一个 StatefulSet 时，该 StatefulSet 不提供任何终止 Pod 的保证。 为了实现 StatefulSet 中的 Pod 可以有序且体面地终止，可以在删除之前将 StatefulSet 缩容到 0。

在默认 Pod 管理策略(OrderedReady) 时使用滚动更新， 可能进入需要人工干预才能修复的损坏状态。**


# 二、使用StatefulSets的样列
## 1.找一台虚拟机搭建NFS

```sh
#安装nfs-utils
yum install -y rpcbind nfs-utils

#创建nfs目录
mkdir -p /root/nfs/data

#编辑/etc/exports输入如下内容 
# insecure:通过 1024 以上端口发送 rw: 读写 sync:请求时写入共享 no_root_squash:root用户有完全根目录访问权限
echo  "/root/nfs/data *(insecure,rw,sync,no_root_squash)" >> /etc/exports

#启动相关服务并配置开机自启动
systemctl start rpcbind

systemctl start nfs-server

systemctl enable rpcbind

systemctl enable nfs-server

#重新挂载 使 /etc/exports生效
exportfs -r

#查看共享情况
exportfs
```

## 2.K8S集群的机器都安装nfs客户端

```js
# 1.安装客户端 所有节点安装
yum install -y nfs-utils

# 2.创建本地目录
mkdir -p /root/nfs

# 3.挂载远程nfs目录到本地  #前面是nfs服务器挂载的目录  后面是本机挂载的目录
mount -t nfs 192.168.201.104:/root/nfs  /root/nfs

# 4.写入一个测试文件
echo "hello nfs server" > /root/nfs/test.txt

# 5.去远程 nfs 目录查看
cat /root/nfs/test.txt

# 挂取消载
umount -f -l nfs目录
```
## 3.编写yml配置文件
### 部署一个NFS客户端供应器（provisioner），作为Kubernetes与NFS服务器之间的桥梁
```yml
vi nfs-client-provider.yml
```

```js
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-client-provisioner
  labels:
    app: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: kube-system
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nfs-client-provisioner
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner
      containers:
        - name: nfs-client-provisioner
          image: chronolaw/nfs-subdir-external-provisioner:v4.0.2
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: k8s-sigs.io/nfs-subdir-external-provisioner
            - name: NFS_SERVER
              value: 192.168.201.104  #nfs服务器ip地址
            - name: NFS_PATH
              value: /root/nfs/data  #nfs服务器共享数据目录
      volumes:
        - name: nfs-client-root
          nfs:
            server: 192.168.201.104    #nfs服务器ip地址
            path: /root/nfs/data      #nfs服务器共享数据目录
```

### RBAC权限配置
ServiceAccount：创建专用服务账号



ClusterRole：定义供应器需要的集群级权限（节点、PV、PVC等资源的操作权限）



ClusterRoleBinding：将ClusterRole绑定到ServiceAccount



Role/RoleBinding：为leader选举机制配置端点(endpoints)的操作权限
```js
vi rbac.yml
```

```yml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: kube-system
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: nfs-client-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "delete"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["create", "update", "patch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: run-nfs-client-provisioner
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: kube-system
roleRef:
  kind: ClusterRole
  name: nfs-client-provisioner-runner
  apiGroup: rbac.authorization.k8s.io
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: kube-system
rules:
  - apiGroups: [""]
    resources: ["endpoints"]
    verbs: ["get", "list", "watch", "create", "update", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  # replace with namespace where provisioner is deployed
  namespace: kube-system
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    # replace with namespace where provisioner is deployed
    namespace: kube-system
roleRef:
  kind: Role
  name: leader-locking-nfs-client-provisioner
  apiGroup: rbac.authorization.k8s.io
```
### MySQL StatefulSet存储配置

```js
mysql.yml
```

```yml
# ==================== 命名空间配置 ====================
apiVersion: v1                   # Kubernetes核心API版本标识
kind: Namespace                  # 声明资源类型为命名空间
metadata:                        # 资源元数据开始
  name: ems                      # 定义命名空间名称为ems（Enterprise Management System）
---
# ==================== 存储类配置 ====================
apiVersion: storage.k8s.io/v1    # 存储类API版本标识
kind: StorageClass               # 声明资源类型为存储类
metadata:                        # 资源元数据开始
  name: mysql-nfs-sc             # 存储类命名（MySQL专用NFS存储类）
  namespace: ems                 # 归属ems命名空间
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner  # 指定NFS子目录动态供应器
parameters:                      # 供应器参数配置开始
  onDelete: "remain"             # 数据保留策略：删除时不清理
---
# ==================== 有状态应用配置 ====================
apiVersion: apps/v1              # 应用API版本标识
kind: StatefulSet                # 声明资源类型为有状态副本集
metadata:                        # 资源元数据开始
  name: mysql                    # StatefulSet名称
  namespace: ems                 # 归属ems命名空间
  labels:                        # 标签集合开始
    app: mysql                   # 应用标识标签
spec:                            # 规格定义开始
  serviceName: mysql-headless    # 关联的无头服务名（用于DNS解析）
  replicas: 1                    # 副本数配置（MySQL单实例部署）

  template:                      # Pod模板定义开始
    metadata:                    # Pod元数据开始
      labels:                    # Pod标签集合开始
        app: mysql               # 应用标识标签（需与selector匹配）
    spec:                        # Pod规格定义开始
      containers:                # 容器定义列表开始
      - name: mysql              # 容器名称标识
        image: mysql/mysql-server:8.0  # 官方MySQL 8.0镜像
        ports:                   # 端口映射列表开始
        - containerPort: 3306    # MySQL服务默认端口
        env:                     # 环境变量列表开始
        - name: MYSQL_ROOT_PASSWORD  # root密码变量名
          value: "root"          # 密码明文值（测试环境使用）
        volumeMounts:            # 存储卷挂载列表开始
        - name: data             # 引用下方PVC模板名称
          mountPath: /var/lib/mysql  # MySQL数据存储路径

  volumeClaimTemplates:          # PVC模板列表开始
  - metadata:                    # PVC元数据开始
      name: data                 # PVC资源名称
    spec:                        # PVC规格定义开始
      accessModes: [ "ReadWriteMany" ]  # 存储访问模式（多节点读写）
      storageClassName: "mysql-nfs-sc"  # 绑定前文定义的存储类
      resources:                 # 资源请求定义开始
        requests:                # 资源请求参数开始
          storage: 2Gi           # 存储空间大小请求值

  selector:                      # Pod选择器定义开始
    matchLabels:                 # 标签匹配规则开始
      app: mysql                 # 需匹配的Pod标签键值


```
## 4.当运行配置后效果
**然后去NFS服务器查看，是否映射生成了mysql的数据，无论怎么重启或删除都是映射对应的数据文件**
![image.png](/static/img/3426823309a79fde94f00351aed6b0fe.image.webp)

![image.png](/static/img/6fd133f79ced5056d1a45cd93e9b7e24.image.webp)

**我把副本扩容为两个，nfs对应也会生成两个，同时nfs那边也会生成对应pod唯一的数据文件**
```js
kubectl scale sts mysql --replicas=2 -n ems
```

![image.png](/static/img/5c5c01490d4b823878913648bcba8194.image.webp)

![image.png](/static/img/d70ef7ea0a67fd3f9d6718391252d5ac.image.webp)
当我缩容缩成一个时，数据文件也不会被删除
```js
kubectl scale sts mysql --replicas=1 -n ems
```

![image.png](/static/img/70a46071ca53543c362c77c30498b31c.image.webp)


![image.png](/static/img/26887ea8f6fd676225384f82bdcbb4db.image.webp)


## 5.手动删除后StatefulSet的恢复操作
**因为知道StatefulSet在你手动删除后，再重新运行会生成一个新的映射文件和唯一ID，虽然原来的文件在nfs不会被删除但映射的文件已经变更。**


```js
# 我先进入容器的msyql数据库写点数据用于辨认。
kubectl exec -it  mysql-0 -n ems -- bash

# 然后执行登录数据库命令
mysql -u root -proot

# 然后查看全部数据库命令
show databases;

# 然后在创建一个数据库
CREATE DATABASE songxuan;
```
**现在有四个数据库，如果我删除了这个StatefulSet，再重新执行，那他只会有三个，怎么恢复成我原来的呢
**
![image.png](/static/img/a57dae047289090e9c0f56dd75b039b9.image.webp)


删除StatefulSet,再重新执行
```js
kubectl delete -f mysql.yml
kubectl apply -f mysql.yml
```
再看这时这个mysql-0已经重新生成映射的容器了，要如何还原原来的数据呢
![image.png](/static/img/e9af647e6dd00722dbbd6bfeccbe0697.image.webp)
先将现在的进行mv更名加个bak备份，然后把原来的文件名称改成现在新映射的名称。

```js
# 先改名（该操作在NFS服务器操作）
mv ems-data-mysql-0-pvc-7f8adb77-88ca-4cc4-991e-dcf3a4168633 ems-data-mysql-0-pvc-7f8adb77-88ca-4cc4-991e-dcf3a4168633.bak

#然后把新的文件名称改到旧的上面（该操作在NFS服务器操作）
mv archived-ems-data-mysql-0-pvc-12b63880-8bd7-459a-9911-8b6d1716cd29  ems-data-mysql-0-pvc-7f8adb77-88ca-4cc4-991e-dcf3a4168633

#然后需要重启pod，我直接把pod删了
kubectl delete pod mysql-0 -n ems
```
![](http://songxuan.vip/static/img/3704832b8606def6d7f0057cb24d6136.image.webp)


**再次进容器的mysql查看已经成功还原**
![image.png](/static/img/89fb0df672b5a5521c13dc5b979ce473.image.webp)
```js
整体工作流程：
1.StatefulSet创建时自动触发PVC申请
2.StorageClass调用NFS provisioner动态创建PV
3.Provisioner在NFS服务器上创建对应子目录
4.PV绑定到PVC后挂载到MySQL容器
```


10.StatefulSet

# 一、deployemnt基础命令
## 1.查看全部的deployemnt
```js
kubectl get deploy -A
```

![image.png](/static/img/8be3a5759af3b7b26b91264ef75420d1.image.webp)



## 2.查看deployemnt的情况
```js
kubectl describe deploy example-app
```

![image.png](/static/img/7657370441ae963fdac42484bb4a8972.image.webp)

## 3.输出到文件中
```js
kubectl get deploy example-app -o yaml >> test.yaml
```

# 二、deployemnt扩缩容
## 1.该deployemnt有三个副本，我要把他变成10个

![image.png](/static/img/d555314739686833ff75eab8081cedb9.image.webp)

## 2.把deployemnt扩成10个副本，同理缩容只需要改变以下数字即可。
```js
kubectl scale deploy example-app --replicas=10
```

![image.png](/static/img/6ecb409b0e06a677e147e90e0e7dcb46.image.webp)

# 三、deployemnt版本回退控制
## 1.当我更换yml配置文件中的镜像版本时候，查看历史版本命令

![image.png](/static/img/840dadf4aa93394f817ba0f50dfc593a.image.webp)
```js
kubectl rollout history deploy example-app
```
## 2.查看指定历史版本信息更新了什么

![image.png](/static/img/25e71b620caa2fdcf5c9014439b437b3.image.webp)
```js
kubectl rollout history deploy example-app --revision=2
```

## 3.回滚到上个版本

![image.png](/static/img/5500007532641322bcc0008c465d41e7.image.webp)
**当回滚到上个版本后，版本号的1就变成3，因为里面的内容是一样的，只会变更版本号，版本1就没有了。**
```js
kubectl rollout undo deploy example-app
```
## 4.回滚到指定版本

![image.png](/static/img/efa1d7e2ef2d7bbc0f22f9959d6ac171.image.webp)

```js
kubectl rollout undo deploy example-app --to-revision=2
```

## 5.其他很少用到的命令

```js
# 重新部署
kubectl rollout restart deploy example-app
# 暂停运行，暂停后，对 deployment 的修改不会立刻生效，恢复后才应用设置
kubectl rollout pause deploy example-app
# 恢复
kubectl rollout resume deploy example-app
```
# 五、删除deployemnt

```js
# 删除 Deployment
kubectl delete deploy example-app
kubect delete -f k8s06.yml

# 删除默认命名空间下全部资源
kubectl delete all --all

# 删除指定命名空间的资源
kubectl delete all --all -n 命名空间的名称
```
