Configurer Amazon EKS avec EFS

Avant de déployer Dynamic Engine et ses environnements, configurez un cluster Amazon EKS avec Amazon Elastic File System (EFS) comme back-end de stockage partagé.

Avant de commencer

Un compte AWS avec les autorisations IAM requises. Pour la liste complète, consultez Configurer Amazon EKS pour un déploiement Dynamic Engine.

Pourquoi et quand exécuter cette tâche

Cette procédure crée un nouveau cluster EKS dans un cloud privé virtuel dédié (un VPC Amazon), configure des cibles de montage EFS dans des Zones de disponibilité et installe le pilote EFS CSI (Container Storage Interface). La procédure crée également une classe de stockage qui référence votre système de fichiers EFS et utilise des points d'accès pour provisionner dynamiquement des volumes persistants.

Procédure

Définissez des variables d'environnement pour votre déploiement AWS EKS et EFS :

Exemple

export AWS_REGION=<your-aws-region>
export EKS_CLUSTER_NAME=<your-eks-cluster-name>
export EFS_NAME=<your-efs-filesystem-name>

Créez le fichier de configuration du cluster EKS pour déployer un cluster EKS avec une infrastructure optimisée pour l'environnement Dynamic Engine :
```
cat <<EOF > eks-config.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: ${EKS_CLUSTER_NAME}
  region: ${AWS_REGION}
  version: "1.34"

autoModeConfig:
  enabled: false

addonsConfig:
  autoApplyPodIdentityAssociations: true

addons:
  - name: eks-pod-identity-agent
  - name: aws-efs-csi-driver
    
vpc:
  cidr: 10.10.0.0/16
  autoAllocateIPv6: false
  hostnameType: resource-name
  clusterEndpoints:
    publicAccess: true
    privateAccess: true
  nat:
    gateway: HighlyAvailable

managedNodeGroups:
  - name: ng-amd64
    amiFamily: AmazonLinux2023 # (default) or Bottlerocket
    minSize: 2
    maxSize: 4
    desiredCapacity: 2
    instanceSelector:
      vCPUs: 4
      memory: 16GiB
      cpuArchitecture: amd64
    privateNetworking: true
    
    
EOF
```
Cette configuration :
- Spécifie la région et le nom du cluster EKS et la version de Kubernetes à utiliser (1.34 dans cet exemple).
- Désactive le mode automatique EKS pour garantir une gestion de groupe de nœuds standard.
- Installe deux add-ons que Dynamic Engine doit exécuter sur EFS : aws-efs-csi-driver, qui monte en toute sécurité les volumes EFS sur des pods, et eks-pod-identity-agent, qui permet aux pods Dynamic Engine d'assumer le rôle IAM nécessaire pour accéder à EFS sans identifiants codés en dur.
- Crée un VPC et place tous les nœuds dans des sous-réseaux privés (privateNetworking: true), ce qui est requis par Dynamic Engine. Les nœuds atteignent Internet uniquement via des passerelles NAT pour extraire des images du conteneur Dynamic Engine. L'endpoint du cluster reste accessible depuis votre poste local et au sein du VPC.
- Provisionne des nœuds dimensionnés pour les workloads Dynamic Engine. Chaque nœud a 4 vCPU et une RAM de 16 GiB. L'architecture AMD64 (cpuArchitecture: amd64) est requise, car les images du conteneur Dynamic Engine sont créées pour AMD64 uniquement.
Créez le cluster EKS, liez votre outil kubectl local au cluster EKS et vérifiez l'accessibilité du cluster :
```
eksctl create cluster -f eks-config.yaml
aws eks update-kubeconfig --region "$AWS_REGION" --name "$EKS_CLUSTER_NAME"
kubectl get nodes
```
Attendez que tous les nœuds aient atteint le statut Ready (Prêt) avant de poursuivre.

Exécutez ce script pour récupérer l'ID du VPC et les ID de sous-réseau :

VPC_ID=$(aws eks describe-cluster \
  --region "$AWS_REGION" \
  --name ${EKS_CLUSTER_NAME} \
  --output text \
  --query "cluster.resourcesVpcConfig.vpcId")
echo "VPC_ID=$VPC_ID"

SUBNET_IDS_PRIVATE=$(aws ec2 describe-subnets \
  --region "$AWS_REGION" \
  --filters Name=vpc-id,Values="$VPC_ID" Name=tag:kubernetes.io/role/internal-elb,Values=1 \
  --query "Subnets[*].SubnetId" \
  --output text | sed 's/\t/ /g')
echo "SUBNET_IDS_PRIVATE=$SUBNET_IDS_PRIVATE"

Créez un groupe de sécurité EFS accessible depuis les nœuds EKS.

Obtenez l'ID du groupe de sécurité des nœuds EKS :

NODE_SG_ID=$(aws eks describe-cluster \
   --region "$AWS_REGION" \
   --name "$EKS_CLUSTER_NAME" \
   --query "cluster.resourcesVpcConfig.clusterSecurityGroupId" \
   --output text)
echo "NODE_SG_ID=$NODE_SG_ID"

Créez un groupe de sécurité EFS.

EFS_SG_ID=$(aws ec2 create-security-group \
  --region "$AWS_REGION" \
  --group-name "${EKS_CLUSTER_NAME}-efs-sg" \
  --description "EFS access from EKS" \
  --vpc-id "$VPC_ID" \
  --query "GroupId" \
  --output text)

Accordez au groupe de sécurité des nœuds l'accès au groupe de sécurité EFS.

aws ec2 authorize-security-group-ingress \
  --region "$AWS_REGION" \
  --group-id "$EFS_SG_ID" \
  --protocol tcp \
  --port 2049 \
  --source-group "$NODE_SG_ID"

Créez le système de fichiers EFS :

EFS_ID=$(aws efs create-file-system \
  --region "$AWS_REGION" \
  --creation-token "${EKS_CLUSTER_NAME}-efs" \
  --encrypted \
  --tags Key=Name,Value="${EFS_NAME}" \
  --query "FileSystemId" \
  --output text)

echo "EFS_ID=$EFS_ID"

Créez les cibles de montage dans chaque sous-réseau privé :

for subnet in $(echo "$SUBNET_IDS_PRIVATE" | tr ' ' '\n'); do
  aws efs create-mount-target \
  --region "$AWS_REGION" \
  --file-system-id "$EFS_ID" \
  --subnet-id "$subnet" \
  --security-groups "$EFS_SG_ID"
done

Attendez que les cibles de montage deviennent disponibles. Vérifiez le statut avec :

aws efs describe-mount-targets \
  --region "$AWS_REGION" \
  --file-system-id "$EFS_ID"

Les cibles de montage de chaque sous-réseau autorisent les nœuds de ce sous-réseau à atteindre EFS.

Créez une classe de stockage qui permet à Dynamic Engine de provisionner dynamiquement les volumes EFS :
1. Créez le fichier de configuration de la classe de stockage.
  Exemple
```
cat <<EOF > efs-storageclass.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: dyn-engine
provisioner: efs.csi.aws.com
parameters:
  provisioningMode: efs-ap
  fileSystemId: $EFS_ID
  directoryPerms: "700"
  gidRangeStart: "1000"
  gidRangeEnd: "65534"  
mountOptions:
  - tls
reclaimPolicy: Delete
volumeBindingMode: Immediate

EOF
```
  - provisioningMode: efs-ap : active le mode Point d'accès EFS. Chaque revendication PersistentVolumeClaim est soutenue par un point d'accès EFS dédié, ce qui applique la titularité POSIX et isole l'accès au répertoire par volume.
  - fileSystemId: ${EFS_ID} : cette valeur doit correspondre à l'ID du système de fichiers EFS créé à l'étape 6.
  - gidRangeStart: "1000" et gidRangeEnd: "65534" : cette plage d'ID de groupe détermine les groupes POSIX qui sont autorisés à accéder aux volumes EFS. Dynamic Engine s’exécute avec l'ID de groupe 61000 par défaut, qui doit se trouver dans cette plage (1000–65534). Si l'ID de groupe se trouve en dehors de cette plage, les pods reçoivent des erreurs de refus d'autorisation lorsqu'ils accèdent à des volumes EFS.
    Note InformationsImportant : Si les pods ne parviennent pas à monter de volumes EFS à cause d'erreurs de refus d'autorisation, vérifiez que l'ID de groupe du pod Dynamic Engine (61000) se trouve dans les paramètres gidRange. Pour des étapes de diagnostic détaillées, consultez Résoudre les erreurs relatives aux autorisations lors de l'accès à des volumes EFS dans des pods sur Amazon EKS.
  Pour plus d'informations sur une classe de stockage Kubernetes, consultez AWS EFS (en anglais).
2. Créez la classe de stockage :
```
kubectl apply -f efs-storageclass.yaml
```

Testez la classe de stockage.

Créez un PVC et un pod pour ce test.

Exemple

Le PVC demande le stockage avec la classe de stockage dyn-engine et le pod monte le volume avant d'y écrire les données de test.

cat <<EOF > efs-pvc-pod.yaml
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: efs-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: dyn-engine
  resources:
    requests:
      storage: 100Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: efs-app
spec:
  securityContext:
    fsGroup: 61000
    runAsNonRoot: true
    runAsUser: 61000
    runAsGroup: 61000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: app
      image: ghcr.io/talend/kube-base:5.3.0
      command: ["/bin/sh"]
      args: ["-c", "while true; do echo $(date -u) >> /data/out; sleep 5; done"]
      securityContext:
        allowPrivilegeEscalation: false
      volumeMounts:
        - name: persistent-storage
          mountPath: /data
  volumes:
    - name: persistent-storage
      persistentVolumeClaim:
        claimName: efs-pvc

Appliquez le fichier :
```
kubectl apply -f efs-pvc-pod.yaml
```

Le fichier /data/out est créé et contient des horodatages UTC.

Résultats

Votre cluster EKS et sa classe de stockage EFS sont prêts pour Dynamic Engine et ses environnements.

Que faire ensuite

Déployez Dynamic Engine et ses environnements dans le cluster EKS que vous avez configuré dans cette procédure et spécifiez la classe de stockage que vous avez créée dans cette procédure.

Pour des instructions détaillées, consultez Provisionner une classe de stockage dédiée aux services d'environnements du Dynamic Engine. Ces instructions s'appliquent à toutes les plateformes supportées, y compris Amazon EKS, Google GKE et on-premises Kubernetes.

Conseil :

Pour nettoyer l'infrastructure de test, supprimez les ressources dans cet ordre :

Supprimez le cluster EKS :

eksctl delete cluster --name "$EKS_CLUSTER_NAME" --region "$AWS_REGION"

Supprimez les cibles de montage EFS avant de supprimer le système de fichiers et son groupe de sécurité :

MT_IDS=$(aws efs describe-mount-targets \
  --region "$AWS_REGION" \
  --file-system-id "$EFS_ID" \
  --query "MountTargets[].MountTargetId" \
  --output text)
for mt in $(echo "$MT_IDS" | tr ' ' '\n'); do
  aws efs delete-mount-target --region "$AWS_REGION" --mount-target-id "$mt"
done
aws efs delete-file-system --region "$AWS_REGION" --file-system-id "$EFS_ID"
aws ec2 delete-security-group --region "$AWS_REGION" --group-id "$EFS_SG_ID"

Ces informations sont fournies pour votre commodité et sont susceptibles d'être modifiées par Amazon. Pour des informations détaillées sur la suppression d'EKS et d'EFS, consultez la documentation d'Amazon.

Cette page vous a-t-elle aidé ?

Si vous rencontrez des problèmes sur cette page ou dans son contenu – une faute de frappe, une étape manquante ou une erreur technique – faites-le-nous savoir.

Laissez vos commentaires ici