Artikelverzeichnis
-
- @[toc]
- 1. Überblick über etcd
- 2. Installieren Sie das etcdctl-Tool
- Drittens: Bereitstellung im Kubeadm-Bereitstellungsmodus
-
- Fünftens: Sicherung der binären Bereitstellung
-
- 6. Velero installieren
-
- 7. Stellen Sie die Testanwendung bereit
-
- Acht, Testsicherung
-
- 8. Erholung
- 9. Cluster-Datenmigration
- 10. Referenzadresse
Artikelverzeichnis
-
- @[toc]
- 1. Überblick über etcd
- 2. Installieren Sie das etcdctl-Tool
- Drittens: Bereitstellung im Kubeadm-Bereitstellungsmodus
- Fünftens: Sicherung der binären Bereitstellung
- 6. Velero installieren
- 7. Stellen Sie die Testanwendung bereit
- Acht, Testsicherung
- 8. Erholung
- 9. Cluster-Datenmigration
- 10. Referenzadresse
1. Überblick über etcd
etcd ist ein Open-Source-Projekt, das im Juni 2013 vom CoreOS-Team initiiert wurde. Ziel ist der Aufbau einer hochverfügbaren verteilten Schlüsselwertdatenbank.
- etcd übernimmt intern das Raft-Protokoll als Konsensalgorithmus und etcd wird basierend auf der Go-Sprache implementiert.
- Vollständige Replikation: Jeder Knoten im Cluster kann das komplette Archiv nutzen
- Hohe Verfügbarkeit: Etcd kann verwendet werden, um Single Points of Failure bei Hardware- oder Netzwerkproblemen zu vermeiden
- Konsistenz: Jeder Lesevorgang gibt den letzten Schreibvorgang über mehrere Master hinweg zurück
- Einfach: Enthält eine klar definierte, benutzerorientierte API (gRPC)
- Sicherheit: Automatisiertes TLS mit optionaler Client-Zertifikatauthentifizierung implementiert
- Schnell: Benchmark-Geschwindigkeit von 10.000 Schreibvorgängen pro Sekunde
- Zuverlässig: Verwendung des Raft-Algorithmus, um ein stark konsistentes, hochverfügbares Dienstspeicherverzeichnis zu erreichen
Grundkenntnisse im Zusammenhang mit dem Betrieb und der Wartung von ETCD-Clustern:
- Der Lese- und Schreibport ist: 2379, Datensynchronisationsport: 2380
- Der ETCD-Cluster ist ein verteiltes System, das das Raft-Protokoll verwendet, um die Konsistenz des Zustands jedes Knotens im Cluster aufrechtzuerhalten.
- Gastgeberstatus: Leader, Follower, Kandidat
- Wenn der Cluster initialisiert wird, übernimmt jeder Knoten die Rolle eines Followers, der Daten über Heartbeats mit anderen Knoten synchronisiert.
- Lesen Sie Daten über Follower und schreiben Sie Daten über Leader
- Wenn ein Follower innerhalb eines bestimmten Zeitraums keinen Heartbeat vom Master-Knoten erhält, ändert er seine Rolle in einen Kandidaten und initiiert eine Master-Wahlabstimmung.
- Um einen etcd-Cluster zu konfigurieren, wird empfohlen, möglichst eine ungerade Anzahl von Knoten anstelle einer geraden Anzahl von Knoten zu haben. Die empfohlene Anzahl beträgt 3, 5 oder 7 Knoten, um einen Cluster zu bilden.
- Verwenden Sie die integrierten Sicherungs-/Wiederherstellungstools von etcd, um Daten aus Quellbereitstellungen zu sichern und Daten in neuen Bereitstellungen wiederherzustellen. Das Datenverzeichnis muss vor der Wiederherstellung bereinigt werden
- Snap im Datenverzeichnis: Speichern Sie Snapshot-Daten, von etcd festgelegte Snapshots, um zu viele WAL-Dateien zu verhindern, und speichern Sie den Status der etcd-Daten.
- Unter dem Datenverzeichniswal: Speichern Sie das vorab geschriebene Protokoll. Die größte Funktion besteht darin, den gesamten Verlauf der gesamten Datenänderung aufzuzeichnen. In etcd müssen alle Datenänderungen vor der Übermittlung in die WAL geschrieben werden.
- Ein etcd-Cluster sollte wahrscheinlich nicht mehr als sieben Knoten haben, da die Schreibleistung darunter leidet. Es wird empfohlen, fünf Knoten auszuführen. Ein 5-köpfiger etcd-Cluster kann den Ausfall von zwei Mitgliedern tolerieren, und drei Mitglieder können einen Ausfall tolerieren.
Allgemeine Konfigurationsparameter:
- ETCD_NAME Knotenname, Standard ist Standard
- ETCD_DATA_DIR Der Pfad, in dem die Dienstlaufdaten gespeichert werden
- ETCD_LISTEN_PEER_URLS Die Adresse der zu überwachenden Peer-Kommunikation, z. B. http://ip:2380. Wenn es mehr als eine gibt, verwenden Sie Kommas, um sie zu trennen. Auf alle Knoten muss zugegriffen werden können. Verwenden Sie daher nicht „localhost“.
- ETCD_LISTEN_CLIENT_URLS Zu überwachende Client-Service-Adresse
- ETCD_ADVERTISE_CLIENT_URLS Die Listener-Adresse des Clients des Knotens, der extern bekannt gegeben wird. Dieser Wert wird anderen Knoten im Cluster mitgeteilt
- ETCD_INITIAL_ADVERTISE_PEER_URLS Die extern bekannt gegebene Listener-Adresse des Peers des Knotens. Dieser Wert wird anderen Knoten im Cluster mitgeteilt
- ETCD_INITIAL_CLUSTER Informationen aller Knoten im Cluster
- ETCD_INITIAL_CLUSTER_STATE Beim Erstellen eines neuen Clusters lautet dieser Wert „new“; wenn Sie einem vorhandenen Cluster beitreten, lautet dieser Wert „existing“.
- ETCD_INITIAL_CLUSTER_TOKEN Die ID des Clusters. Wenn mehrere Cluster vorhanden sind, muss die ID jedes Clusters eindeutig bleiben
2. Installieren Sie das etcdctl-Tool
【Offizielle Website】https://github.com/etcd-io/etcd/releases
#查看版本号
cat /etc/kubernetes/manifests/etcd.yaml |grep image
#输入版本号：v3.5.4
$ install_etcdctl.sh
#!/bin/bash
read -p "输入·etcd的版本号": VERSION
ETCD_VER=$VERSION
ETCD_DIR=etcd-download
DOWNLOAD_URL=https://ghproxy.com/github.com/coreos/etcd/releases/download
# 下载
cd /usr/local
mkdir ${ETCD_DIR}
cd ${ETCD_DIR}
rm -rf *
wget ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz
tar -xzvf etcd-${ETCD_VER}-linux-amd64.tar.gz
# 安装etcdctl
cd etcd-${ETCD_VER}-linux-amd64
#重命名，便于识别
cp etcdctl /usr/local/bin/
#删除安装数据目录
cd /usr/local&& rm -rf ${ETCD_DIR}
#添加环境变量
echo "ETCDCTL_API=3" >>/etc/profile
#查看版本
etcdctl version
chmod o+x install_etcdctl.sh
sh install_etcdctl.sh
输入：v3.5.4
Drittens: Bereitstellung im Kubeadm-Bereitstellungsmodus
Grundverständnis:
- K8s verwendet die etcd-Datenbank, um Daten in Echtzeit im Cluster zu speichern. Aus Sicherheitsgründen müssen diese gesichert werden!
- Die Sicherung muss nur auf einem Knoten gesichert werden (um Schäden am Sicherungsknoten zu vermeiden, wird empfohlen, zwei Knoten zu sichern), die Daten auf jedem Knoten werden synchronisiert; die Datenwiederherstellung muss jedoch auf jedem Knoten durchgeführt werden .
- Der ectd-Container wird im Netzwerk mit dem Host-Computer geteilt. Mit der hostNetwork-Methode kann der 2379-Datenport auf dem Host-Computer angezeigt werden ( ss -ntlp|grep 2379).
[root@k8s-master-01 etcd_backup]# ss -ntlp|grep 2379
LISTEN 0 128 192.168.4.114:2379 *:* users:(("etcd",pid=1841,fd=9))
LISTEN 0 128 127.0.0.1:2379 *:* users:(("etcd",pid=1841,fd=8))
- In dem von kubeadm bereitgestellten Cluster wird etcd vom statischen Pod bereitgestellt und gestartet. Im Verzeichnis /etc/kubernetes/manifests befindet sich seine Yaml-Datei, in der das Startbild, die Version, der Zertifikatpfad, das Datenverzeichnis usw. aufgezeichnet werden.
[root@k8s-master-01 ~]# cat /etc/kubernetes/manifests/etcd.yaml |grep -A 10 volumes:
volumes:
- hostPath:
path: /etc/kubernetes/pki/etcd
type: DirectoryOrCreate
name: etcd-certs
- hostPath:
path: /data/k8s/etcd
type: DirectoryOrCreate
name: etcd-data
status: {}
Achten Sie darauf, ob das etcd-Datenverzeichnis ersetzt wird. Der Standardwert ist /var/lib/etcd/, wobei das etcd-Datenverzeichnis /data/k8s/etcd ist. Andernfalls kann der Cluster nicht wiederhergestellt werden.
1) Sicherung
- Am besten sichern Sie zwei Knoten, um zu vermeiden, dass nur der Backup-Computer ausfällt
#创建命名空间
kubectl create ns test
#部署
cat > nginx-deployment.yaml<<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
namespace: test
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: nginx-service
namespace: test
spec:
selector:
app: nginx
ports:
- protocol: TCP
port: 80
targetPort: 80
type: NodePort
EOF
#部署
kubectl apply -f nginx-deployment.yaml
#创建备份目录
mkdir -p /data/etcd_backup
cd /data/etcd_backup
#备份
ETCDCTL_API=3 etcdctl \
snapshot save snap.db_$(date +%F) \
--endpoints=https://192.168.4.114:2379 \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key
#检查
[root@k8s-master-01 etcd_backup]# ETCDCTL_API=3 etcdctl --write-out=table snapshot status /opt/etcd_backup/snap.db_2023-08-24
Deprecated: Use `etcdutl snapshot status` instead.
+----------+----------+------------+------------+
| HASH | REVISION | TOTAL KEYS | TOTAL SIZE |
+----------+----------+------------+------------+
| 4c5447a8 | 2333766 | 1308 | 6.9 MB |
+----------+----------+------------+------------+
#集群节点状态
[root@k8s-master-01 etcd_backup]# ETCDCTL_API=3 etcdctl --endpoints https://127.0.0.1:2379 --cert="/etc/kubernetes/pki/etcd/server.crt" --key="/etc/kubernetes/pki/etcd/server.key" --cacert="/etc/kubernetes/pki/etcd/ca.crt" member list -w table
+------------------+---------+---------------+----------------------------+----------------------------+------------+
| ID | STATUS | NAME | PEER ADDRS | CLIENT ADDRS | IS LEARNER |
+------------------+---------+---------------+----------------------------+----------------------------+------------+
| c3509e57d5f53562 | started | k8s-master-01 | https://192.168.4.114:2380 | https://192.168.4.114:2379 | false |
+------------------+---------+---------------+----------------------------+----------------------------+------------+
#任意节点查看 etcd 集群信息
[root@k8s-master-01 etcd_backup]# ETCDCTL_API=3 etcdctl --endpoints https://127.0.0.1:2379 --cert="/etc/kubernetes/pki/etcd/server.crt" --key="/etc/kubernetes/pki/etcd/server.key" --cacert="/etc/kubernetes/pki/etcd/ca.crt" endpoint status --cluster -w table
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| ENDPOINT | ID | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://192.168.4.114:2379 | c3509e57d5f53562 | 3.5.4 | 6.9 MB | true | false | 10 | 2649811 | 2649811 | |
+----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
- Vor der Bereitstellung gibt es Nginx. Löschen Sie Nginx, stellen Sie etcd wieder her, um die Existenz von Nginx zu bestätigen.
[root@k8s-master-01 etcd_backup]# kubectl get pods -n test
NAME READY STATUS RESTARTS AGE
nginx-deployment-ff6774dc6-7mm2j 1/1 Running 0 11s
nginx-deployment-ff6774dc6-hdvbf 1/1 Running 0 11s
nginx-deployment-ff6774dc6-zcf8m 1/1 Running 0 11s
[root@k8s-master-01 ~]#kubectl delete -f nginx-deployment.yaml
[root@k8s-master-01 etcd_backup]# kubectl get pods -n test
2) Erholung
kubeadm
- Der etcd im von kubeadm bereitgestellten Cluster wird als statischer Container ausgeführt, und das Speicherverzeichnis der Konfigurationsdatei des statischen Containers ist /etc/kubernetes/manifests/.
- Der Kernprozess ist: API-Server- und etcd-Dienste stoppen -> Wiederherstellung ausführen -> API-Server- und etcd-Dienste neu starten
#先停止api server和etcd服务。因为是静态Pod部署，监控这个目录下的yaml文件，当把目录备份后就直接相当于停服
mkdir -p /tmp/etcd/manifests/
mv /etc/kubernetes/manifests/{kube-apiserver.yaml,etcd.yaml} /tmp/etcd/manifests/
mv /data/k8s/etcd /data/k8s/etcd.`date +%Y%m%d`
#查看api-server是否停止
[root@k8s-master-01 ~]# kubectl get pod
The connection to the server 192.168.4.114:6443 was refused - did you specify the right host or port?
#使用snap.db文件恢复数据到/var/lib/etcd目录。
ETCDCTL_API=3 etcdctl snapshot restore snap.db_2023-08-24 --endpoints=https://192.168.4.114:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key --data-dir=/data/k8s/etcd
#启动kube-apiserver和etcd容器
mv /tmp/etcd/manifests/{kube-apiserver.yaml,etcd.yaml} /etc/kubernetes/manifests/
#查看结果，数据恢复
[root@k8s-master-01 etcd_backup]# kubectl get pods -n test
NAME READY STATUS RESTARTS AGE
nginx-deployment-ff6774dc6-ch9p2 1/1 Running 0 2m3s
nginx-deployment-ff6774dc6-cklzj 1/1 Running 0 2m3s
nginx-deployment-ff6774dc6-fb6wb 1/1 Running 0 2m3s
#检查集群是否正常
[root@k8s-master-01 etcd_backup]# kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
controller-manager Healthy ok
etcd-0 Healthy {"health":"true","reason":""}
4. Timing-Sicherung
- Am besten sichern Sie zwei Knoten, um zu vermeiden, dass nur der Backup-Computer ausfällt
#创建etcd脚本存放目录
mkdir -p /opt/etcd_backup
#创建etcd数据备份目录
mkdir -p /data/etcd_backup
#创建定时备份脚本
[root@master etcd]# cat /opt/etcd_backup/etcd_backup.sh
#!/bin/bash
CACERT="/etc/kubernetes/pki/etcd/ca.crt "
CERT="/etc/kubernetes/pki/etcd/server.crt"
EKY="/etc/kubernetes/pki/etcd/server.key"
ENDPOINTS="192.168.4.114:2379"
ETCDCTL_API=3 etcdctl \
--cacert="${CACERT}" \
--cert="${CERT}" \
--key="${EKY}" \
--endpoints=${ENDPOINTS} \
snapshot save /data/etcd_backup/etcd-snapshot-`date +%Y-%m-%d_%H:%M:%S`.db
# 备份保留30天
find /data/etcd_backup/ -name *.db -mtime +30 -exec rm -f {} \;
#设置定时任务
crontab -e
#每天凌晨2点执行
0 2 * * * sh /opt/etcd_backup/etcd_backup.sh
#停止apisever和etcd
mkdir -p /tmp/etcd/manifests/
mv /etc/kubernetes/manifests/{kube-apiserver.yaml,etcd.yaml} /tmp/etcd/manifests/
mv /data/k8s/etcd /data/k8s/etcd.`date +%Y-%m-%d_%H:%M:%S`
#恢复命令
ETCDCTL_API=3 etcdctl snapshot restore /data/etcd_backup/etcd-snapshot-20230825.db \
--endpoints=https://192.168.4.114:2379 \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key \
--data-dir=/data/k8s/etcd
#启动kube-apiserver和etcd容器
mv /tmp/etcd/manifests/{kube-apiserver.yaml,etcd.yaml} /etc/kubernetes/manifests/
#查看集群
kubectl get cs
Fünftens: Sicherung der binären Bereitstellung
| Knoten | IP |
|---|---|
| etdc_1 | 192.168.4.114 |
| etdc_2 | 192.168.4.115 |
| etdc_3 | 192.168.4.116 |
1) Sicherung
- Am besten sichern Sie zwei Knoten, um zu vermeiden, dass nur der Backup-Computer ausfällt
ETCDCTL_API=3 etcdctl \
snapshot save snap.db \
--endpoints=https://192.168.4.114:2379 \ #备份节点IP
--cacert=/opt/etcd/ssl/ca.pem \
--cert=/opt/etcd/ssl/server.pem \
--key=/opt/etcd/ssl/server-key.pem
2) Erholung
- Der etcd-Cluster läuft auf mehreren Servern in Form eines Dienstes. Der einzige Unterschied zur Container-Methode besteht in den Endpunkten des Dienstes. Die Sicherung ist die gleiche wie bei kubeadm.
- Wiederherstellungssequenz: kube-apiserver stoppen –> ETCD stoppen –> Daten wiederherstellen –> ETCD starten –> kube-apiserve starten
1. Stoppen Sie Apiserver und etcd
#每个etcd节点需要先手动停止kube-apiserver和etcd服务
systmectl stop kube-apiserver
systemctl stop etcd
mv /var/lib/etcd/default.etcd /var/lib/etcd/default.etcd.`date +%Y-%m-%d_%H:%M:%S`
2. etcd_1-Wiederherstellung
- Die Wiederherstellung muss auf jedem etcd-Knoten durchgeführt werden.
# 每个etcd依次恢复，需要修改 name, initialadvertise-peer-urls等参数
ETCDCTL_API=3 etcdctl snapshot restore snap.db \
--name etcd_1 \ # 每台节点name不一样，根据当前节点etcd配置文件即可
--initial-cluster="etcd-1=https:/192.168.4.114:2380,etcd-1=https://192.168.4.115:2380,etcd-1=https:/192.168.4.116:2380" \ #描述集群节点信息
--initial-cluster-token=etcd-cluster \
--initialadvertise-peer-urls=https://192.168.4.114:2380 \ # 修改为当前节点ip
--data-dir=/vaf/lib/default.etcd #注意数据目录
3. etcd_2-Wiederherstellung
ETCDCTL_API=3 etcdctl snapshot restore snap.db \
--name etcd_2 \
--initial-cluster="etcd-1=https:/192.168.4.114:2380,etcd-1=https://192.168.4.115:2380,etcd-1=https:/192.168.4.116:2380" \
--initial-cluster-token=etcd-cluster \
--initialadvertise-peer-urls=https://192.168.4.115:2380 \
--data-dir=/vaf/lib/default.etcd
4. etcd_3-Wiederherstellung
ETCDCTL_API=3 etcdctl snapshot restore snap.db \
--name etcd_3 \
--initial-cluster="etcd-1=https:/192.168.4.114:2380,etcd-1=https://192.168.4.115:2380,etcd-1=https:/192.168.4.116:2380" \
--initial-cluster-token=etcd-cluster \
--initialadvertise-peer-urls=https://192.168.4.116:2380 \
--data-dir=/vaf/lib/default.etcd
5. Starten Sie etcd und apiserver
#启动 kube-apiserver和etcd 服务
systemctl start kube-apiserver
systemctl start etcd
6. Überprüfen Sie den Cluster
#查看集群状态
ETCDCTL_API=3 /opt/etcd/bin/etcdctl \
--cacert=/opt/etcd/ssl/etcd-ca.pem \
--cert=/opt/etcd/ssl/server.pem \
--key=/opt/etcd/ssl/server-key.pem \
--endpoints="https://192.168.4.114:2379,https://192.168.4.115:2379,https://192.168.4.116:2379" endpoint health \
--write-out=table
#查看集群
[root@k8s-master-01 k8s]# kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME STATUS MESSAGE ERROR
controller-manager Healthy ok
scheduler Healthy ok
etcd-0 Healthy {"health":"true","reason":""}
Hinweis:
- Nachdem die Sicherung wiederhergestellt wurde, ist der Cluster vorübergehend nicht verfügbar, da die Dienste apiserver und etcd neu gestartet werden.
- etcdctl ist ein Snapshot-Backup und zeichnet nicht die zuletzt geschriebenen Daten auf, sodass bei der Wiederherstellung aus dem Backup möglicherweise die neuesten Daten verloren gehen.
- etcd kann keine auf PV-Datenvolumes gespeicherten Geschäftsdaten sichern.
- etcd ist ein globales Backup und kann nicht für einen bestimmten Namespace gesichert und wiederhergestellt werden.
6. Velero installieren
Velero-Adresse: https://github.com/vmware-tanzu/velero
ACK-Plugin-Adresse: https://github.com/AliyunContainerService/velero-plugin
1) Einführung in Velero
Velero verwendet ein Objektspeichersystem für die Sicherung. Daher müssen Sie vor der Installation von Velero ein Objektspeichersystem wie Ceph oder Minio installieren. Die Installation von Minio ist relativ einfach und es wird auch empfohlen, Minio als Backup-Speichersystem von Velero zu verwenden.
Mit Velero können Benutzer Kubernetes-Clusterressourcen und persistente Volumes sicher sichern, wiederherstellen und migrieren. Sein Grundprinzip besteht darin, Clusterdaten, wie Clusterressourcen und persistente Datenvolumes, im Objektspeicher zu sichern und die Daten während der Wiederherstellung aus dem Objektspeicher abzurufen. Neben der Notfallwiederherstellung kann es auch eine Ressourcenmigration durchführen und die Migration von Containeranwendungen von einem Cluster in einen anderen unterstützen. Dies ist auch ein sehr erfolgreiches Einsatzszenario für Velero.
Velero besteht hauptsächlich aus zwei Kernkomponenten, nämlich Server und Client. Der Server wird in einem bestimmten Kubernetes-Cluster ausgeführt, und der Client ist ein lokal ausgeführtes Befehlszeilentool. Es kann verwendet werden, solange kubectl und kubeconfig konfiguriert sind, was sehr einfach ist.
Basierend auf seiner Fähigkeit zur Sicherung von Kubernetes-Ressourcen kann Velero problemlos die Datensicherung und -wiederherstellung von Kubernetes-Clustern realisieren, Kubernetes-Cluster-Ressourcen in andere Kubernetes-Cluster kopieren oder die Produktionsumgebung schnell in die Testumgebung und andere Funktionen kopieren.
Im Hinblick auf die Ressourcensicherung unterstützt Velero die Datensicherung auf zahlreichen Cloud-Speichern, wie z. B. AWS S3 oder S3-kompatiblen Speichersystemen, Azure Blob, Google Cloud Storage, Aliyun OSS usw. Im Vergleich zu etcd, der Datenspeicher-Engine, die das gesamte Kubernetes sichert, ist die Steuerung von Velero detaillierter: Es kann die Objektebene im Kubernetes-Cluster sichern und auch Objekte wie Typ, Namespace und Label nach Klassifizierung sichern oder wiederherstellen .
2) Arbeitsablauf
Nehmen Sie als Beispiel die Kerndatensicherung. Erstellen Sie bei der Ausführung von Velero Backup mein Backup:
- Der Velero-Client ruft zunächst den Kubernetes-API-Server auf, um ein Sicherungsobjekt zu erstellen.
- BackupController wird benachrichtigt, dass ein neues Backup-Objekt erstellt wurde, und führt eine Validierung durch.
- BackupController startet den Backup-Prozess, er sammelt Daten für die Sicherung, indem er den API-Server nach Ressourcen abfragt;
- BackupController ruft den Objektspeicherdienst, beispielsweise AWS S3, auf, um die Sicherungsdatei hochzuladen. Standardmäßig unterstützt Velero Backup Create Festplatten-Snapshots aller persistenten Volumes. Snapshots können durch Angabe zusätzlicher Flags angepasst werden. Führen Sie Velero Backup Create --help aus, um verfügbare Flags anzuzeigen. Sie können Snapshots auch mit der Option --snapshot-volumes=false deaktivieren .
In Bezug auf Backup-Speicherort und Volume-Snapshots verfügt Velero über zwei benutzerdefinierte Ressourcen, BackupStorageLocation und VolumeSnapshotLocation, die zum Konfigurieren des Speicherorts von Velero-Backups und der zugehörigen persistenten Volume-Snapshots verwendet werden.
Der von BackupStorageLocation unterstützte primäre Backend-Speicher ist S3-kompatibler Speicher, ein Präfix im Bucket, in dem alle Velero-Daten gespeichert werden, und eine Reihe weiterer anbieterspezifischer Felder. Zum Beispiel: Minio und Alibaba Cloud OSS usw.;
VolumeSnapshotLocation (PV-Daten), die hauptsächlich zum Erstellen von Snapshots von PV verwendet wird, erfordert die Bereitstellung von Plug-Ins durch Cloud-Anbieter und wird vollständig durch bestimmte vom Anbieter bereitgestellte Felder definiert (z. B. AWS-Region, Azure-Ressourcengruppe, Portworx-Snapshot-Typ usw.). ). Am Beispiel der Datenbank und Middleware, die am empfindlichsten auf die Datenkonsistenz reagieren, wird das Open-Source-Speicher-Plug-in Carina in Kürze eine datenbankbewusste Velero-Volume-Snapshot-Funktion bereitstellen, mit der eine schnelle Sicherung und Wiederherstellung von Middleware-Daten realisiert werden kann.
3) Gesamtprozess
Im Folgenden sind die allgemeinen Schritte zur Implementierung von Kubernetes Velero aufgeführt:
| Schritt | beschreiben |
|---|
- Velero installieren | Velero in einem Kubernetes-Cluster installieren
- Velero-Backend-Speicher erstellen | Cloud-Speicher oder lokalen Speicher konfigurieren, der von Velero verwendet wird
- Erstellen Sie Velero-Zertifikate und -Authentifizierung | Generieren Sie TLS-Zertifikate und -Schlüssel und erstellen Sie Kubernetes Secret
- Velero konfigurieren | Erstellen Sie eine Konfigurationsdatei für Velero
- Erstellen und konfigurieren Sie Velero-Buckets | Erstellen Sie Buckets im Velero-Backend-Speicher
- Velero-Plugins konfigurieren | Velero-Plugins installieren und konfigurieren
- Velero-Zeitplan erstellen | Velero so konfigurieren, dass ein Backup-Zeitplan erstellt wird
4) Persistentes NFS-Volume
[root@k8s-master ~]# vim nfs.sh
#!/bin/bash
IPADDR=$(ip a|grep brd|grep ens160|awk '{print $2}'|grep -o -E "[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}")
read -p "请输入本机IP:" -t 30 HOST_IP
yum install -y nfs-utils
mkdir -p /data/nfs
chmod -R 777 /data/nfs
#增加配置文件
echo "/data/nfs s $IPADDR/24(rw,sync,no_subtree_check,no_root_squash)" >>/etc/exports
#查看配置文件
cat /etc/exports
#授权（chown 修改文件和文件夹的用户和用户组属性）
chown nfsnobody:nfsnobody /data/nfs
#启动和增加开启自启动
systemctl restart nfs-server.service
systemctl enable nfs-server.service
systemctl status nfs-server.service
#创建数据目录
mkdir -p /opt/nfs-storageclass
cd /opt/nfs-storageclass
cat >nfs-client-provisioner.yaml<<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
name: nfs-client-provisioner
labels:
app: nfs-client-provisioner
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: gcr.io/k8s-staging-sig-storage/nfs-subdir-external-provisioner:v4.0.1
imagePullPolicy: IfNotPresent
volumeMounts:
- name: nfs-client-root
mountPath: /persistentvolumes
env:
- name: PROVISIONER_NAME
value: nfs # 存储分配器的默认名称 ，根据自己的名称来修改，与 storageclass.yaml 中的 provisioner 名字一致
- name: NFS_SERVER
value: $HOST_IP # NFS服务器所在的 ip
- name: NFS_PATH
value: /data/nfs # 共享存储目录
volumes:
- name: nfs-client-root
nfs:
server: $HOST_IP # NFS服务器所在的 ip
path: /data/nfs # 共享存储目录
EOF
sed -i 's#gcr.io/k8s-staging-sig-storage/nfs-subdir-external-provisioner:v4.0.1# dyrnq/nfs-subdir-external-provisioner:v4.0.1#g' nfs-client-provisioner.yaml
cat >rbac.yaml<<EOF
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: ["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
EOF
cat >storageclass.yaml<<EOF
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: managed-nfs-storage
provisioner: nfs # 或者选择其他名称，必须匹配部署变量 PROVISIONER_NAME'
parameters:
archiveOnDelete: "false" #当设置为“false”时，在删除PVC时，您的pv将不会被配置程序存档。
EOF
kubectl apply -f /opt/nfs-storageclass/.
chmod o+x nfs.sh
sh nfs.sh
输入nfs的节点IP
kubectl get pods -n kube-system|grep fs-client-provisioner-
5) Installieren Sie Velero
【Offizielles Dokument】
- https://velero.io/docs/v1.9/
- https://github.com/vmware-tanzu/velero/
[Kompatibilität zwischen Velero-Version und k8s-Version]
- https://github.com/vmware-tanzu/velero
| Segelbootversion | Getestet auf der Kubernetes-Version |
|---|---|
| 1.12 | 1.25.7, 1.26.5, 1.26.7 und 1.27.3 |
| 1.11 | 1.23.10, 1.24.9, 1.25.5 und 1.26.1 |
| 1.10 | 1.22.5, 1.23.8, 1.24.6 und 1.25.1 |
| 1.9 | 1.20.5, 1.21.2, 1.22.5, 1.23 und 1.24 |
- Velero unterstützt IPv4-, IPv6- und Dual-Stack-Umgebungen
#查看k8s版本，选择Velero版本kubeadm version
[root@k8s-master1 ~]# kubeadm version
kubeadm version: &version.Info{Major:"1", Minor:"25", GitVersion:"v1.25.0", GitCommit:"a866cbe2e5bbaa01cfd5e969aa3e033f3282a8a2", GitTreeState:"clean", BuildDate:"2022-08-23T17:43:25Z", GoVersion:"go1.19", Compiler:"gc", Platform:"linux/amd64"}
cd /opt/
wget -c https://ghproxy.com/github.com/vmware-tanzu/velero/releases/download/v1.10.0/velero-v1.10.0-linux-amd64.tar.gz
tar -zxvf velero-v1.10.0-linux-amd64.tar.gz
cd velero-v1.10.0-linux-amd64
mv velero /usr/local/bin
chmod +x /usr/local/bin/velero
velero version
6) Minio installieren
1. Offizielle Adresse
【Offizielle Adresse】
- https://github.com/minio/mc
- https://min.io/docs/minio/linux/index.html?ref=docs-redirect
- https://zhuanlan.zhihu.com/p/557868296
【Angegebene Spiegelversion】
- https://github.com/minio/mc/tree/RELEASE.2023-08-18T21-57-55Z
2. Stellen Sie Yaml bereit
Hier können wir Minio verwenden, um den Objektspeicher der Cloud-Umgebung zu ersetzen. Das oben dekomprimierte komprimierte Paket enthält eine Ressourcenlistendatei mit example/minio/00-minio-deployment.yaml. Zur Vereinfachung des Testens kann der Dienst in geändert werden B. den NodePort-Typ. , können wir eine Konsolenadresse konfigurieren, um einen Eintrag für den Zugriff auf die Konsolenseite bereitzustellen. Die vollständige Ressourcenlistendatei lautet wie folgt:
#配置一个 console-address 来提供一个 console 页面的访问入口
args:
- server
- /storage
- --config-dir=/config
- --console-address=:9001 #添加
。。。。。。
ports:
- containerPort: 9000
- containerPort: 9001 #添加
#暴露端口
# type: ClusterIP
# ports:
# - port: 9000
# targetPort: 9000
# protocol: TCP
type: NodePort
ports:
- name: api
port: 9000
targetPort: 9000
- name: console
port: 9001
targetPort: 9001
nodePort: 30009
#修改minio部署yaml
cd /opt/velero-v1.10.0-linux-amd64/examples/minio
#查看
[root@k8s-master1 minio]# cat 00-minio-deployment.yaml
# Copyright 2017 the Velero contributors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
---
apiVersion: v1
kind: Namespace
metadata:
name: velero
---
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: velero
name: minio
labels:
component: minio
spec:
strategy:
type: Recreate
selector:
matchLabels:
component: minio
template:
metadata:
labels:
component: minio
spec:
volumes:
- name: storage
emptyDir: {}
- name: config
emptyDir: {}
containers:
- name: minio
image: minio/minio:edge
imagePullPolicy: IfNotPresent
args:
- server
- /storage
- --config-dir=/config
- --console-address=:9001
env:
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
value: "minio123"
ports:
- containerPort: 9000
- containerPort: 9001
volumeMounts:
- name: storage
mountPath: "/storage"
- name: config
mountPath: "/config"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: storage
namespace: velero
spec:
storageClassName: "managed-nfs-storage"
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
---
apiVersion: v1
kind: Service
metadata:
namespace: velero
name: minio
labels:
component: minio
spec:
# ClusterIP is recommended for production environments.
# Change to NodePort if needed per documentation,
# but only if you run Minio in a test/trial environment, for example with Minikube.
type: NodePort
ports:
# - port: 9000
# targetPort: 9000
# protocol: TCP
- name: api
port: 9000
targetPort: 9000
- name: console
port: 9001
targetPort: 9001
nodePort: 30009
selector:
component: minio
---
apiVersion: batch/v1
kind: Job
metadata:
namespace: velero
name: minio-setup
labels:
component: minio
spec:
template:
metadata:
name: minio-setup
spec:
restartPolicy: OnFailure
volumes:
- name: config
emptyDir: {}
containers:
- name: mc
image: minio/mc:edge
imagePullPolicy: IfNotPresent
command:
- /bin/sh
- -c
- "mc --config-dir=/config config host add velero http://minio:9000 minio minio123 && mc --config-dir=/config mb -p velero/velero"
volumeMounts:
- name: config
mountPath: "/config"
Zugriff: http://192.168.4.115:30009/login
- Benutzername: minio
- Passwort: minio123
Die Daten und Konfiguration von Minio können beispielsweise mit cephfs beibehalten werden.
Generell wird die Bereitstellung außerhalb des Clusters empfohlen.
3. ID und Schlüssel erstellen
Sie können sich für die Erstellung eines Buckets entscheiden und müssen dann einen Benutzer erstellen (merken Sie sich die ID und den Schlüssel), um den entsprechenden Bucket zum normalen Hochladen zu autorisieren.
- Benutzer auswählen – Benutzer erstellen auswählen.
- Zugriffsschlüssel: Sicherung
- Geheimer Schlüssel: Abcd123456
- Wählen Sie die Richtlinie: readwrite
4. Erstellen Sie einen Backup-Bucket
- Wählen Sie „Buckets“, um einen Backup-Bucket mit dem Namen velerodata zu erstellen.
- Wählen Sie zum Erstellen „Bucket erstellen“, der Rest ist standardmäßig eingestellt
5. Testzugang
Zugriff auf das Backup-Konto: http://192.168.4.115:30009/login
- Benutzername: minioadmin
- Passwort: minioadmin
7) Installieren Sie den Velero-Server
Erstellen Sie eine Minio-Authentifizierungsdatei und verwenden Sie dabei den oben erstellten Benutzer mit Lese-/Schreibberechtigung:
cd /opt/velero-v1.10.0-linux-amd64/
cat >velero-auth.txt << EOF
[default]
aws_access_key_id = minioadmin
aws_secret_access_key = minioadmin
EOF
velero --kubeconfig /root/.kube/config install \
--use-node-agent \
--provider aws \
--plugins velero/velero-plugin-for-aws:v1.7.0 \
--bucket velerodata --secret-file ./velero-auth.txt \
--use-volume-snapshots=false \
--namespace velero default-volumes-to-restic \
--backup-location-config region=minio,s3ForcePathStyle="true",s3Url=http://minio.velero.svc:9000
Wenn die s3URL-Adresse nicht die interne Auflösungsadresse von k8s verwendet, verwenden Sie die offengelegte Adresse des Datenports 9000 (Knoten-IP + 30008).
【Parameterbeschreibung】
- –kubeconfig findet standardmäßig die Authentifizierungsdatei, die von der Umgebungsvariablen KUBECONFIG erstellt wird
- –bucket minio Speichernamen erstellen
- --secret-file Passwortauthentifizierungsdatei
- –namespace ist standardmäßig der Velero-Namespace. Die Angabe dieses Parameters gibt die Erstellung eines Namespace an
【Wichtige Parameterbeschreibung】
| Installationsparameter | Parameterbeschreibung |
|---|---|
| -Anbieter | Deklariert die Verwendung von Plugin-Typen, die von aws bereitgestellt werden. |
| -Plugins | Verwenden Sie das AWS S3-kompatible API-Plugin „velero-plugin-for-aws“. |
| -Eimer | In COS erstellter Bucket-Name. |
| –geheime-Datei | Die Zugangsdatendatei für den Zugriff auf COS. Einzelheiten finden Sie in der oben erstellten Anmeldedatendatei „credentials-velero“. |
| –use-restic | Velero unterstützt die Verwendung des kostenlosen Open-Source-Backup-Tools Restic zum Sichern und Wiederherstellen von Kubernetes-Speicher-Volume-Daten (hostPath-Volumes werden nicht unterstützt, Einzelheiten finden Sie unter Restic-Einschränkungen). Diese Integration ist eine Ergänzung zur Backup-Funktion von Velero und es wird empfohlen, sie zu aktivieren Es. |
| –default-volumes-to-restic | Aktivieren Sie die Verwendung von Restic zum Sichern aller Pod-Volumes, sofern der Parameter --use-restic aktiviert werden muss. |
| –backup-location-config | Konfigurationen für den Backup-Bucket-Zugriff, einschließlich Region, s3ForcePathStyle, s3Url usw. |
| Region | Die Objektspeicher-COS-Bucket-Region ist mit der S3-API kompatibel. Die Erstellungsregion ist beispielsweise Guangzhou und der Regionsparameterwert ist „ap-guangzhou“. |
| s3ForcePathStyle | Verwenden Sie das S3-Dateipfadformat. |
| s3Url | Objektspeicher-COS-kompatible S3-API-Zugriffsadresse. Bitte beachten Sie, dass der Domänenname in der Zugriffsadresse nicht der oben erwähnte Domänenname für den Zugriff auf das öffentliche Netzwerk zum Erstellen des COS-Speicher-Buckets ist und das URL-Format https://cos..myqcloud.com verwendet werden muss. Zum Beispiel, wenn Die Region ist Guangzhou, der Parameterwert ist https://cos.ap-guangzhou.myqcloud.com. |
- Weitere Installationsparameter können mit dem Befehl velero install --help eingesehen werden. Anstatt beispielsweise Speicher-Volume-Daten zu sichern, können Sie --use-volume-snapshots=false festlegen, um die Snapshot-Sicherung des Speicher-Volumes zu deaktivieren.
#查看
[root@k8s-master1 velero-v1.10.0-linux-amd64]# kubectl get backupstoragelocation -A -oyaml
apiVersion: v1
items:
- apiVersion: velero.io/v1
kind: BackupStorageLocation
metadata:
creationTimestamp: "2023-09-05T06:08:12Z"
generation: 15
labels:
component: velero
name: default
namespace: velero
resourceVersion: "1116179"
uid: 3eb2e6ef-f95e-4674-92c7-8b296f864d57
spec:
config:
region: minio
s3ForcePathStyle: "true"
s3Url: http://minio.velero.svc:9000
default: true
objectStorage:
bucket: velerodata
provider: aws
status:
lastSyncedTime: "2023-09-05T06:14:21Z"
lastValidationTime: "2023-09-05T06:14:21Z"
phase: Available
kind: List
metadata:
resourceVersion: ""
#删除
kubectl delete -n velero backupstoragelocations.velero.io default
kubectl delete deployments.apps -n velero velero
#卸载
velero uninstall
#查看安装状态
[root@k8s-master1 ~]# kubectl get pod -n velero
NAME READY STATUS RESTARTS AGE
minio-597fcfdb94-cksx2 1/1 Running 0 18m
minio-setup-76r5g 0/1 Completed 0 18m
node-agent-frqjq 1/1 Running 0 12m
node-agent-mtb96 1/1 Running 0 12m
node-agent-nlsg7 1/1 Running 0 12m
velero-5bb5bd6699-f8z9q 1/1 Running 0 12m
[root@k8s-master1 ~]# kubectl get crd | grep velero
backuprepositories.velero.io 2023-09-05T06:08:09Z
backups.velero.io 2023-09-05T06:08:09Z
backupstoragelocations.velero.io 2023-09-05T06:08:09Z
deletebackuprequests.velero.io 2023-09-05T06:08:09Z
downloadrequests.velero.io 2023-09-05T06:08:09Z
podvolumebackups.velero.io 2023-09-05T06:08:09Z
podvolumerestores.velero.io 2023-09-05T06:08:09Z
restores.velero.io 2023-09-05T06:08:10Z
schedules.velero.io 2023-09-05T06:08:10Z
serverstatusrequests.velero.io 2023-09-05T06:08:10Z
volumesnapshotlocations.velero.io 2023-09-05T06:08:10Z
#查看安装状态
[root@k8s-master1 ~]# kubectl get backupstoragelocations -A
NAMESPACE NAME PHASE LAST VALIDATED AGE DEFAULT
velero default Available 45s 13m true
[Velero durch Ruder installiert]
- http://www.1024sky.cn/blog/article/77733
7. Stellen Sie die Testanwendung bereit
1) Stellen Sie den Testdienst bereit
Stellen Sie zwei Testanwendungen bereit, um die Sicherungs- und Wiederherstellungsergebnisse zu testen, und verwenden Sie minio zum Speichern von Sicherungsdaten
- MySQL 5.7
cd /opt/velero-v1.10.0-linux-amd64/
cat >mysql5.7.yaml<<EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mysql-pv-claim
spec:
storageClassName: managed-nfs-storage
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
---
apiVersion: apps/v1 #版本
kind: Deployment #创建资源的类型
metadata: #资源的元数据
name: mysql-dep #资源的名称，是元数据必填项
spec: #期望状态
replicas: 1 #创建的副本数量（pod数量），不填默认为1
selector: #
matchLabels:
app: mysql-pod
template: #定义pod的模板
metadata: #pod的元数据
labels: #labels标签，必填一个
app: mysql-pod
spec: #pod的期望状态
containers: #容器
- name: mysql #容器名称
image: mysql:5.7 #镜像
imagePullPolicy: IfNotPresent
ports: #容器的端口
- containerPort: 3306
env:
- name: MYSQL_ROOT_PASSWORD
value: "root"
volumeMounts:
- name: mysql-persistent-storage
mountPath: /var/lib/mysql
volumes:
- name: mysql-persistent-storage
persistentVolumeClaim:
claimName: mysql-pv-claim
---
apiVersion: v1 #版本
kind: Service #创建资源的类型
metadata: #资源的元数据
name: mysql-svc #资源的名称，是元数据必填项
labels: #labels标签
app: mysql-svc
spec: #期望状态
type: NodePort #服务类型
ports: #端口
- port: 3306
targetPort: 3306 #与containerPort一样
protocol: TCP
nodePort: 30306
selector:
app: mysql-pod
EOF
- Nginx-Bereitstellungsdatei
cat >nginx.yaml<<EOF
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: my-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
storageClassName: managed-nfs-storage
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
replicas: 1
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
volumes:
- name: data-volume
persistentVolumeClaim:
claimName: my-pvc
containers:
- name: nginx
image: nginx
volumeMounts:
- name: data-volume
mountPath: /var/www/html
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: NodePort
ports:
- port: 80
targetPort: 80
selector:
app: nginx
EOF
#创建
kubectl apply -f mysql5.7.yaml
kubectl apply -f nginx.yaml
2) Schreiben Sie Testinhalte
kubectl exec -it -n default mysql-dep-58cb9d765f-4sd58 /bin/bash
mysql -uroot -proot
-- 创建测试数据库
CREATE DATABASE testdb;
-- 使用测试数据库
USE testdb;
-- 创建测试表
CREATE TABLE test_table (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50),
age INT,
email VARCHAR(100)
);
-- 插入测试数据
INSERT INTO test_table (name, age, email) VALUES
('John Doe', 25, '[email protected]'),
('Jane Smith', 30, '[email protected]'),
('Mike Johnson', 35, '[email protected]');
select * from test_table;
+----+--------------+------+--------------------------+
| id | name | age | email |
+----+--------------+------+--------------------------+
| 1 | John Doe | 25 | [email protected] |
| 2 | Jane Smith | 30 | [email protected] |
| 3 | Mike Johnson | 35 | [email protected] |
+----+--------------+------+--------------------------+
#退出MySQL和容器
mysql> exit
Bye
bash-4.2# exit
exit
Acht, Testsicherung
1) Backup-Zusammenfassung
1. Backup-Klassifizierung
Velero bietet zwei Möglichkeiten, zustandsbehaftete Daten zu sichern. Der Vergleich ist wie folgt
| Berücksichtigen Sie die Abmessungen | Basierend auf einem CSI-Schnappschuss | Dateikopie |
|---|---|---|
| Auswirkungen auf die Anwendungsleistung | Bei niedrigem Wert ruft die CSI-Schnittstelle den Speichersystem-Snapshot auf | Verbraucht je nach Datenmenge zusätzliche Ressourcen |
| Datenverfügbarkeit | Abhängig vom Speichersystem müssen Sie ein CSI verwenden, das Snapshots unterstützt | Isolation der Objektspeicher- und Produktionsumgebung, unabhängige Verfügbarkeit, Unterstützung der standortübergreifenden Verfügbarkeit |
| Datenkonsistenz | Unterstützen Sie die Crash-Konsistenz und arbeiten Sie mit dem Hook-Mechanismus zusammen, um Konsistenz zu erreichen | Keine Garantie, je nach Haken |
⋓Das Kopieren von Dateien wird verschlüsselt, komprimiert und inkrementell gesichert. Das Komprimierungsverhältnis beträgt etwa 60 %. Bei den Sicherungsdateien handelt es sich ausschließlich um verschlüsselte Binärdateien, die verstümmelt sind
Zwei Plugins zum Kopieren von Dateien:
- Restic (Standard) https://restic.readthedocs.io/en/latest/100_references.html#terminology
- Kopieren Sie https://kopia.io/docs/advanced/architecture
2. Best Practices für Backups
- Wenn Ihr Speicher Snapshots unterstützt, hochfrequente lokale Snapshots + niederfrequente Restic-Backups auf s3
- Wählen Sie aus Anwendungssicht die geeignete Backup-Granularität und Backup-Strategie aus
- Vermeiden Sie Konflikte bei der gemeinsamen Nutzung desselben Objektspeichers in einer Multi-Cluster-Umgebung
3. Synchronisationsmechanismus
- Da Velero Backup die Metainformationen dieser Sicherungsaufgabe auf s3 hochlädt, synchronisiert Velero die Sicherungsaufgabe von s3 regelmäßig mit dem Cluster, wenn die Sicherungsaufgabe im Cluster gelöscht wird, die Daten in s3 jedoch gelöscht werden
4. Grube
- Das Löschen von Sicherungs- oder Wiederherstellungsaufgaben, die über einen längeren Zeitraum nicht abgeschlossen wurden, führt dazu, dass Velero blockiert und nachfolgende Aufgaben nicht mehr verarbeitet werden können
- Bei Verwendung der Dateikopie-Sicherungsmethode werden Anwendungen mit sich schnell ändernden Sicherungsdateisystemen wie Es und Ck aller Wahrscheinlichkeit nach nicht gesichert
2) Sicherung
- Backup unterstützt vollständige Backups, spezifizierte Namespace-Sicherung, spezifizierte Selektor-Sicherung usw. Weitere Informationen finden Sie in der Hilfe über velero backup create -h.
#创建单次的备份任务，备份数据库与nginx
velero backup create test3 --include-namespaces=default --default-volumes-to-fs-backup
Gemeinsame Parameter:
- --include-namespaces: Geben Sie die zu sichernden Namespaces an, getrennt durch mehrere Kommas
- –include-resources: Geben Sie den zu sichernden Ressourcentyp an, getrennt durch mehrere Kommas, z. B. configmap, Secret
- --include-cluster-resources: Auf „true“ gesetzt, um anzugeben, dass die Sicherung Ressourcen auf Clusterebene enthält, getrennt durch mehrere Kommas
- –exclude-namespaces: Angegebene Namespaces ausschließen, durch mehrere Kommas getrennt
- Ausschließen von Ressourcen: Bestimmte Ressourcentypen ausschließen
- Velero-Backup: Backup anzeigen
- velero backup discover --details Liste der Sicherungsdaten anzeigen
3) Timing-Sicherung
#这里我们为了测试将备份周期调整成了每分钟一次
[root@master1 yaml]# velero schedule create schedule-backup --schedule="* * * * *" --include-namespaces=default --default-volumes-to-fs-backup Schedule "schedule-backup" created successfully.
[root@master1 yaml]# kubectl get schedule -A
NAMESPACE NAME STATUS SCHEDULE LASTBACKUP AGE PAUSED
velero schedule-backup Enabled * * * * * 15s
8. Erholung
- Löschen Sie zuerst MySQL und Nginx. Wir haben Nginx und MySQL hier manuell gelöscht, um einen Datenverlust zu simulieren
#删除
cd /opt/velero-v1.10.0-linux-amd64/
kubectl delete -f mysql5.7.yaml
kubectl delete -f nginx.yaml
#查看
kubectl get pod -n default
kubectl get all -n default
-Starten Sie die Wiederherstellung, erstellen Sie eine Wiederherstellungsstrategie und stellen Sie eine zuvor gesicherte Sicherungsaufgabe wieder her
#查看备份
[root@k8s-master1 ~]# kubectl get backup -A
NAMESPACE NAME AGE
velero test3 5m47s
#恢复
[root@k8s-master1 ~]# velero restore create --from-backup test3
Restore request "test3-20230905145431" submitted successfully.
Run `velero restore describe test3-20230905145431` or `velero restore logs test3-20230905145431` for more details.
#查看恢复记录
[root@k8s-master1 ~]# kubectl get restore -A
NAMESPACE NAME AGE
velero test3-20230905145431 26s
#查看恢复的数据
[root@k8s-master1 ~]# kubectl get pods -n default
NAME READY STATUS RESTARTS AGE
mysql-dep-58cb9d765f-4sd58 0/1 PodInitializing 0 64s
nginx-deployment-7bb559659f-w6tpw 1/1 Running 0 64s
- Nach einer Weile wird festgestellt, dass alle Pods ausgeführt werden, und es wird überprüft, ob Daten in MySQL vorhanden sind.
[root@k8s-master1 ~]# kubectl exec -it -n default mysql-dep-58cb9d765f-4sd58 /bin/bash
bash-4.2# mysql -uroot -proot
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
| testdb |
+--------------------+
5 rows in set (0.00 sec)
mysql> use testdb;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> select * from test_table;
+----+--------------+------+--------------------------+
| id | name | age | email |
+----+--------------+------+--------------------------+
| 1 | John Doe | 25 | [email protected] |
| 2 | Jane Smith | 30 | [email protected] |
| 3 | Mike Johnson | 35 | [email protected] |
+----+--------------+------+--------------------------+
3 rows in set (0.00 sec)
9. Cluster-Datenmigration
#首先，在集群 1 中创建备份（默认 TTL 是 30 天，你可以使用 --ttl 来修改）：
velero backup create <BACKUP-NAME>
#然后，为集群 2 配置 BackupStorageLocations 和 VolumeSnapshotLocations，指向与集群 1 相同的备份和快照路径，并确保 BackupStorageLocations 是只读的（使用 --access-mode=ReadOnly）。接下来，稍微等一会（默认的同步时间为 1 分钟），等待 Backup 对象创建成功。
velero backup describe <BACKUP-NAME>
#最后，执行数据恢复：
velero restore create --from-backup <BACKUP-NAME>
velero restore get
velero restore describe <RESTORE-NAME-FROM-GET-COMMAND>
10. Referenzadresse
【kubeadm】
- http://wed.xjx100.cn/news/186281.html?action=onClick
- http://www.inspinia.net/a/216380.html?action=onClick
- https://www.cnblogs.com/xiaozhi1223/p/16570606.html
- https://cloud.tencent.com/developer/article/2098673
[Drehbuch]
- https://www.cnblogs.com/zhangmingcheng/p/13892140.html
- https://www.cnblogs.com/xiaozhi1223/p/16570606.html
[Referenz zur binären Bereitstellung]
- https://www.yii666.com/blog/509712.html
- https://www.cnblogs.com/xiaozhi1223/p/16570606.html
【Velero-Werkzeuge】
- https://github.com/vmware-tanzu/velero
[Schlüsselreferenz]
- https://www.jb51.cc/k8s/3812803.html
- https://blog.51cto.com/u_16175439/6627299
- http://yunxue521.top/archives/velero
【Tencent Cloud-Dokumentation】
- https://www.tencentcloud.com/zh/document/product/457/38939
【Backup-Tool-Behälter】
- https://zhuanlan.zhihu.com/p/391732609
【Ausgezeichneter Blog】
- https://www.hi-linux.com/posts/60858.html