Simple Blog

1
想象一个小区的物业管理：
2

3
节点（Node） = 每栋楼
4
DaemonSet Pod = 每栋楼的保安（每栋楼必须有且只有一个保安）
5

6
小区新建一栋楼 → 自动分配一个保安
7
拆除一栋楼 → 这栋楼的保安也会撤离

1
没有DaemonSet：
2
┌─────────┐ ┌─────────┐ ┌─────────┐
3
│ Node1   │ │ Node2   │ │ Node3   │
4
│         │ │         │ │         │
5
│ 3个Pod  │ │ 5个Pod  │ │ 2个Pod  │
6
└─────────┘ └─────────┘ └─────────┘
7
     ?          ?          ?
8
  怎么收集日志？要在哪里部署日志收集器？
9

10
有DaemonSet：
11
┌─────────┐ ┌─────────┐ ┌─────────┐
12
│ Node1   │ │ Node2   │ │ Node3   │
13
│ Fluentd │ │ Fluentd │ │ Fluentd │  <- 每个节点都有日志收集器
14
│ 3个Pod  │ │ 5个Pod  │ │ 2个Pod  │     自动收集本节点日志
15
└─────────┘ └─────────┘ └─────────┘

1
需求：监控每个节点的CPU、内存、磁盘
2
解决：在每个节点上运行监控Agent（如node-exporter）

1
需求：每个节点都需要网络组件（如Calico、Flannel）
2
解决：用DaemonSet部署网络插件

1
Deployment：我需要3个副本，调度器帮我分配到合适的节点
2
┌─────────┐ ┌─────────┐ ┌─────────┐
3
│ Node1   │ │ Node2   │ │ Node3   │
4
│ Pod1    │ │ Pod2    │ │         │
5
│         │ │ Pod3    │ │         │
6
└─────────┘ └─────────┘ └─────────┘
7

8
DaemonSet：每个节点必须运行一个副本
9
┌─────────┐ ┌─────────┐ ┌─────────┐
10
│ Node1   │ │ Node2   │ │ Node3   │
11
│ Pod1    │ │ Pod2    │ │ Pod3    │  <- 每个节点都有
12
└─────────┘ └─────────┘ └─────────┘

1
Deployment Pod创建流程：
2
用户 → API Server → Deployment Controller创建ReplicaSet
3
→ ReplicaSet Controller创建Pod（状态：Pending，未分配节点）
4
→ Scheduler选择节点并绑定
5
→ Kubelet创建容器
6

7
DaemonSet Pod创建流程：
8
用户 → API Server → DaemonSet Controller创建Pod
9
→ 直接指定nodeName（绕过Scheduler）
10
→ Kubelet创建容器

1
节点宕机 → Pod状态变为Unknown
2
→ 节点恢复 → DaemonSet Controller检测到
3
→ 重建Pod

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: example-daemonset
5
  namespace: default
6
spec:
7
  selector:
8
    matchLabels:
9
      app: example
10
  template:
11
    metadata:
12
      labels:
13
        app: example
14
    spec:
15
      containers:
16
      - name: example-container
17
        image: busybox
18
        command: ['sh', '-c', 'echo Hello from $(hostname) && sleep 3600']

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: nginx-daemonset
5
spec:
6
  selector:
7
    matchLabels:
8
      app: nginx
9
  template:
10
    metadata:
11
      labels:
12
        app: nginx
13
    spec:
14
      nodeSelector:
15
        disktype: ssd    # 只在有disktype=ssd标签的节点上运行
16
      containers:
17
      - name: nginx
18
        image: nginx:1.20

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: monitoring-daemonset
5
spec:
6
  selector:
7
    matchLabels:
8
      app: monitoring
9
  template:
10
    metadata:
11
      labels:
12
        app: monitoring
13
    spec:
14
      affinity:
15
        nodeAffinity:
16
          requiredDuringSchedulingIgnoredDuringExecution:
17
            nodeSelectorTerms:
18
            - matchExpressions:
19
              - key: kubernetes.io/hostname
20
                operator: In
21
                values:
22
                - k8s-node1
23
                - k8s-node2
24
      containers:
25
      - name: node-exporter
26
        image: prom/node-exporter:latest

1
污点（Taint）= 节点的"拒客牌"
2
容忍（Toleration）= Pod的"通行证"
3

4
想象一个VIP餐厅：
5
- 餐厅门口挂牌："只接待VIP客户"（这是污点）
6
- 你有VIP卡（这是容忍），就能进去

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: fluent-bit
5
  namespace: kube-system
6
spec:
7
  selector:
8
    matchLabels:
9
      app: fluent-bit
10
  template:
11
    metadata:
12
      labels:
13
        app: fluent-bit
14
    spec:
15
      tolerations:
16
      # 容忍master节点污点（允许在master上运行）
17
      - key: node-role.kubernetes.io/master
18
        operator: Exists
19
        effect: NoSchedule
20
      - key: node-role.kubernetes.io/control-plane
21
        operator: Exists
22
        effect: NoSchedule
23
      # 容忍节点未就绪
24
      - key: node.kubernetes.io/not-ready
25
        operator: Exists
26
        effect: NoExecute
27
      # 容忍节点不可达
28
      - key: node.kubernetes.io/unreachable
29
        operator: Exists
30
        effect: NoExecute
31
      containers:
32
      - name: fluent-bit
33
        image: fluent/fluent-bit:latest

1
滚动更新流程：
2
1. 更新DaemonSet的Pod模板
3
2. DaemonSet Controller逐个节点更新Pod
4
   - 删除旧Pod
5
   - 等待旧Pod终止
6
   - 创建新Pod
7
   - 等待新Pod就绪
8
   - 继续下一个节点

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: fluentd
5
spec:
6
  updateStrategy:
7
    type: RollingUpdate
8
    rollingUpdate:
9
      maxUnavailable: 1    # 同时更新的最大节点数（默认1）
10
  selector:
11
    matchLabels:
12
      app: fluentd
13
  template:
14
    metadata:
15
      labels:
16
        app: fluentd
17
    spec:
18
      containers:
19
      - name: fluentd
20
        image: fluent/fluentd:v1.14    # 镜像版本

1
maxUnavailable: 1 （保守更新）
2
┌─────────┐ ┌─────────┐ ┌─────────┐
3
│ Node1   │ │ Node2   │ │ Node3   │
4
│ v1.14 ✓ │ │ v1.13   │ │ v1.13   │  <- 一个一个更新
5
└─────────┘ └─────────┘ └─────────┘
6
     ↓           等待         等待
7
┌─────────┐ ┌─────────┐ ┌─────────┐
8
│ Node1   │ │ Node2   │ │ Node3   │
9
│ v1.14 ✓ │ │ v1.14 ✓ │ │ v1.13   │
10
└─────────┘ └─────────┘ └─────────┘
11

12
maxUnavailable: 2 （激进更新）
13
┌─────────┐ ┌─────────┐ ┌─────────┐
14
│ Node1   │ │ Node2   │ │ Node3   │
15
│ v1.14 ✓ │ │ v1.14 ✓ │ │ v1.13   │  <- 两个同时更新
16
└─────────┘ └─────────┘ └─────────┘

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: critical-monitoring
5
spec:
6
  updateStrategy:
7
    type: OnDelete    # 手动更新模式
8
  selector:
9
    matchLabels:
10
      app: monitoring
11
  template:
12
    metadata:
13
      labels:
14
        app: monitoring
15
    spec:
16
      containers:
17
      - name: monitor
18
        image: monitoring:v2.0

1
Deployment: 我要这个服务一直运行着（长期运行服务）
2
  - Web服务器
3
  - API服务
4
  - 数据库
5

6
DaemonSet: 每个节点都要运行一个服务（节点级长期服务）
7
  - 日志收集
8
  - 监控Agent
9

10
Job: 执行一个任务，完成就结束（一次性任务）
11
  - 数据库备份
12
  - 批量数据处理
13
  - 定时清理任务

1
Deployment = 餐厅的厨师（一直工作）
2
DaemonSet = 每层楼的保洁（每层都有，一直工作）
3
Job = 搬家工人（搬完就走）

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: backup-job
5
spec:
6
  template:
7
    spec:
8
      containers:
9
      - name: backup
10
        image: mysql:8.0
11
        command: ['sh', '-c', 'mysqldump -h mysql -u root -pPassword123 mydb > /backup/mydb.sql']
12
      restartPolicy: Never    # 重要：Job必须设置为Never或OnFailure

1
创建Job → 创建Pod → Pod运行 → 任务完成(退出码0) → Pod状态Completed → Job状态Complete

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: data-process-job
5
spec:
6
  completions: 5    # 需要成功完成5次
7
  template:
8
    spec:
9
      containers:
10
      - name: processor
11
        image: data-processor:latest
12
      restartPolicy: Never

1
创建5个Pod（可能顺序执行）→ 每个Pod完成一个任务 → 5个全部成功 → Job完成

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: parallel-job
5
spec:
6
  completions: 10       # 总共需要完成10个任务
7
  parallelism: 3        # 同时运行3个Pod
8
  template:
9
    spec:
10
      containers:
11
      - name: worker
12
        image: worker:latest
13
      restartPolicy: Never

1
第一批：创建3个Pod同时运行
2
  → Pod1完成 → 创建Pod4
3
  → Pod2完成 → 创建Pod5
4
  → Pod3完成 → 创建Pod6
5
...
6
→ 10个全部完成 → Job完成

1
顺序执行（parallelism=1, completions=3）：
2
时间 →
3
Pod1 [████████]
4
              Pod2 [████████]
5
                            Pod3 [████████]
6

7
并行执行（parallelism=3, completions=3）：
8
时间 →
9
Pod1 [████████]
10
Pod2 [████████]
11
Pod3 [████████]
12

13
混合模式（parallelism=2, completions=5）：
14
时间 →
15
Pod1 [████████]
16
Pod2 [████████]
17
              Pod3 [████████]
18
              Pod4 [████████]
19
                            Pod5 [████████]

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: example-job
5
  namespace: default
6
spec:
7
  # 并行控制
8
  completions: 3              # 需要成功完成的Pod数量（默认1）
9
  parallelism: 2              # 同时运行的最大Pod数量（默认1）
10

11
  # 失败控制
12
  backoffLimit: 6             # 最大失败重试次数（默认6）
13

14
  # 超时控制
15
  activeDeadlineSeconds: 600  # Job运行的最大时间（秒），超时则终止
16

17
  # 清理控制
18
  ttlSecondsAfterFinished: 100  # Job完成后多久自动删除（秒）
19

20
  # Pod模板
21
  template:
22
    spec:
23
      restartPolicy: Never    # 必须是Never或OnFailure
24
      containers:
25
      - name: worker
26
        image: busybox
27
        command: ['sh', '-c', 'echo Processing... && sleep 10 && echo Done!']

1
# Never: Pod失败后不重启，Job Controller创建新Pod
2
restartPolicy: Never
3
# 行为：Pod1失败 → 创建Pod2 → Pod2失败 → 创建Pod3 ...
4

5
# OnFailure: Pod失败后在原地重启容器
6
restartPolicy: OnFailure
7
# 行为：Pod1失败 → 容器重启 → 失败 → 容器再重启 ...

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: retry-job
5
spec:
6
  backoffLimit: 3    # 最多失败3次
7
  template:
8
    spec:
9
      restartPolicy: Never
10
      containers:
11
      - name: worker
12
        image: busybox
13
        command: ['sh', '-c', 'exit 1']  # 故意失败

1
创建Pod1 → 失败（退出码1）
2
→ 创建Pod2 → 失败
3
→ 创建Pod3 → 失败
4
→ 创建Pod4 → 失败
5
→ 达到backoffLimit限制，Job标记为Failed

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: timeout-job
5
spec:
6
  activeDeadlineSeconds: 30  # 30秒超时
7
  template:
8
    spec:
9
      restartPolicy: Never
10
      containers:
11
      - name: worker
12
        image: busybox
13
        command: ['sh', '-c', 'sleep 60']  # 睡眠60秒

1
创建Pod → 运行30秒 → 超时 → Job终止Pod → Job状态Failed

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: auto-cleanup-job
5
spec:
6
  ttlSecondsAfterFinished: 100  # 完成后100秒自动删除
7
  template:
8
    spec:
9
      restartPolicy: Never
10
      containers:
11
      - name: worker
12
        image: busybox
13
        command: ['sh', '-c', 'echo Done && sleep 10']

1
Job = 临时工（干完活就走）
2
CronJob = 定时闹钟（每天早上7点叫你起床）
3

4
示例：
5
- 每天凌晨2点备份数据库
6
- 每小时清理临时文件
7
- 每周一生成报表

1
分钟  小时  日期  月份  星期
2
*    *    *    *    *

1
apiVersion: batch/v1
2
kind: CronJob
3
metadata:
4
  name: hello-cronjob
5
spec:
6
  schedule: "*/1 * * * *"    # 每分钟执行一次
7
  jobTemplate:
8
    spec:
9
      template:
10
        spec:
11
          restartPolicy: Never
12
          containers:
13
          - name: hello
14
            image: busybox
15
            command: ['sh', '-c', 'date; echo Hello from CronJob']

1
apiVersion: batch/v1
2
kind: CronJob
3
metadata:
4
  name: backup-cronjob
5
  namespace: default
6
spec:
7
  # Cron表达式
8
  schedule: "0 2 * * *"              # 每天凌晨2点
9

10
  # 时区（Kubernetes 1.25+）
11
  timeZone: "Asia/Shanghai"          # 使用中国时区
12

13
  # 并发策略
14
  concurrencyPolicy: Forbid          # Allow/Forbid/Replace
15

16
  # Job历史保留
17
  successfulJobsHistoryLimit: 3      # 保留3个成功的Job
18
  failedJobsHistoryLimit: 1          # 保留1个失败的Job
19

20
  # 启动延迟
21
  startingDeadlineSeconds: 100       # 如果错过调度时间，100秒内还可以启动
22

23
  # 暂停调度
24
  suspend: false                     # true表示暂停，不创建新Job
25

26
  # Job模板（与Job的spec相同）
27
  jobTemplate:
28
    spec:
29
      template:
30
        spec:
31
          restartPolicy: Never
32
          containers:
33
          - name: backup
34
            image: mysql:8.0
35
            command: ['sh', '-c', 'mysqldump -h mysql -u root -p$MYSQL_PWD mydb > /backup/backup-$(date +%Y%m%d-%H%M%S).sql']
36
            env:
37
            - name: MYSQL_PWD
38
              valueFrom:
39
                secretKeyRef:
40
                  name: mysql-secret
41
                  key: password

1
spec:
2
  schedule: "*/1 * * * *"
3
  concurrencyPolicy: Allow    # 允许多个Job同时运行

1
时间线：
2
0:00 → Job1创建，运行中
3
0:01 → Job2创建，运行中（Job1还没完成）
4
0:02 → Job3创建，运行中（Job1、Job2都还没完成）
5

6
结果：3个Job同时运行

1
spec:
2
  schedule: "*/1 * * * *"
3
  concurrencyPolicy: Forbid   # 如果上一个Job还在运行，跳过本次调度

1
时间线：
2
0:00 → Job1创建，运行中
3
0:01 → 检查：Job1还在运行 → 跳过，不创建Job2
4
0:02 → 检查：Job1还在运行 → 跳过，不创建Job3
5
0:03 → Job1完成
6
0:04 → Job2创建，运行中
7

8
结果：同一时间只有1个Job运行

1
spec:
2
  schedule: "*/1 * * * *"
3
  concurrencyPolicy: Replace  # 终止旧Job，创建新Job

1
时间线：
2
0:00 → Job1创建，运行中
3
0:01 → 检查：Job1还在运行 → 终止Job1 → 创建Job2
4
0:02 → 检查：Job2还在运行 → 终止Job2 → 创建Job3
5

6
结果：旧Job被新Job替换

1
apiVersion: v1
2
kind: ConfigMap
3
metadata:
4
  name: fluentd-config
5
  namespace: kube-system
6
data:
7
  fluent.conf: |
8
    # 输入源：读取容器日志
9
    <source>
10
      @type tail                           # 使用tail插件（类似tail -f命令）
11
      path /var/log/containers/*.log       # 监控所有容器日志
12
      pos_file /var/log/fluentd-containers.log.pos  # 记录读取位置（避免重复）
13
      tag kubernetes.*                     # 日志标签
14
      read_from_head true                  # 从头开始读取
15
      <parse>
16
        @type json                         # 解析JSON格式日志
17
        time_key time
18
        time_format %Y-%m-%dT%H:%M:%S.%NZ
19
        keep_time_key true
20
      </parse>
21
    </source>
22

23
    # 过滤器：添加Kubernetes元数据
24
    <filter kubernetes.**>
25
      @type kubernetes_metadata            # 添加Pod名称、命名空间等信息
26
    </filter>
27

28
    # 输出：打印到stdout（测试用）
29
    <match **>
30
      @type stdout                         # 输出到标准输出
31
    </match>

1
apiVersion: apps/v1
2
kind: DaemonSet
3
metadata:
4
  name: fluentd
5
  namespace: kube-system
6
  labels:
7
    app: fluentd
8
spec:
9
  selector:
10
    matchLabels:
11
      app: fluentd
12
  template:
13
    metadata:
14
      labels:
15
        app: fluentd
16
    spec:
17
      # 服务账号（需要权限读取Pod元数据）
18
      serviceAccountName: fluentd
19

20
      # 容忍master节点污点（在所有节点运行）
21
      tolerations:
22
      - key: node-role.kubernetes.io/master
23
        operator: Exists
24
        effect: NoSchedule
25
      - key: node-role.kubernetes.io/control-plane
26
        operator: Exists
27
        effect: NoSchedule
28

29
      containers:
30
      - name: fluentd
31
        image: fluent/fluentd-kubernetes-daemonset:v1-debian-elasticsearch
32
        env:
33
        # 禁用Elasticsearch输出（我们只用stdout测试）
34
        - name: FLUENT_ELASTICSEARCH_HOST
35
          value: "localhost"
36
        resources:
37
          limits:
38
            memory: 200Mi
39
          requests:
40
            cpu: 100m
41
            memory: 200Mi
42
        volumeMounts:
43
        # 挂载配置文件
44
        - name: config
45
          mountPath: /fluentd/etc/fluent.conf
46
          subPath: fluent.conf
47
        # 挂载容器日志目录
48
        - name: varlog
49
          mountPath: /var/log
50
          readOnly: true
51
        # 挂载容器运行时目录
52
        - name: varlibdockercontainers
53
          mountPath: /var/lib/docker/containers
54
          readOnly: true
55

56
      volumes:
57
      - name: config
58
        configMap:
59
          name: fluentd-config
60
      - name: varlog
61
        hostPath:
62
          path: /var/log
63
      - name: varlibdockercontainers
64
        hostPath:
65
          path: /var/lib/docker/containers

1
---
2
apiVersion: v1
3
kind: ServiceAccount
4
metadata:
5
  name: fluentd
6
  namespace: kube-system
7
---
8
apiVersion: rbac.authorization.k8s.io/v1
9
kind: ClusterRole
10
metadata:
11
  name: fluentd
12
rules:
13
- apiGroups: [""]
14
  resources:
15
  - pods
16
  - namespaces
17
  verbs:
18
  - get
19
  - list
20
  - watch
21
---
22
apiVersion: rbac.authorization.k8s.io/v1
23
kind: ClusterRoleBinding
24
metadata:
25
  name: fluentd
26
roleRef:
27
  apiGroup: rbac.authorization.k8s.io
28
  kind: ClusterRole
29
  name: fluentd
30
subjects:
31
- kind: ServiceAccount
32
  name: fluentd
33
  namespace: kube-system

1
cat > process.sh << 'EOF'
2
#!/bin/sh
3
TASK_ID=${TASK_ID:-"unknown"}
4
echo "=== Task $TASK_ID Started at $(date) ==="
5
SLEEP_TIME=$((5 + RANDOM % 10))
6
echo "Processing for $SLEEP_TIME seconds..."
7
sleep $SLEEP_TIME
8
echo "=== Task $TASK_ID Completed at $(date) ==="
9
exit 0
10
EOF
11
chmod +x process.sh

1
FROM alpine:3.18
2
COPY process.sh /usr/local/bin/
3
CMD ["/usr/local/bin/process.sh"]

1
apiVersion: batch/v1
2
kind: Job
3
metadata:
4
  name: parallel-image-job
5
spec:
6
  completions: 10
7
  parallelism: 3
8
  backoffLimit: 20
9
  ttlSecondsAfterFinished: 300
10
  template:
11
    spec:
12
      restartPolicy: Never
13
      containers:
14
      - name: processor
15
        image: reg.westos.org/library/image-processor:v1
16
        env:
17
        - name: TASK_ID
18
          valueFrom:
19
            fieldRef:
20
              fieldPath: metadata.name

1
cat > backup.sh << 'EOF'
2
#!/bin/sh
3
set -e
4
BACKUP_DIR="/backup"
5
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
6
BACKUP_FILE="${BACKUP_DIR}/etcd-snapshot-${TIMESTAMP}.db"
7
echo "=== Backing up etcd at $(date) ==="
8
mkdir -p ${BACKUP_DIR}
9
ETCDCTL_API=3 etcdctl snapshot save ${BACKUP_FILE} \
10
  --endpoints=${ETCD_ENDPOINTS} \
11
  --cacert=${ETCD_CACERT} \
12
  --cert=${ETCD_CERT} \
13
  --key=${ETCD_KEY}
14
ETCDCTL_API=3 etcdctl snapshot status ${BACKUP_FILE} -w table
15
ls -lh ${BACKUP_FILE}
16
find ${BACKUP_DIR} -name "etcd-snapshot-*.db" -mtime +7 -delete
17
echo "=== Backup completed at $(date) ==="
18
EOF
19
chmod +x backup.sh

1
FROM alpine:3.18
2
RUN apk add --no-cache curl && \
3
    ETCD_VER=v3.5.9 && \
4
    curl -L https://github.com/etcd-io/etcd/releases/download/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd.tar.gz && \
5
    tar xzvf /tmp/etcd.tar.gz -C /tmp && \
6
    mv /tmp/etcd-${ETCD_VER}-linux-amd64/etcdctl /usr/local/bin/ && \
7
    rm -rf /tmp/etcd*
8
COPY backup.sh /usr/local/bin/
9
ENTRYPOINT ["/usr/local/bin/backup.sh"]

1
apiVersion: batch/v1
2
kind: CronJob
3
metadata:
4
  name: etcd-backup
5
  namespace: kube-system
6
spec:
7
  schedule: "0 2 * * *"
8
  concurrencyPolicy: Forbid
9
  successfulJobsHistoryLimit: 3
10
  failedJobsHistoryLimit: 1
11
  jobTemplate:
12
    spec:
13
      template:
14
        spec:
15
          restartPolicy: OnFailure
16
          nodeSelector:
17
            node-role.kubernetes.io/control-plane: ""
18
          tolerations:
19
          - key: node-role.kubernetes.io/control-plane
20
            operator: Exists
21
            effect: NoSchedule
22
          containers:
23
          - name: etcd-backup
24
            image: reg.westos.org/library/etcd-backup:v1
25
            env:
26
            - name: ETCD_ENDPOINTS
27
              value: "https://192.168.100.20:2379"
28
            - name: ETCD_CACERT
29
              value: "/etc/kubernetes/pki/etcd/ca.crt"
30
            - name: ETCD_CERT
31
              value: "/etc/kubernetes/pki/etcd/server.crt"
32
            - name: ETCD_KEY
33
              value: "/etc/kubernetes/pki/etcd/server.key"
34
            volumeMounts:
35
            - name: etcd-certs
36
              mountPath: /etc/kubernetes/pki/etcd
37
              readOnly: true
38
            - name: backup-dir
39
              mountPath: /backup
40
          volumes:
41
          - name: etcd-certs
42
            hostPath:
43
              path: /etc/kubernetes/pki/etcd
44
          - name: backup-dir
45
            hostPath:
46
              path: /data/etcd-backup