Comment restaurer, redimensionner ou créer un instantané de stockage persistant EBS dans Amazon EKS à des fins de reprise après sinistre ou lorsque le taux de modification d'EBS est dépassé ?

Dernière mise à jour : 09-11-2022

Je souhaite utiliser un instantané de stockage persistant Amazon Elastic Block Store (Amazon EBS) dans Amazon Elastic Kubernetes Service (Amazon EKS) pour la reprise après sinistre. Comment créer, redimensionner ou restaurer un tel instantané ? Ou bien, j'ai dépassé mon taux de modification Amazon EBS. Mais je dois tout de même redimensionner, restaurer ou créer un instantané de mon stockage persistant Amazon EBS dans Amazon EKS.

Brève description

Vous modifiez votre stockage persistant Amazon EBS dans Amazon EKS et vous recevez le message d'erreur suivant :

Code d'erreur : Client.Volume : taux de modification dépassé
Message d'erreur : Vous avez atteint le taux de modification maximal par limite de volume. Attendez au moins 6 heures entre les modifications par volume EBS

Après avoir modifié un volume, vous devez attendre au moins six heures avant de pouvoir continuer à le modifier. Assurez-vous que le volume est en cours d'utilisation ou disponible avant de le modifier à nouveau.

Votre entreprise peut avoir un objectif de reprise après sinistre (DR) avec un objectif de temps de restauration (RTO) inférieur à six heures. Pour les RTO d'une durée inférieure à six heures, créez un instantané et restaurez votre volume à l'aide du pilote Amazon EBS Container Storage Interface (CSI).

Solution

Remarque : si vous recevez des erreurs lors de l'exécution de commandes depuis l'interface de la ligne de commande AWS (AWS CLI), vérifiez que vous utilisez la version la plus récente de l'AWS CLI.

Utilisez le pilote Amazon EBS CSI et le snapshotter externe pour effectuer les opérations suivantes :

  1. Créez un instantané Amazon EBS de la réclamation PersistentVolumeClaim.
  2. Restaurez la réclamation PersistentVolumeClaim.
  3. Liez le PersistentVolumeClaim à la charge de travail.

Prérequis :

Installez le pilote Amazon EBS CSI à l'aide du snapshotter externe

1.    Vérifiez si vous disposez d'un fournisseur IAM OpenID Connect (OIDC) existant pour votre cluster :

% cluster_name=ebs
% oidc_id=$(aws eks describe-cluster --name cluster_name --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
% aws iam list-open-id-connect-providers | grep $oidc_id

Remarque : remplacez cluster_name par le nom de votre cluster.

Exemple de sortie :

"Arn": "arn:aws:iam::XXXXXXXXXX:oidc-provider/oidc.eks.eu-west-1.amazonaws.com/id/B7E2BC2980D17C9A5A3889998CB22B23"

Remarque : Si vous ne disposez pas d'un fournisseur IAM OIDC, créez-en un pour votre cluster.

2.    Installez le snapshotter externe.
Remarque : vous devez installer le snapshotter externe avant d'installer le module complémentaire Amazon EBS CSI. Vous devez également installer les composants externes du snapshotter dans l'ordre suivant :

Définition de ressource personnalisée (CRD) pour les classes d'instantanés de volumes, les instantanés de volume, et le contenu des instantanés de volume

mkdir crd
cd crd
wget https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/client/config/crd/kustomization.yaml
wget https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/client/config/crd/snapshot.storage.k8s.io_volumesnapshotclasses.yaml
wget https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/client/config/crd/snapshot.storage.k8s.io_volumesnapshotcontents.yaml
wget https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/client/config/crd/snapshot.storage.k8s.io_volumesnapshots.yaml
kubectl apply -k ../crd

RBAC, tel que ClusterRole et ClusterRoleBinding

kubectl apply -f https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/deploy/kubernetes/snapshot-controller/rbac-snapshot-controller.yaml

déploiement du contrôleur

kubectl apply -f https://raw.githubusercontent.com/kubernetes-csi/external-snapshotter/master/deploy/kubernetes/snapshot-controller/setup-snapshot-controller.yaml

3.    Créez votre rôle IAM dans le plugin Amazon EBS CSI à l'aide de eksctl :

eksctl create iamserviceaccount \
  --name ebs-csi-controller-sa \
  --namespace kube-system \
  --cluster cluster_name \
  --attach-policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
  --approve \
  --role-only \
  --role-name AmazonEKS_EBS_CSI_DriverRole

4.    Ajoutez le module complémentaire Amazon EBS CSI à l'aide de eksctl :

eksctl create addon --name aws-ebs-csi-driver --cluster cluster_name --service-account-role-arn arn:aws:iam::account_id:role/AmazonEKS_EBS_CSI_DriverRole --force

Remarque : remplacez account_id par l'ID de votre compte AWS.

5.    Vérifiez que le pilote Amazon EBS CSI et les modules de snapshotter externes sont en cours d'exécution :

% kubectl get pods -A | egrep "csi|snapshot"

Création d'un StatefulSet avec le stockage persistant Amazon EBS

1.    Téléchargez les manifestes depuis le site Web de GitHub.

2.    Créez la classe StorageClass et la classe VolumeSnapshotClass :

% kubectl apply -f manifests/classes/

Exemple de sortie :

volumesnapshotclass.snapshot.storage.k8s.io/csi-aws-vsc created
storageclass.storage.k8s.io/ebs-sc created

3.    Déployez le StatefulSet sur votre cluster avec le PersistentVolumeClaim :

% kubectl apply -f manifests/app/

Exemple de sortie :

service/cassandra created
StatefulSet.apps/cassandra created

4.    Vérifiez que les pods ont le statut En cours d'exécution :

% kubectl get pods

Exemple de sortie :

NAME         READY  STATUS   RESTARTS  AGE
cassandra-0  1/1    Running  0         33m
cassandra-1  1/1    Running  0         32m
cassandra-2  1/1    Running  0         30m

5.    Vérifiez que le PersistenVolumeClaim est lié à votre PersisentVolume :

% kubectl get pvc

Exemple de sortie :

NAME                                              STATUS  VOLUME                                    CAPACITY ACCESS MODES STORAGECLASS  AGE

persistentvolumeclaim/cassandra-data-cassandra-0  Bound   pvc-b3ab4971-37dd-48d8-9f59-8c64bb65b2c8  2Gi      RWO          ebs-sc        28m
persistentvolumeclaim/cassandra-data-cassandra-1  Bound   pvc-6d68170e-2e51-40f4-be52-430790684e51  2Gi      RWO          ebs-sc        28m
persistentvolumeclaim/cassandra-data-cassandra-2  Bound   pvc-d0403adb-1a6f-44b0-9e7f-a367ad7b7353  2Gi      RWO          ebs-sc        26m
...

Remarque : Notez les noms de chaque PersistentVolumeClaim à comparer aux noms de PersistentVolumeClaim dans le manifeste des instantanés.

6.    Pour tester le StatefulSet, écrivez du contenu dans le PersistentVolumeClaim :

for i in {0..2}; do kubectl exec "cassandra-$i" -- sh -c 'echo "$(hostname)" > /cassandra_data/data/file.txt'; done

Créer un instantané

Le PersistentVolumeClaimName dans le manifeste du snapshot doit correspondre au nom du PersistentVolumeClaim que vous avez créé pour chaque espace du StatefulSet. Par exemple :

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: cassandra-data-snapshot-0
spec:
  volumeSnapshotClassName: csi-aws-vsc
  source:
    persistentVolumeClaimName: cassandra-data-cassandra-0

1.    Créez un instantané à partir de chaque réclamation de PersistenVolumeClaim :

% kubectl apply -f manifests/snapshot/

Exemple de sortie :

volumesnapshot.snapshot.storage.k8s.io/cassandra-data-snapshot-0 created
volumesnapshot.snapshot.storage.k8s.io/cassandra-data-snapshot-1 created
volumesnapshot.snapshot.storage.k8s.io/cassandra-data-snapshot-2 created

2.    Une fois l'état terminé, vérifiez que les instantanés sont disponibles sur la console Amazon Elastic Compute Cloud (Amazon EC2) :

aws ec2 describe-snapshots --filters "Name=tag-key,Values=*ebs*" --query 'Snapshots[*].{VOL_ID:VolumeId,SnapshotID:SnapshotId,State:State,Size:VolumeSize,Name:[Tags[?Key==`Name`].Value] [0][0]}' --output table
---------------------------------------------------------------------------------------------------------------------------------------
|                                                          DescribeSnapshots                                                          |
+------------------------------------------------------------+-------+-------------------------+------------+-------------------------+
|                            Name                            | Size  |       SnapshotID        |   State    |         VOL_ID          |
+------------------------------------------------------------+-------+-------------------------+------------+-------------------------+
|  ebs-dynamic-snapshot-c6c9cb3c-2dab-4833-9124-40a0abde170d |  2    |  snap-057c5e2de3957d855 |  pending   |  vol-01edf53ee26a615f5  |
|  ebs-dynamic-snapshot-1c1ad0c5-a93a-468f-ab54-576db5d630d4 |  2    |  snap-02bf49a3b78ebf194 |  completed |  vol-0289efe54525dca4a  |
|  ebs-dynamic-snapshot-760c48e7-33ff-4b83-a6fb-6ef13b8d31b7 |  2    |  snap-0101c3d2efa40af19 |  completed |  vol-0fe68c9ac2f6375a4  |
+------------------------------------------------------------+-------+-------------------------+------------+-------------------------+

Restaurez l'instantané

Vous pouvez restaurer un PersistentVolumeClaim à partir d'un instantané créé à partir d'un PersistentVolumeClaim existant sous le même nom que PersistentVolumeClaim. Lorsque vous recréez le StatefulSet, le PersistentVolumeClaim provisionne dynamiquement un PersistentVolume et est automatiquement lié aux modules StatefulSet. Le format du nom StatefulSet PersistenVolumeClaim est le suivant : `PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX`.

Pour restaurer un instantané, procédez comme suit :

1.    Supprimez la charge de travail StatefulSet existante :

kubectl delete -f manifests/app/Cassandra_statefulset.yaml

Remarque : La suppression de la charge de travail entraîne également celle des modules StatefulSet. L'instantané que vous avez créé sert de sauvegarde.

Exemple de sortie :

statefulset.apps "cassandra" deleted

2.    Supprimez de force la réclamation PersistentVolumeClaim :

for i in {0..2}
do
  kubectl delete pvc cassandra-data-cassandra-$i --force
done

Remarque : La suppression du PersistentVolumeClaim supprime également le PersistentVolume.

3.    Restaurez le PersistentVolumeClaim à partir de l'instantané en utilisant le même nom que le PersistentVolumeClaim que vous avez créé :

kubectl apply -f manifests/snapshot-restore/

Exemple de sortie :

persistentvolumeclaim/cassandra-data-cassandra-0 created
persistentvolumeclaim/cassandra-data-cassandra-1 created
persistentvolumeclaim/cassandra-data-cassandra-2 created

4.    Vérifiez que chaque réclamation de PersistentVolumeClaim est en attente :

kubectl get pvc

Exemple de sortie :

NAME                         STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
cassandra-data-cassandra-0   Pending                                      ebs-sc         24s
cassandra-data-cassandra-1   Pending                                      ebs-sc         23s
cassandra-data-cassandra-2   Pending                                      ebs-sc         22s

5.    Recréez le StatefulSet avec le manifeste d'origine :

kubectl apply -f manifests/app-restore/

Remarque : Pour redimensionner le stockage, définissez le StatefulSet avec une nouvelle taille de stockage.

Exemple de sortie :

StatefulSet.apps/cassandra created

6.    Vérifiez le contenu du stockage Amazon EBS pour vérifier que l'instantané et la restauration fonctionnent :

for i in {0..2}; do kubectl exec "cassandra-$i" -- sh -c 'cat /cassandra_data/data/file.txt'; done
cassandra-0
cassandra-1
cassandra-2

Redimensionner la réclamation PersistentVolumeClaim

Vous pouvez modifier le fichier .spec.resources.requests.storage du fichier PersistentVolumeClaim pour qu'il reflète automatiquement la taille que vous avez définie dans le manifeste StatefulSet :

for i in {0..2}
do
  echo "Resizing cassandra-$i"
  kubectl patch pvc cassandra-data-cassandra-$i -p '{ "spec": { "resources": { "requests": { "storage": "4Gi" }}}}'
done

Remarque : 4Gi est un exemple de taille de stockage. Définissez une taille de stockage adaptée à votre cas d'utilisation.

Vérifiez que la nouvelle taille de stockage est reflétée sur la console Amazon EC2 et dans les modules :

% aws ec2 describe-volumes --filters "Name=tag-key,Values=*pvc*" --query 'Volumes[*].{ID:VolumeId,Size:Size,Name:[Tags[?Key==`Name`].Value] [0][0]}' --output table
-------------------------------------------------------------------------------------------
|                                     DescribeVolumes                                     |
+------------------------+--------------------------------------------------------+-------+
|           ID           |                         Name                           | Size  |
+------------------------+--------------------------------------------------------+-------+
|  vol-01266a5f1f8453e06 |  ebs-dynamic-pvc-359a87f6-b584-49fa-8dd9-e724596b2b43  |  4    |
|  vol-01b63a941450342d9 |  ebs-dynamic-pvc-bcc6f2cd-383d-429d-b75f-846e341d6ab2  |  4    |
|  vol-041486ec92d4640af |  ebs-dynamic-pvc-fa99a595-84b7-49ad-b9c2-1be296e7f1ce  |  4    |
+------------------------+--------------------------------------------------------+-------+

% for i in {0..2}
do
  echo "Inspecting cassandra-$i"
  kubectl exec -it cassandra-$i -- lsblk
  kubectl exec -it cassandra-$i -- df -h
done...

Exécutez les commandes Kubectl suivantes pour nettoyer votre StatefulSet

Pour supprimer les ressources que vous avez créées pour votre StatefulSet, exécutez les commandes kubectl suivantes :

restauration d'applications

kubectl delete -f manifests/app-restore

restauration d'instantanés

kubectl delete -f manifests/snapshot-restore

instantané

kubectl delete -f manifests/snapshot

des objets

kubectl delete -f manifests/classes

Cassandra

kubectl delete -f manifests/app/Cassandra_service.yaml

Cet article vous a-t-il été utile?


Besoin d'aide pour une question technique ou de facturation ?