Installazione e configurazione di Restic e Velero in modalità autonoma in cluster TKG

Per eseguire il backup e il ripristino dei carichi di lavoro in esecuzione nei cluster TKG nel Supervisore, creare un datastore e installare Velero con Restic nel cluster Kubernetes.

Panoramica

I cluster TKG vengono eseguiti nei nodi della macchina virtuale. Per eseguire il backup e il ripristino dei carichi di lavoro dei cluster TKG, installare Velero e Restic nel cluster.

Prerequisiti

Assicurarsi che l'ambiente soddisfi i seguenti prerequisiti per l'installazione di Velero e Restic per il backup e il ripristino dei carichi di lavoro in esecuzione nei cluster di Tanzu Kubernetes.

Una macchina virtuale Linux con una quantità di storage sufficiente per archiviare diversi backup del carico di lavoro. In questa macchina virtuale verrà installato MinIO.
Una macchina virtuale Linux in cui sono installati i Strumenti CLI Kubernetes di vSphere, tra cui Plug-in vSphere per kubectl e kubectl. In questa macchina virtuale client verrà installata la CLI di Velero. Se non si dispone di una macchina virtuale di questo tipo, è possibile installare la CLI di Velero in locale, ma è necessario modificare i passaggi di installazione di conseguenza.
L'ambiente Kubernetes dispone di accesso a Internet e può essere raggiunto dalla macchina virtuale client.

Installazione e configurazione dell'archivio oggetti MinIO

Velero richiede un archivio oggetti compatibile con S3 come destinazione per i backup dei carichi di lavoro di Kubernetes. Velero supporta diversi provider di archivi oggetti. Per semplicità, queste istruzioni utilizzano MinIO, un servizio di storage compatibile con S3 eseguito in locale nella macchina virtuale dell'archivio oggetti.

Installare MinIO.

wget https://dl.min.io/server/minio/release/linux-amd64/minio

Concedere le autorizzazioni di esecuzione a MinIO.
```
chmod +x minio
```
Creare una directory sul file system per MinIO.
```
mkdir /DATA-MINIO
```
Avviare il server MinIO.
```
./minio server /DATA-MINIO
```

Dopo l'avvio del server MinIO, vengono forniti importanti dettagli sull'istanza del datastore, tra cui l'URL dell'endpoint, AccessKey e SecretKey. Nella tabella registrare l'URL dell'endpoint, AccessKey e SecretKey.

Metadati del datastore	Valore
Endpoint URL
AccessKey
SecretKey

Passare al datastore MinIO aprendo un browser con l'URL dell'endpoint del server MinIO.
Accedere al server MinIO e fornire AccessKey e SecretKey.
Per abilitare MinIO come servizio, configurare MinIO per l'avvio automatico scaricando lo script minio.service.
```
curl -O https://raw.githubusercontent.com/minio/minio-service/master/linux-systemd/minio.service
```
Modificare lo script minio.service e aggiungere il valore seguente per ExecStart.
```
ExecStart=/usr/local/bin/minio server /DATA-MINIO path
```
Salvare lo script rivisto.

Configurare il servizio MinIO eseguendo i comandi seguenti.

cp minio.service /etc/systemd/system 
cp minio /usr/local/bin/ 
systemctl daemon-reload 
systemctl start minio 
systemctl status minio 
systemctl enable minio

Creare un bucket MinIO per il backup e il ripristino avviando il browser MinIO e accedendo all'archivio oggetti.
Fare clic sull'icona di creazione del bucket.
Immettere il nome del bucket, ad esempio my-cluster-backups.
Verificare che il bucket sia stato creato.
Per impostazione predefinita, un nuovo bucket MinIO è di sola lettura. Per il backup e il ripristino di Velero in modalità autonoma, il bucket MinIO deve essere di lettura-scrittura. Per impostare il bucket su lettura-scrittura, selezionare il bucket e fare clic sul collegamento con i puntini.
Selezionare Modifica criterio.
Modificare il criterio impostandolo su Lettura e scrittura.
Fare clic su Aggiungi.
Per chiudere la finestra di dialogo, fare clic su X

Installare la CLI di Velero

Installare la CLI di Velero nel client della macchina virtuale o nella macchina locale.

La versione utilizzata per questa documentazione è Velero 1.9.7 per Tanzu Kubernetes Grid 2.2.0.

Scaricare Velero dalla pagina di download del prodotto Tanzu Kubernetes Grid nel portale VMware Customer Connect.
Nota: Per l'idoneità per il supporto di VMware, è necessario utilizzare il file binario Velero firmato da VMware.
Aprire una riga di comando e passare alla directory di download della CLI di Velero.
Decomprimere il file di download. Ad esempio:
```
gunzip velero-linux-vX.X.X_vmware.1.gz
```
Verificare che sia presente il file binario di Velero.
```
ls -l
```
Concedere le autorizzazioni di esecuzione alla CLI di Velero.
```
chmod +x velero-linux-vX.X.X_vmware.1 
```
Rendere la CLI di Velero disponibile globalmente spostandola nel percorso di sistema:
```
cp velero-linux-vX.X.X_vmware.1 /usr/local/bin/velero 
```
Verificare l'installazione.
```
velero version
```

Installare Velero e Restic nel cluster di Tanzu Kubernetes

Il contesto della CLI di Velero seguirà automaticamente il contesto di kubectl. Prima di eseguire i comandi della CLI di Velero per installare Velero e Restic nel cluster di destinazione, impostare il contesto di kubectl.

Recuperare il nome del bucket MinIO. Ad esempio my-cluster-backups.
Recuperare AccessKey e SecretKey per il bucket MinIO.
Impostare il contesto per il cluster Kubernetes di destinazione in modo che la CLI di Velero sappia in quale cluster lavorare.
```
kubectl config use-context tkgs-cluster-name
```
Creare un file di segreti denominato credentials-minio. Aggiornare il file con le credenziali di accesso del server MinIO raccolte. Ad esempio:
```
aws_access_key_id = 0XXNO8JCCGV41QZBV0RQ
aws_secret_access_key = clZ1bf8Ljkvkmq7fHucrKCkxV39BRbcycGeXQDfx
```
Nota: Se viene visualizzato il messaggio di errore relativo al recupero di un archivio di backup con la descrizione "NoCredentialProviders: no valid providers in chain", inserire la riga [default] all'inizio del file delle credenziali. Ad esempio:
```
[default]
aws_access_key_id = 0XXNO8JCCGV41QZBV0RQ
aws_secret_access_key = clZ1bf8Ljkvkmq7fHucrKCkxV39BRbcycGeXQDfx
```
Salvare il file e verificare che sia presente.
```
ls
```

Eseguire il comando seguente per installare Velero e Restic nel cluster Kubernetes di destinazione. Sostituire entrambi gli URL con l'URL dell'istanza di MinIO.

velero install \
--provider aws \
--plugins velero/velero-plugin-for-aws:v1.0.0 \
--bucket tkgs-velero \
--secret-file ./credentials-minio \
--use-volume-snapshots=false \
--use-restic \
--backup-location-config \
region=minio,s3ForcePathStyle="true",s3Url=http://10.199.17.63:9000,publicUrl=http://10.199.17.63:9000

Verificare l'installazione di Velero e Restic.
```
kubectl logs deployment/velero -n velero
```
Verificare lo spazio dei nomi velero.
```
kubectl get ns
```
Verificare i pod di velero e restic.
```
kubectl get all -n velero
```

Risolvere i problemi del DaemonSet Restic (se necessario)

Per eseguire il DaemonSet di Restic a tre pod in un cluster di Kubernetes, potrebbe essere necessario aggiornare la specifica del DaemonSet di Restic e modificare hostPath. Per ulteriori informazioni su questo problema, vedere l'argomento relativo all' integrazione di Restic nella documentazione di Velero.

Verificare il DaemonSet di Restic a tre pod.
```
kubectl get pod -n velero
```
Se lo stato dei pod è CrashLoopBackOff, modificarli come indicato di seguito.
Eseguire il comando edit.
```
kubectl edit daemonset restic -n velero
```
Modificare hostPath da /var/lib/kubelet/pods a /var/vcap/data/kubelet/pods.
```
- hostPath:
    path: /var/vcap/data/kubelet/pods
```
Salvare il file.

Verificare il DaemonSet di Restic a tre pod.

kubectl get pod -n velero

NAME                      READY   STATUS    RESTARTS   AGE
restic-5jln8              1/1     Running   0          73s
restic-bpvtq              1/1     Running   0          73s
restic-vg8j7              1/1     Running   0          73s
velero-72c84322d9-le7bd   1/1     Running   0          10m

Regolare i limiti di memoria di Velero (se necessario)

Se il backup di Velero restituisce status=InProgress per molte ore, aumentare i limiti e le impostazioni della memoria delle richieste.

Eseguire il comando seguente.

kubectl edit deployment/velero -n velero

Modificare le impostazioni predefinite dei limiti e della memoria delle richieste, ovvero 256Mi e 128Mi, sostituendole con 512Mi e 256Mi.

    
ports:
- containerPort: 8085
  name: metrics
  protocol: TCP
resources:
  limits:
    cpu: "1"
    memory: 512Mi
  requests:
    cpu: 500m
    memory: 256Mi
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File