Einrichten von Amazon EKS mit EFS

Bevor Sie Dynamic Engine und ihre Umgebungen bereitstellen, richten Sie einen Amazon EKS-Cluster mit Amazon Elastic File System (EFS) als freigegebenes Speicher-Backend ein.

Vorbereitungen

Ein AWS-Konto mit den erforderlichen IAM-Berechtigungen. Die vollständige Liste finden Sie unter Konfigurieren von Amazon EKS für die Dynamic Engine-Bereitstellung.

Warum und wann dieser Vorgang ausgeführt wird

Mit diesem Verfahren werden ein neuer EKS-Cluster in einer dedizierten Virtual Private Cloud (einer Amazon VPC) erstellt, EFS-Mount-Ziele über Verfügbarkeitszonen hinweg konfiguriert und der EFS CSI-Treiber (Container Storage Interface) installiert. Mit dem Verfahren wird auch eine Speicherklasse erstellt, die Ihr EFS-Dateisystem referenziert und Zugriffspunkte verwendet, um persistente Volumes dynamisch bereitzustellen.

Prozedur

Legen Sie die Umgebungsvariablen für Ihre AWS EKS- und EFS-Bereitstellung fest:

Example

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

Erstellen Sie die EKS-Clusterkonfigurationsdatei, um einen EKS-Cluster mit für die Dynamic Engine-Umgebung optimierter Infrastruktur bereitzustellen.
```
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
```
Diese Konfiguration:
- Gibt die Region und den Namen des EKS-Clusters und die zu verwendende Kubernetes-Version an (in diesem Beispiel 1.34).
- Deaktiviert den automatischen EKS-Modus, um eine Standard-Knotengruppenverwaltung sicherzustellen.
- Installiert zwei Add-Ons, die von Dynamic Engine für die Ausführung auf EFS benötigt werden: aws-efs-csi-driver, der EFS-Volumes sicher in Pods mountet und eks-pod-identity-agent, der die Dynamic Engine-Pods die IAM-Rolle annehmen lässt, die für den Zugriff auf EFS ohne hartcodierte Anmeldedaten benötigt wird.
- Erstellt eine VPC und platziert alle Knoten in privaten Subnetzen (privateNetworking: true), was für Dynamic Engine erforderlich ist. Die Knoten erreichen das Internet nur über NAT-Gateways, um Dynamic Engine-Container-Images abzurufen. Der Cluster-Endpunkt bleibt sowohl von der lokalen Maschine als auch innerhalb der VPC erreichbar.
- Stellt Knoten in der passenden Größe für Dynamic Engine-Arbeitslasten bereit. Jeder Knoten hat 4 vCPUs und 16 GiB RAM. Die AMD64-Architektur (cpuArchitecture: amd64) ist erforderlich, weil Dynamic Engine-Container-Images nur für AMD64 erstellt werden.
Erstellen Sie den EKS-Cluster, verknüpfen Sie das lokale kubectl-Tool mit dem EKS-Cluster und überprüfen Sie die Erreichbarkeit des Clusters:
```
eksctl create cluster -f eks-config.yaml
aws eks update-kubeconfig --region "$AWS_REGION" --name "$EKS_CLUSTER_NAME"
kubectl get nodes
```
Warten Sie vor dem Fortfahren, bis alle Knoten den Status Bereit erreicht haben.

Führen Sie das folgende Skript aus, um die VPC-ID und die Subnetz-IDs abzurufen:

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"

Erstellen Sie eine EFS-Sicherheitsgruppe, die von den EKS-Knoten aus zugänglich ist.

Rufen Sie die ID der EKS-Knoten-Sicherheitsgruppe ab:

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"

Erstellen Sie eine EFS-Sicherheitsgruppe.

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)

Gewähren Sie der Knoten-Sicherheitsgruppe Zugriff auf die EFS-Sicherheitsgruppe.

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

Erstellen Sie das EFS-Dateisystem:

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"

Erstellen Sie Mount-Ziele in jedem privaten Subnetz:

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

Warten Sie, bis die Mount-Ziele verfügbar werden. Überprüfen Sie den Status mit:

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

Die Mount-Ziele in jedem Subnetz ermöglichen es den Knoten im Subnetz, EFS zu erreichen.

Erstellen Sie eine Speicherklasse, die es Dynamic Engine ermöglicht, EFS-Volumes dynamisch bereitzustellen:
1. Erstellen Sie die Konfigurationsdatei für die Speicherklasse.
  Example
```
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: Aktiviert den EFS-Zugriffspunkt-Modus. Jeder PersistentVolumeClaim wird von einem dedizierten EFS-Zugriffspunkt unterstützt, was POSIX-Eigentümerschaft erzwingt und den Verzeichniszugriff pro Volume isoliert.
  - fileSystemId: ${EFS_ID}: Dieser Wert muss mit der EFS-Dateisystem-ID übereinstimmen, die in Schritt 6 erstellt wurde.
  - gidRangeStart: "1000" und gidRangeEnd: "65534": Dieser Gruppen-ID-Bereich steuert, welche POSIX-Gruppen auf EFS-Volumes zugreifen können. Dynamic Engine wird standardmäßig mit der Gruppen-ID 61000 ausgeführt, die in diesen Bereich fallen muss (1000–65534). Wenn die Gruppen-ID außerhalb dieses Bereichs fällt, erhalten Pods „permission-denied“-Fehler, wenn sie auf EFS-Volumes zugreifen.
    InformationshinweisWichtig: Wenn Pods aufgrund von „Berechtigung verweigert“-Fehlern nicht auf EFS-Volumes gemountet werden können, prüfen Sie, ob sich die Gruppen-ID des Dynamic Engine-Pods (61000) innerhalb der gidRange-Einstellungen befindet. Unter Fehlerbehebung für Berechtigungsfehler beim Zugriff auf EFS-Volumes in Pods auf Amazon EKS finden Sie detaillierte Diagnoseschritte.
  Weitere Informationen zu einer Kubernetes-Speicherklasse finden Sie unter AWS EFS.
2. Erstellen Sie die Speicherklasse:
```
kubectl apply -f efs-storageclass.yaml
```

Testen Sie die Speicherklasse.

Erstellen Sie für diesen Test einen PVC und einen Pod.

Example

Der PVC fordert Speicher mit der dyn-engine-Speicherklasse an und der Pod mountet das Volume, bevor er Testdaten darin schreibt.

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

Wenden Sie die Datei an:
```
kubectl apply -f efs-pvc-pod.yaml
```

Die Datei /data/out wird erstellt. Sie enthält UTC-Zeitstempel.

Ergebnisse

Der EKS-Cluster und seine EFS-Speicherklasse sind für Dynamic Engine und ihre Umgebungen bereit.

Nächste Maßnahme

Stellen Sie Dynamic Engine und ihre Umgebungen auf dem EKS-Cluster bereit, den Sie in diesem Verfahren konfiguriert haben, und geben Sie die in diesem Verfahren erstellte Speicherklasse an.

Detaillierte Anweisungen finden Sie unter Bereitstellung einer Speicherklasse, die auf Dynamic Engine-Umgebungsdienste spezialisiert ist. Diese Anweisungen gelten für alle unterstützten Plattformen, einschließlich Amazon EKS, Google GKE und lokales Kubernetes.

Tipp:

Um die Testinfrastruktur zu bereinigen, löschen Sie die Ressourcen in der folgenden Reihenfolge:

Löschen Sie den EKS-Cluster:

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

Löschen Sie die EFS-Mount-Ziele, bevor Sie das Dateisystem und seine Sicherheitsgruppe löschen:

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"

Diese Angaben werden zu Ihrer Information bereitgestellt und können von Amazon geändert werden. Konsultieren Sie die Amazon-Dokumentation für Details zum Löschen von EKS und EFS.

Hat diese Seite Ihnen geholfen?

Wenn Sie ein Problem mit dieser Seite oder ihrem Inhalt feststellen, sei es ein Tippfehler, ein ausgelassener Schritt oder ein technischer Fehler, informieren Sie uns bitte!

Geben Sie hier Ihr Feedback ab