Velero

restore.sh

#!/bin/bash
# <source_ns> [destination_ns]

nameSpace=$1
nameSpaceDestination=$2

echo

# Read file names into an array
mapfile -t files_array < <(oc get backups.velero.io -n openshift-adp -o name |tac |cut -d/ -f2 |grep -w $nameSpace)

# Display the index number and file name for each file in the array
echo "Backups :"
for ((i=0; i<${#files_array[@]}; i++)); do
    echo "$i:${files_array[$i]}"
done

echo
echo "Select index [0]:" 
read i
[ -z $i ] &&i=0
backupName="${files_array[$i]}"

[ -z $nameSpaceDestination ] &&nameSpaceDestination=$nameSpace
kubectl get ns $nameSpaceDestination -o name >/dev/null 2>&1 &&nameSpaceDestination=${nameSpaceDestination}-$(echo $RANDOM |md5sum |cut -c1-6 )

OADP_OPERATOR_NAMESPACE=openshift-adp
cat <<EOF |kubectl -n ${OADP_OPERATOR_NAMESPACE} apply -f -
apiVersion: velero.io/v1
kind: Restore
metadata:
  name: ${nameSpace}-$(date '+%Y%m%d%H%M')
spec:
  backupName: ${backupName}
  restorePVs: true
  namespaceMapping:
    ${nameSpace}: ${nameSpaceDestination}
EOF

watch kubectl get all -n ${nameSpaceDestination}

backup.sh

#!/bin/bash
# <source_ns>

export nameSpace=$1

backupSuffix="-$(date '+%Y%m%d-%H-%M')"
backupName=${nameSpace}${backupSuffix}
export OADP_OPERATOR_NAMESPACE=openshift-adp

cat <<EOF |kubectl -n ${OADP_OPERATOR_NAMESPACE} apply -f - |cut -d' ' -f1 |xargs watch kubectl -o jsonpath='{.status.phase}' -n ${OADP_OPERATOR_NAMESPACE} get
apiVersion: velero.io/v1
kind: Backup
metadata:
  name: ${backupName}
spec:
  defaultVolumesToRestic: true
#  defaultVolumesToFsBackup: true
  snapshotVolumes: true
  includedNamespaces:
  - ${nameSpace}
  storageLocation: velero-1
  ttl: 240h0m0s
  volumeSnapshotLocations:
  - velero-1
EOF

documentation MD

# Ajouter Velero à C2

Ce guide vous explique comment ajouter Velero à C2 pour effectuer des sauvegardes et des restaurations de ressources Kubernetes.

## 1) Création du bucket S3

Avant d'installer Velero, vous devez créer un bucket S3 où les sauvegardes seront stockées. 
Pour créer le bucket S3, exécutez les commandes suivantes :

```bash
# Définir les variables d'environnement
export s3Url=                                        
export bucketName=                           
export AccessKey=
echo SecretKey ;read i &&export SecretKey=$i
```
```bash
# Créer le bucket S3
aws s3api create-bucket --endpoint-url $s3Url --no-verify-ssl --bucket $bucketName
```
Importer votre secret :
```bash
cat <<EOT > ~/credentials-velero
[default]
aws_access_key_id = $AccessKey
aws_secret_access_key = $SecretKey
EOT
```

Assurez-vous de remplacer les valeurs des variables d'environnement `s3Url`, `bucketName` et `SecretKey` selon votre configuration.

## 2) Installation de Velero avec Helm

Pour installer Velero, suivez les étapes ci-dessous :
 

### 2.1) Ajouter le référentiel Helm Velero

```bash
export nameSpace=velero
helm repo add vmware-tanzu https://vmware-tanzu.github.io/helm-charts
helm repo update
```

### 2.2) Installer Velero avec les paramètres appropriés
```bash
kubectl create namespace $nameSpace
```

```bash
#https://github.com/vmware-tanzu/helm-charts/blob/main/charts/velero/values.yaml
helm upgrade --install velero vmware-tanzu/velero \
  --namespace $nameSpace \
  --set-file credentials.secretContents.cloud=$(realpath ~/credentials-velero ) \
  --set configuration.backupStorageLocation[0].provider=aws \
  --set configuration.backupStorageLocation[0].name=default \
  --set configuration.backupStorageLocation[0].bucket=${bucketName} \
  --set configuration.backupStorageLocation[0].config.region=minio \
  --set configuration.backupStorageLocation[0].config.s3ForcePathStyle=true \
  --set configuration.backupStorageLocation[0].config.s3Url=${s3Url} \
  --set snapshotsEnabled=true \
  --set configuration.volumeSnapshotLocation[0].provider=aws \
  --set configuration.volumeSnapshotLocation[0].name=default \
  --set configuration.volumeSnapshotLocation[0].bucket=${bucketName} \
  --set configuration.volumeSnapshotLocation[0].config.region=minio \
  --set configuration.volumeSnapshotLocation[0].config.s3ForcePathStyle=true \
  --set configuration.volumeSnapshotLocation[0].config.s3Url=${s3Url} \
  --set deployNodeAgent=true \
  --set 'initContainers[0].name=velero-plugin-for-aws' \
  --set 'initContainers[0].volumeMounts[0].mountPath=/target' \
  --set 'initContainers[0].image=velero/velero-plugin-for-aws:v1.8.0' \
  --set 'initContainers[0].volumeMounts[0].name=plugins'
```

Assurez-vous de remplacer les valeurs des paramètres selon votre configuration :

- `credentials.secretContents.cloud` : Chemin du fichier contenant les informations d'identification pour Velero.
- `configuration.backupStorageLocation.bucket` : Nom du bucket de stockage des sauvegardes.
- `configuration.backupStorageLocation.config.region` : Région où est situé le stockage des sauvegardes.
- `configuration.backupStorageLocation.config.s3Url` : URL S3 personnalisée pour l'adresse du service de stockage.

Vérifiez que Velero est correctement installé en exécutant la commande suivante :

```bash
kubectl get pods -n $nameSpace
```

## 3) Utilisation de Velero

Une fois Velero installé, vous pouvez utiliser les commandes suivantes pour effectuer des sauvegardes et des restaurations de ressources Kubernetes.

Tout d'abord, définissez le `storageLocation` de Velero en ex

écutant la commande `kubectl api-resources`.

### 3.1) Création d'une sauvegarde

```bash
==BACKUP==
export nameSpace=infra-root

export backupSuffix="-$(date '+%Y%m%d-%H')"
export backupName=${nameSpace}${backupSuffix}

cat <<EOF |kubectl -n velero apply -f -
apiVersion: velero.io/v1
kind: Backup
metadata:
  name: ${backupName}
spec:
  defaultVolumesToRestic: true
#  defaultVolumesToFsBackup: true
  snapshotVolumes: true
  includedNamespaces:
  - ${nameSpace}
  storageLocation: default
  ttl: 240h0m0s
EOF
```
```bash
export nameSpace=infra-root
export backupSuffix="-$(date '+%Y%m%d-%H')"
export backupName=${nameSpace}${backupSuffix}
```

Créez un fichier `backup.yaml` et ajoutez le code suivant :

```yaml
apiVersion: velero.io/v1
kind: Backup
metadata:
  name: ${backupName}
spec:
  defaultVolumesToRestic: true
#  defaultVolumesToFsBackup: true
  snapshotVolumes: true
  includedNamespaces:
  - ${nameSpace}
  storageLocation: default
  ttl: 240h0m0s
```

### 3.2) Création d'une restauration

```bash
==RESTORE==
export nameSpace=openproject
export nameSpaceDestination=openproject2

export backupSuffix="-$(date '+%Y%m%d-%H')"
export backupName=${nameSpace}${backupSuffix}
export restoreName=${nameSpace}${backupSuffix}

cat <<EOF |kubectl -n velero apply -f -
apiVersion: velero.io/v1
kind: Restore
metadata:
  name: ${restoreName}
spec:
  backupName: ${backupName}
  restorePVs: true
  namespaceMapping:
    ${nameSpace}: ${nameSpaceDestination}
EOF
```
```bash
export restoreName=infra-root
export nameSpaceDestination=ns-restore
```

Créez un fichier `restore.yaml` et ajoutez le code suivant :

```yaml
apiVersion: velero.io/v1
kind: Restore
metadata:
  name: ${restoreName}
spec:
  backupName: ${backupName}
  restorePVs: true
  namespaceMapping:
    ${nameSpace}: ${nameSpaceDestination}
```

Assurez-vous de remplacer les variables `${backupName}`, `${nameSpace}`, `${nameSpaceDestination}` et `<nom de storageLocation>` selon vos besoins.

Vous pouvez utiliser ces fichiers YAML pour créer des sauvegardes et effectuer des restaurations en utilisant la commande `kubectl apply -f <fichier.yaml>`.

```bash
#==SCEDULE==
export namespaceList="velero
openproject"

echo "${namespaceList}" |while read nameSpace ;do
  scheduleName=$nameSpace
  cat <<EOF |kubectl -n velero apply -f -
apiVersion: velero.io/v1
kind: Schedule
metadata:
  name: ${scheduleName}
spec:
  schedule: '0 0 * * * '
  template:
    storageLocation: default
    ttl: 240h0m0s
    defaultVolumesToRestic: true
#    defaultVolumesToFsBackup: true
    includedNamespaces:
      - ${nameSpace}
EOF
done
```