Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
  • kubernetes

    • Kubernetes 学习笔记
      • 集群搭建

        • 使用 ansible 快速搭建 k8s 集群
        • 常见应用安装配置

          • Harbor 安装配置(k8s)
            • Harbor 高可用搭建(docker-compose)
              • Rancher 安装配置
                • Helm 安装配置
                • 容器运行时

                  • k8s 适配 GPU
                    • Kata2 尝试
                    • 存储

                      • Longorn 安装配置
                        • 使用 Rook 快速搭建 Ceph 集群
                        • 服务发现与路由

                          • ingress-nginx 安装配置
                          • 集群网络

                            • CNI
                              • Calico
                              • 监控告警

                                • Prometheus Operator 安装配置
                                • 实用技巧

                                  • 运维手册

                                    • etcd 备份恢复
                                      • etcd 备份
                                        • etcd 恢复
                                          • 总结
                                          • velero 备份恢复
                                            • k8s 开启审计日志
                                              • 内核版本升级
                                                • 使用 kubeadm 手动更新证书
                                                  • 为 k8s node 配置资源预留
                                                    • 利用LXCFS提升容器资源可见性
                                                    • 最佳实践

                                                      • k8s node 配置资源预留
                                                        • 性能压测指标及方法
                                                          • CPU 绑核
                                                          • 集群排障

                                                            • 如何更新Terminating状态的命名空间
                                                              • 卸载 rancher 导致 node 被清空
                                                                • lvs 健康检查 k8s apiserver
                                                                  • k8s 更改apiserver使用强加密算法
                                                                  • 教程|项目|博客|文章推荐
                                                                    • 附录

                                                                      • 快捷命令

                                                                    etcd 备份恢复

                                                                    author iconClaycalendar icon2022年9月15日category icon
                                                                    • 云原生
                                                                    tag icon
                                                                    • Kubernetes
                                                                    timer icon大约 2 分钟

                                                                    此页内容
                                                                    • etcd 备份
                                                                    • etcd 恢复
                                                                    • 总结

                                                                    # etcd 备份恢复

                                                                    # etcd 备份

                                                                    1. 创建备份脚本/opt/etcd_backup.sh

                                                                      #!/usr/bin/env bash
                                                                      #
                                                                      # Etcd backup
                                                                       
                                                                      set -e
                                                                       
                                                                      ETCD_CA_CERT="/etc/kubernetes/pki/etcd/ca.crt"
                                                                      ETCD_CERT="/etc/kubernetes/pki/etcd/server.crt"
                                                                      ETCD_KEY="/etc/kubernetes/pki/etcd/server.key"
                                                                      BACKUP_DIR="/var/lib/docker/etcd_backup"
                                                                      DT=$(date +%Y%m%d.%H%M%S)
                                                                       
                                                                      [[ ! -d ${BACKUP_DIR} ]] && mkdir -p ${BACKUP_DIR}
                                                                      find ${BACKUP_DIR} -name "*.db" -mtime +7 -exec rm -f {} \;
                                                                       
                                                                      ETCDCTL_API=3 /usr/local/bin/etcdctl --endpoints=https://127.0.0.1:2379 \
                                                                        --cacert="${ETCD_CA_CERT}" --cert="${ETCD_CERT}" --key="${ETCD_KEY}" \
                                                                        snapshot save "${BACKUP_DIR}/etcd-snapshot-${DT}.db"
                                                                       
                                                                      echo "Etcd backup success, backup file: ${BACKUP_DIR}/etcd-snapshot-${DT}.db, \
                                                                        file size: $(du -sh ${BACKUP_DIR}/etcd-snapshot-${DT}.db |awk '{print $1}')"
                                                                      echo
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                      8
                                                                      9
                                                                      10
                                                                      11
                                                                      12
                                                                      13
                                                                      14
                                                                      15
                                                                      16
                                                                      17
                                                                      18
                                                                      19
                                                                      20
                                                                      21
                                                                      22
                                                                    2. 添加cron定时任务 crontab -e

                                                                      0 */1 * * * /bin/bash /opt/etcd_backup.sh >>/opt/log-backup-etcd.log 2>&1
                                                                      
                                                                      1

                                                                    # etcd 恢复

                                                                    1. 创建备份目录

                                                                      mkdir -p /opt/k8s_manifests_backup
                                                                      
                                                                      1
                                                                    2. 停止所有 Master 上 kube-apiserver 服务

                                                                      mv /etc/kubernetes/manifests/kube-apiserver.yaml /opt/k8s_manifests_backup/
                                                                      # 检查服务是否已停止
                                                                      kubectl get pod -n kube-system | grep kube-apiserver
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                    3. 停止集群中所有 etcd 服务

                                                                      # 记录 etcd --name、--initial-advertise-peer-urls、--data-dir 值
                                                                      ps -ef | grep etcd
                                                                      # 停止服务
                                                                      mv /etc/kubernetes/manifests/etcd.yaml /opt/k8s_manifests_backup/
                                                                      # 检查服务是否已停止
                                                                      docker ps | grep etcd
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                    4. 移除所有 etcd 存储目录下数据,不同环境下,存储目录可能不一样,线上存储目录为 /data/etcd

                                                                      mv /data/etcd{,.bak}
                                                                      
                                                                      1
                                                                    5. 拷贝要恢复的快照到所有 etcd 节点,进行快照恢复 所有 etcd 节点操作,不同节点,传入不同的 --name、--initial-advertise-peer-urls、--data-dir值

                                                                      ETCDCTL_API=3 /usr/local/bin/etcdctl snapshot restore /tmp/xxx.db \
                                                                        --name st-kubernetes-master-2 \
                                                                        --initial-cluster "st-kubernetes-master-3=https://10.100.142.165:2380,st-kubernetes-master-1=https://10.100.142.163:2380,st-kubernetes-master-2=https://10.100.142.164:2380" \
                                                                        --initial-cluster-token k8s_etcd \
                                                                        --initial-advertise-peer-urls https://10.100.142.164:2380 \
                                                                        --data-dir=/data/etcd
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                    6. 启动集群中所有 etcd

                                                                      mv /opt/k8s_manifests_backup/etcd.yaml /etc/kubernetes/manifests/
                                                                      # 检查集群状态
                                                                      ETCDCTL_API=3 /usr/local/bin/etcdctl  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
                                                                        --cert=/etc/kubernetes/pki/etcd/server.crt \
                                                                        --key=/etc/kubernetes/pki/etcd/server.key \
                                                                        --endpoints=https://10.100.142.163:2379,https://10.100.142.164:2379,https://10.100.142.165:2379 \
                                                                        endpoint health
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                      4
                                                                      5
                                                                      6
                                                                      7
                                                                    7. 启动所有 Master 上 kube-apiserver 服务

                                                                      mv /opt/k8s_manifests_backup/kube-apiserver.yaml /etc/kubernetes/manifests/
                                                                      # 检查服务状态
                                                                      kubectl get pod -n kube-system | grep kube-apiserver
                                                                      
                                                                      1
                                                                      2
                                                                      3
                                                                    8. 检查是否如期恢复

                                                                    # 总结

                                                                    Kubernetes 集群备份主要是备份etcd集群。而恢复时,主要考虑恢复整个顺序:

                                                                    停止Kube-apiserver–> 停止etcd–> 恢复数据–>启动etcd–>启动kube-apiserver

                                                                    注意:备份etcd集群时,只需要备份一个etcd就行,恢复时,拿同一份备份数据恢复。

                                                                    参考:

                                                                    • Etcd备份数据如何做到完美恢复Kubernetes中误删数据呢open in new window
                                                                    edit icon编辑此页open in new window
                                                                    上次编辑于: 2022/9/15 10:31:37
                                                                    贡献者: clay-wangzhi
                                                                    下一页
                                                                    velero 备份恢复
                                                                    备案号:冀ICP备2021007336号
                                                                    Copyright © 2023 Clay