Comment utiliser le stockage permanent dans Amazon EKS ?

Date de la dernière mise à jour : 19/07/2021

Je souhaite utiliser le stockage permanent dans Amazon Elastic Kubernetes Service (Amazon EKS).

Brève description

Vous pouvez configurer un stockage permanent dans Amazon EKS en utilisant l'une des options suivantes :

Pour utiliser l'une de ces options, suivez les étapes de l'une des sections suivantes :

  • Option A : déployer et tester le pilote CSI Amazon EBS
  • Option B : déployer et tester le pilote CSI Amazon EFS

Remarque : kubectl version 1.14 ou ultérieure est nécessaire pour les commandes de cet article. Pour voir la version de kubectlque vous utilisez, exécutez la commande suivante :

kubectl version --client --short

Remarque : si vous recevez des erreurs lors de l'exécution de commandes depuis AWS Command Line Interface (AWS CLI), veillez à utiliser la version la plus récente d'AWS CLI.

Résolution

Avant de suivre les étapes de l'une ou l'autre des sections, vous devez :

1.    Installer l'AWS CLI.

2.    Définissez les autorisations AWS Identity and Access Management (IAM) pour créer et attacher une politique au rôle de nœud de travail Amazon EKS Rôle de pilote CSI.

3.    Créez votre cluster Amazon EKS et joignez-y vos nœuds de travail.

Remarque : Pour vérifier que vos nœuds de travail sont attachés à votre cluster, exécutez la commande kubectl get nodes.

Option A : déployer et tester le pilote CSI Amazon EBS

Déployer le pilote CSI Amazon EBS :

1.    Téléchargez un exemple de stratégie IAM avec des autorisations qui permettent à vos nœuds de travail de créer et de modifier des volumes Amazon EBS :

curl -o example-iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-ebs-csi-driver/v0.9.0/docs/example-iam-policy.json

2.    Créez une politique IAM appelée Amazon_EBS_CSI_Pilote :

aws iam create-policy --policy-name AmazonEKS_EBS_CSI_Driver_Policy --policy-document file://example-iam-policy.json

3.    Consultez l'URL du fournisseur OIDC de votre cluster :

aws eks describe-cluster --name your_cluster_name --query "cluster.identity.oidc.issuer" --output text

Remarque : à l'étape 3, remplacez your_cluster_name par le nom de votre cluster.

4.    Créez le fichier de stratégie d'approbation IAM suivant :

cat <<EOF > trust-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:oidc-provider/oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
        }
      }
    }
  ]
}
EOF

Remarque : à l'étape 4, remplacez YOUR_AWS_ACCOUNT_ID par l'ID de votre de compte. Remplacez YOUR_AWS_REGION par votre région AWS. Remplacez XXXXXXXXXX45D83924220DC4815XXXXX par la valeur renvoyée à l'étape 3.

5.    Créez un rôle IAM :

aws iam create-role \
  --role-name AmazonEKS_EBS_CSI_DriverRole \
  --assume-role-policy-document file://"trust-policy.json"

6.    Attachez votre nouvelle stratégie IAM au rôle :

aws iam attach-role-policy \
--policy-arn arn:aws:iam::111122223333:policy/AmazonEKS_EBS_CSI_Driver_Policy \
--role-name AmazonEKS_EBS_CSI_DriverRole

7.    Pour déployer le pilote Amazon EBS CSI, exécutez l'une des commandes suivantes en fonction de votre région :

Toutes les régions autres que les régions de Chine :

kubectl apply -k "github.com/kubernetes-sigs/aws-ebs-csi-driver/deploy/kubernetes/overlays/stable/?ref=master"

Les régions de Chine Beijing et Ningxia :

kubectl apply -k "github.com/kubernetes-sigs/aws-ebs-csi-driver/deploy/kubernetes/overlays/stable-cn/?ref=master"

8.    Annotez le compte de service Kubernetes ebs-csi-controller-sa avec le Amazon Resource Name (ARN) du rôle IAM que vous avez créé précédemment :

kubectl annotate serviceaccount ebs-csi-controller-sa \
  -n kube-system \
  eks.amazonaws.com/role-arn=arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/AmazonEKS_EBS_CSI_DriverRole

Remarque : remplacez YOUR_AWS_ACCOUNT_ID par l'ID de votre compte.

9.    Supprimez les pods du pilote :

kubectl delete pods \
  -n kube-system \
  -l=app=ebs-csi-controller

Remarque : les pods du pilote sont automatiquement redéployés avec les autorisations IAM de la stratégie IAM attribuée au rôle. Pour plus d'informations, consultez Pilote CSI Amazon EBS.

Tester le pilote CSI Amazon EBS :

Vous pouvez tester votre pilote CSI Amazon EBS avec une application qui utilise le provisionnement dynamique. Le volume Amazon EBS est alloué à la demande.

1.    Clonez le référentiel aws-ebs-csi-driver à partir d'AWS GitHub :

git clone https://github.com/kubernetes-sigs/aws-ebs-csi-driver.git

2.    Remplacez votre répertoire de travail par le dossier qui contient les fichiers de test du pilote Amazon EBS :

cd aws-ebs-csi-driver/examples/kubernetes/dynamic-provisioning/

3.    Créez les ressources Kubernetes requises pour les tests :

kubectl apply -f specs/

Remarque : la commande kubectl crée un StorageClass (à partir du site web de Kubernetes), un PersistentVolumeClaim (PVC) (à partir du site web Kubernetes) et un pod. Le pod fait référence au PVC. Un volume Amazon EBS est mis en service uniquement lorsque le pod est créé.

4.    Décrivez la classe de stockage ebs-sc :

kubectl describe storageclass ebs-sc

5.    Regardez les pods dans l'espace de noms par défaut et attendez que le statut du pod d'application passe à Running (En cours d'exécution). Par exemple :

kubectl get pods --watch

6.    Affichez le volume persistant créé à cause du pod qui référence le PVC :

kubectl get pv

7.    Affichez les informations sur le volume persistant :

kubectl describe pv your_pv_name

Remarque : remplacez your_pv_name par le nom du volume persistant renvoyé à l'étape 6 précédente. La valeur de la propriété Source.VolumeHandle dans la sortie correspond à l'ID du volume Amazon EBS physique créé dans votre compte.

8.    Vérifiez que le pod écrit des données sur le volume :

kubectl exec -it app -- cat /data/out.txt

Remarque : la sortie de la commande affiche la date et l'heure actuelles stockées dans le fichier /data/out.txt. Le fichier inclut le jour, le mois, la date et l'heure.

Option B : déployer et tester le pilote CSI Amazon EFS

Avant de déployer le pilote CSI, créez un rôle IAM qui permet au compte de service du pilote CSI de passer des appels aux API AWS en votre nom.

1.    Téléchargez le document de stratégie IAM à partir de GitHub :

curl -o iam-policy-example.json https://raw.githubusercontent.com/kubernetes-sigs/aws-efs-csi-driver/v1.2.0/docs/iam-policy-example.json

2.    Créez une stratégie IAM :

aws iam create-policy \
    --policy-name AmazonEKS_EFS_CSI_Driver_Policy \
    --policy-document file://iam-policy-example.json

3.    Annotez le compte de service Kubernetes avec le rôle IAM ARN et le rôle IAM avec le nom du compte de service Kubernetes. Par exemple :

aws eks describe-cluster --name your_cluster_name --query "cluster.identity.oidc.issuer" --output text

Remarque : à l'étape 3, remplacez your_cluster_name par le nom de votre cluster.

4.    Créez la stratégie d'approbation IAM suivante, puis accordez l'action AssumeRoleWithWebIdentity à votre compte de service Kubernetes. Par exemple :

cat <<EOF > trust-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:oidc-provider/oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>:sub": "system:serviceaccount:kube-system:efs-csi-controller-sa"
        }
      }
    }
  ]
}
EOF

Remarque : à l'étape 4, remplacez YOUR_AWS_ACCOUNT_ID par l'ID de votre de compte. Remplacez YOUR_AWS_REGION par votre région. Remplacez XXXXXXXXXX45D83924220DC4815XXXXX par la valeur renvoyée à l'étape 3.

5.    Créez un rôle IAM :

aws iam create-role \
  --role-name AmazonEKS_EFS_CSI_DriverRole \
  --assume-role-policy-document file://"trust-policy.json"

6.    Attachez votre nouvelle stratégie IAM au rôle :

aws iam attach-role-policy \
  --policy-arn arn:aws:iam::<AWS_ACCOUNT_ID>:policy/AmazonEKS_EFS_CSI_Driver_Policy \
  --role-name AmazonEKS_EFS_CSI_DriverRole

7.    Créez un compte de service Kubernetes annoté avec l'ARN du rôle IAM que vous avez créé. Par exemple :

cat << EOF > efs-service-account.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: efs-csi-controller-sa
  namespace: kube-system
  labels:
    app.kubernetes.io/name: aws-efs-csi-driver
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/AmazonEKS_EFS_CSI_DriverRole
EOF

Remarque : remplacez YOUR_AWS_ACCOUNT_ID par l'ID de votre compte.

8.    Appliquez le manifeste :

kubectl apply -f efs-service-account.yaml

Déployer le pilote CSI Amazon EFS :

Le pilote CSI Amazon EFS permet à plusieurs pods d'écrire sur un volume en même temps avec le mode ReadWriteMany.

1.    Pour déployer le pilote CSI Amazon EFS, exécutez l'une des commandes suivantes en fonction de votre région ou du type de cluster :

Toutes les régions autres que les régions de Chine :

kubectl apply -k "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/ecr/?ref=release-1.1"

Les régions de Chine Beijing et Ningxia :

kubectl apply -k "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/?ref=release-1.1"

Si votre cluster ne contient que des pods AWS Fargate (pas de nœuds), déployez alors le pilote avec la commande suivante (toutes les régions) :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-efs-csi-driver/master/deploy/kubernetes/base/csidriver.yaml

2.    Obtenez l'ID VPC de votre cluster Amazon EKS :

aws eks describe-cluster --name your_cluster_name --query "cluster.resourcesVpcConfig.vpcId" --output text

Remarque : à l'étape 2, remplacez your_cluster_name par le nom de votre cluster.

3.    Obtenez la plage d'adresses CIDR pour votre cluster VPC :

aws ec2 describe-vpcs --vpc-ids YOUR_VPC_ID --query "Vpcs[].CidrBlock" --output text

Remarque : à l'étape 3, remplacez YOUR_VPC_ID par l'ID VPC de l'étape 2 précédente.

4.    Créez un groupe de sécurité qui autorise le trafic NFS (Network File System) entrant pour vos points de montage Amazon EFS :

aws ec2 create-security-group --description efs-test-sg --group-name efs-sg --vpc-id YOUR_VPC_ID

Remarque : remplacez YOUR_VPC_ID par la sortie de l'étape 2 précédente. Enregistrez le GroupId pour plus tard.

5.    Ajoutez une règle NFS entrante pour que les ressources de votre VPC puissent communiquer avec votre système de fichiers Amazon EFS :

aws ec2 authorize-security-group-ingress --group-id sg-xxx --protocol tcp --port 2049 --cidr YOUR_VPC_CIDR

Remarque : remplacez YOUR_VPC_CIDR par la sortie de l'étape 3 précédente. Remplacez sg-xxx par l'ID du groupe de sécurité de l'étape 4 précédente.

6.    Créez un système de fichiers Amazon EFS pour votre cluster Amazon EKS :

aws efs create-file-system --creation-token eks-efs

Remarque : enregistrez le FileSystemId pour une utilisation ultérieure.

7.    Pour créer une cible de montage pour Amazon EFS, exécutez la commande suivante :

aws efs create-mount-target --file-system-id FileSystemId --subnet-id SubnetID --security-group sg-xxx

Important : assurez-vous d'exécuter la commande pour toutes les zones de disponibilité avec le SubnetID dans la zone de disponibilité où se trouvent vos nœuds de travail. Remplacez FileSystemId par la sortie de l'étape 6 précédente (où vous avez créé le système de fichiers Amazon EFS). Remplacez sg-xxx par la sortie de l'étape 4 précédente (où vous avez créé le groupe de sécurité). Remplacez SubnetID par le sous-réseau utilisé par vos nœuds de travail. Pour créer des cibles de montage dans plusieurs sous-réseaux, vous devez exécuter la commande de l'étape 7 séparément pour chaque ID de sous-réseau. Il est recommandé de créer une cible de montage dans chaque zone de disponibilité où vos nœuds de travail sont en cours d'exécution.

Remarque : vous pouvez créer des cibles de montage pour toutes les zones de disponibilité dans lesquelles les nœuds de travail sont lancés. Ensuite, toutes les instances Amazon Elastic Compute Cloud (Amazon EC2) de la zone de disponibilité disposant de la cible de montage peuvent utiliser le système de fichiers.

Le système de fichiers Amazon EFS et ses cibles de montage sont désormais en cours d'exécution et prêts à être utilisés par les pods du cluster.

Tester le pilote CSI Amazon EFS :

Vous pouvez tester le pilote CSI Amazon EFS en déployant deux pods qui écrivent dans le même fichier.

1.    Clonez le référentiel aws-efs-csi-driver à partir d'AWS GitHub :

git clone https://github.com/kubernetes-sigs/aws-efs-csi-driver.git

2.    Remplacez votre répertoire de travail par le dossier qui contient les fichiers de test du pilote CSI Amazon EFS :

cd aws-efs-csi-driver/examples/kubernetes/multiple_pods/

3.    Récupérez votre ID de système de fichiers Amazon EFS créé précédemment :

aws efs describe-file-systems --query "FileSystems[*].FileSystemId" --output text

Remarque : si la commande de l'étape 3 renvoie plusieurs résultats, vous pouvez utiliser l'ID de système de fichiers Amazon EFS que vous avez enregistré précédemment.

4.    Dans le fichier specs/pv.yaml, remplacez la valeur spec.sci.volumeHandle par le FileSystemId Amazon EFS des étapes précédentes.

5.    Créez les ressources Kubernetes requises pour les tests :

kubectl apply -f specs/

Remarque : la commande kubectl de l'étape 5 précédente créee une classe de stockage Amazon EFS, un PVC, un volume persistant et deux pods (app1 et app2).

6.    Listez les volumes persistants dans l'espace de noms par défaut, et recherchez un volume persistant avec l'enregistrement default/efs-claim :

kubectl get pv -w

7.    Décrivez le volume persistant :

kubectl describe pv efs-pv

8.    Testez si les deux pods sont en train d'écrire des données dans le fichier :

kubectl exec -it app1 -- tail /data/out1.txt 
kubectl exec -it app2 -- tail /data/out1.txt

Attendez environ une minute. La sortie montre la date actuelle écrite dans /data/out1.txt par les deux pods.


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


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