# 一、概念
ConfigMap是Kubernetes中用于存储非敏感配置数据的API对象，它将配置信息与容器镜像解耦，便于应用配置的修改，

# 二、ConfigMap使用

```txt
‌env单个变量注入方式‌
作用：将ConfigMap中的特定键值注入为Pod容器的环境变量
实现过程：
通过valueFrom.configMapKeyRef精确指定要引用的ConfigMap名称和键名
只提取ConfigMap中的特定配置项（如示例中的log_level）
生成独立的环境变量（可自定义变量名与键名不同）
典型场景：需要单独控制的关键配置参数

‌envFrom批量注入方式‌
作用：将整个ConfigMap的所有键值对自动转换为环境变量
实现过程：
通过configMapRef直接引用整个ConfigMap
ConfigMap中的每个键都会成为容器的环境变量（键名作为变量名）
自动包含ConfigMap的所有数据变更
注意事项：需确保键名符合环境变量命名规范（大写字母+下划线）

‌volume挂载方式‌
作用：将ConfigMap内容作为文件挂载到容器文件系统
实现过程：
在volumes段声明使用ConfigMap作为存储卷
通过volumeMounts将卷挂载到容器指定路径
每个键值对会生成独立文件（文件名=键名，内容=值）

核心优势：
支持配置文件的热更新（kubectl update后约1分钟同步）
保持原有文件格式（如nginx.conf的缩进和语法）
可通过subPath挂载单个文件而不影响目录

‌对比总结：
精细控制选env方式
批量导入用envFrom
配置文件场景必须用volume挂载
volume方式唯一支持配置热更新（需应用支持重载）
```

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


```yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  # 键值对配置
  log_level: "DEBUG"
  max_connections: "100"
  
  # 文件内容配置
  nginx.conf: |
    server {
      listen 80;
      server_name localhost;
      location / {
        root /usr/share/nginx/html;
      }
    }
```

```yml
apiVersion: v1
kind: Pod
metadata:
  name: configmap-demo
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    # 方式1：env单个变量注入
    env:
    - name: LOG_LEVEL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: log_level
    
    # 方式2：envFrom批量注入
    envFrom:
    - configMapRef:
        name: app-config
    
    # 方式3：volume挂载配置文件
    volumeMounts:
    - name: config-volume
      mountPath: /etc/nginx/conf.d  # 此目录原有文件将被覆盖
  volumes:
  - name: config-volume
    configMap:
      name: app-config
      items:
      - key: nginx.conf
        path: nginx.conf
```

16.configmap

# 一、概念
PV（Persistent Volume）和PVC（Persistent Volume Claim）是Kubernetes中用于管理存储资源的两个核心概念，它们通过解耦存储资源与应用需求实现灵活管理。以下是两者的核心区别及协作机制：

PV‌
是集群管理员预先配置的‌物理存储资源‌，如NFS、云存储或本地磁盘等，其生命周期独立于Pod存在‌。

‌PVC‌
是用户为应用程序提交的‌存储需求申请‌，通过声明容量、访问模式等参数匹配可用PV‌


![image.png](/static/img/fd5bbe55ec18890585958963b975690d.image.webp)
- 管理员创建PV或定义存储模板（如StorageClass）‌

- 用户提交PVC申请，Kubernetes自动匹配符合条件的PV‌

- 若动态供给已启用，未匹配的PVC可触发自动创建新PV‌


# 二、静态供给
在Kubernetes中，‌静态供给（Static Provisioning）‌是指管理员预先创建并配置好PV（PersistentVolume），然后由用户通过PVC（PersistentVolumeClaim）申请匹配的存储资源。

```yml
# ========== PersistentVolume (PV) 定义 ==========
apiVersion: v1
kind: PersistentVolume
metadata:
  name: static-pv-nfs
spec:
  capacity:
    storage: 1Gi  # PV的总容量
  accessModes:
    - ReadWriteMany  # 支持多节点同时读写
  persistentVolumeReclaimPolicy: Retain  # Pod删除后保留PV和数据
  nfs:
    server: 192.168.201.104  # NFS服务器地址
    path: "/data/nfs_share"  # NFS服务器共享路径
    # 可选参数：readOnly: false  # 默认可读写

---
# ========== PersistentVolumeClaim (PVC) 定义 ==========
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: static-pvc-app  # PVC名称，Pod中会引用此名称
spec:
  accessModes:
    - ReadWriteMany  # 必须与PV的accessModes匹配
  resources:
    requests:
      storage: 1Gi  # 申请1GB存储空间，申请的容量必须和PV一样
  storageClassName: ""  # 显式设置为空字符串以确保使用静态供给

---
# ========== Pod 定义 ==========
apiVersion: v1
kind: Pod
metadata:
  name: nginx-with-pvc  # Pod名称
spec:
  containers:
  - name: nginx
    image: nginx:latest
    volumeMounts:
    - name: nfs-storage  # 必须与volumes.name匹配
      mountPath: "/usr/share/nginx/html"  # 容器内挂载路径
      # 可选参数：readOnly: false  # 默认可读写
  volumes:
  - name: nfs-storage  # 卷名称
    persistentVolumeClaim:
      claimName: static-pvc-app  # 绑定前面定义的PVC
      # 可选参数：readOnly: false  # 默认可读写
```

# 三、动态供给
Kubernetes中PV（PersistentVolume）和PVC（PersistentVolumeClaim）的动态供给是一种自动化存储资源分配机制。

动态供给‌：当用户创建PVC时，系统根据预定义的StorageClass自动创建并绑定匹配的PV，无需管理员手动预置PV。

```yml
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服务器共享数据目录
```


```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
```

```yml
# ==================== 存储类配置 ====================
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"             # 数据保留策略：删除时不清理
```



```yml
# ==================== 命名空间配置 ====================
apiVersion: v1                   # Kubernetes核心API版本标识
kind: Namespace                  # 声明资源类型为命名空间
metadata:                        # 资源元数据开始
  name: ems                      # 定义命名空间名称为ems（Enterprise Management System）
---

# ==================== 有状态应用配置 ====================
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标签键值

```

15.PV和PVC

# 一、卷的类型使用
## 1.emptyDir
emptyDir - 临时空目录，随Pod创建/删除而创建/销毁，用于容器间数据共享

```yml
apiVersion: v1
kind: Pod
metadata:
  name: emptydir-demo     #该类型临时使用，pod删除后数据卷也会被删除
spec:
  containers:
  - name: writer
    image: busybox
    command: ["/bin/sh", "-c"]
    args: ["echo 'Hello from writer' > /cache/data.txt && sleep 3600"]
    volumeMounts:
    - name: cache-volume #名称必须一致
      mountPath: /cache

  - name: reader
    image: busybox
    command: ["/bin/sh", "-c"]
    args: ["cat /cache/data.txt && sleep 3600"] 
    volumeMounts:
    - name: cache-volume  #名称必须一致
      mountPath: /cache

  volumes:
  - name: cache-volume #名称必须一致
    emptyDir: {}
```

```js
创建了一个Pod包含writer和reader两个容器
通过emptyDir卷在/cache目录实现容器间共享
writer容器向/cache/data.txt写入数据
reader容器读取并输出相同文件内容
emptyDir生命周期与Pod绑定，Pod删除后数据丢失
```

```js
#进入reader容器中是否存在
kubectl exec -it  emptydir-demo -c reader -- sh
```
![image.png](/static/img/fd700baa8b4adda52bba6183f484a2c1.image.webp)

## 2.hostPath
hostPath - 将节点本地文件系统挂载到Pod，数据可持久化但仅限于单节点

```yml
apiVersion: v1
kind: Pod
metadata:
  name: hostpath-demo
spec:
  containers:
  - name: hostpath-container
    image: nginx:alpine
    volumeMounts:
    - name: hostpath-volume
      mountPath: /usr/share/nginx/html
  volumes:
  - name: hostpath-volume
    hostPath:
      path: /tmp/hostpath-data
      type: DirectoryOrCreate   #DirectoryOrCreate类型表示如果目录不存在会自动创建
```
将节点上的/tmp/hostpath-data目录挂载到容器的/usr/share/nginx/html

查看pod分配的是节点2，就去节点2的服务器查看
![image.png](/static/img/2206ae3c5500260a1b944e181cd851e8.image.webp)

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

![image.png](/static/img/b17bbfd19fcd205e0b192fca3ad96854.image.webp)
注意：hostPath是根据你/tmp/hostpath-data目录去挂载的，你节点上的/tmp/hostpath-data目录是空，挂载到pod内的文件目录下也会是空，哪怕你pod该目录下有文件一样给你清空，根据节点上的文件目录下文件进行挂载

## 3.NFS

```yml
apiVersion: v1
kind: Pod
metadata:
  name: nfs-direct-pod
spec:
  containers:
  - name: nginx
    image: nginx
    volumeMounts:
    - name: nfs-vol
      mountPath: /usr/share/nginx/html
  volumes:
  - name: nfs-vol
    nfs:
      server: 192.168.201.104
      path: /data/nfs_share
      readOnly: false
```
在全部节点都先创建一个/data/nfs_share目录并授权，NFS服务器上也创建该目录。
然后NFS在/etc/fstab编辑加一行，这样就能同时挂载多个目录（因为之前挂载过一个了）

```js
192.168.201.104:/data/nfs_share  /data/nfs_share  nfs  defaults  0  0
```
然后nfs重新加载生效
```js
sudo exportfs -a                               # 重新加载配置
sudo systemctl restart nfs-server 
```
再全部k8s集群节点重新挂载一个新的

```js
mount -t nfs 192.168.201.104:/data/nfs_share /data/nfs_share
```
然后进入pod容器后去到/usr/share/nginx/html目录下会发现跟我nfs挂载的目录文件一样。

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

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

14.Volumes卷

# 一、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     # 最大重试次数（含首次尝试）
```