Wie verwende ich persistenten Speicher in Amazon EKS?

Lesedauer: 10 Minute

Ich möchte persistenten Speicher in Amazon Elastic Kubernetes Service (Amazon EKS) verwenden.

Kurzbeschreibung

Verwenden Sie eine der folgenden Optionen, um persistenten Speicher in Amazon EKS einzurichten:

Amazon Elastic Block Store (Amazon EBS)-Container Storage Interface (CSI)-Treiber
Amazon Elastic File System (Amazon EFS)-Container Storage Interface (CSI)-Treiber

Um eine dieser Optionen zu verwenden, führen Sie die Schritte des entsprechenden Abschnitts aus:

Option A: Bereitstellen und Testen des Amazon-EBS-CSI-Treibers
Option B: Bereitstellen und Testen des Amazon-EFS-CSI-Treibers

Die Befehle in diesem Artikel erfordern kubectl Version 1.14 oder eine neuere Version. Führen Sie folgenden Befehl aus, um anzuzeigen, welche Version von kubectl Sie verwenden:

kubectl version --client --short

Hinweis: Es hat sich bewährt, immer die neueste Version der Treiber zu installieren. Weitere Informationen finden Sie in den GitHub-Repositorys für den Amazon-EBS-CSI-Treiber und den Amazon-EFS-CSI-Treiber.

Behebung

**Hinweis:**Wenn Sie beim Ausführen von Befehlen in AWS Command Line Interface (AWS CLI) Fehler erhalten, stellen Sie sicher, dass Sie die neueste Version von AWS CLI verwenden.

Erledigen Sie Folgendes, bevor Sie die Schritte aus einem der Abschnitte ausführen:

Installieren Sie AWS CLI.
Erstellen Sie Berechtigungen in AWS Identity and Access Management (IAM), um eine Richtlinie zu erstellen und an die Amazon-EKS-Worker-Knoten-Rolle CSI Driver Role anzuhängen.
Hinweis:Die Befehle in den folgenden Abschnitten verwenden nicht immer die Variable--region. Wenn Sie**--region** nicht verwenden, greifen die Befehle auf den Standardwert für Ihre AWS-Region zurück. Führen Sie den Befehl „AWS CLI configure“ aus, um den Standardwert zu überprüfen.
Erstellen Sie Ihren Amazon-EKS-Cluster und verbinden Sie Ihre Worker-Knoten mit dem Cluster.
Hinweis: Führen Sie den kubectl-Befehl „get nodes“ aus, um zu überprüfen, ob Ihre Worker-Knoten an Ihren Cluster angeschlossen sind.

Führen Sie folgenden Befehl aus, um zu überprüfen, ob Ihr AWS IAM OpenID Connect (OIDC)-Anbieter für Ihren Cluster existiert:

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

**Hinweis:**Ersetzen Sie your_cluster_name durch Ihren Clusternamen.

Stellen Sie sicher, dass Ihr IAM-OIDC-Anbieter konfiguriert ist:
```
aws iam list-open-id-connect-providers | grep OIDC_PROVIDER_ID
```
**Hinweis:**Ersetzen Sie die ID des OIDC-Anbieters durch Ihre OIDC-ID. Wenn Sie die Fehlermeldung Kein OpenIDConnect-Anbieter in Ihrem Konto gefunden erhalten, müssen Sie einen IAM-OIDC-Anbieter erstellen.
Installieren oder aktualisieren Sie eksctl.

Erstellen Sie einen IAM-OIDC-Anbieter:

eksctl utils associate-iam-oidc-provider --cluster my-cluster --approve

**Hinweis:**Ersetzen Sie my-cluster durch Ihren Clusternamen.

Option A: Bereitstellen und Testen des Amazon-EBS-CSI-Treibers

Stellen Sie den Amazon-EBS-CSI-Treiber bereit:

Erstellen Sie eine IAM-Trust-Policy-Datei, ähnlich dem folgenden Beispiel:

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/YOUR_OIDC ID"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>:aud": "sts.amazonaws.com",
          "oidc.eks.YOUR_AWS_REGION.amazonaws.com/id/<XXXXXXXXXX45D83924220DC4815XXXXX>:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
        }
      }
    }
  ]
}
EOF

Hinweis: Ersetzen Sie YOUR_AWS_ACCOUNT_ID durch Ihre Konto-ID. Ersetzen Sie YOUR_AWS_REGION durch Ihre Region. Ersetzen Sie Ihre OIDC-ID durch die Ausgabe aus der Erstellung Ihres IAM-OIDC-Anbieters.

Erstellen Sie eine IAM-Rolle mit dem Namen Amazon_EBS_CSI_Driver:

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

Hängen Sie die von AWS verwaltete IAM-Richtlinie für den EBS-CSI-Treiber an die eben erstellte IAM-Rolle an:

aws iam attach-role-policy \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--role-name AmazonEKS_EBS_CSI_Driver

Stellen Sie den Amazon-EBS-CSI-Treiber bereit.

aws eks create-addon \
 --cluster-name my-cluster \
 --addon-name aws-ebs-csi-driver \
 --service-account-role-arn arn:aws:iam::
YOUR_AWS_ACCOUNT_ID:role/AmazonEKS_EBS_CSI_DriverRole

**Hinweis:**Ersetzen Sie my-cluster durch Ihren Clusternamen und YOUR_AWS_ACCOUNT_ID durch Ihre Konto-ID.

Sie können den EBS-CSI-Treiber mithilfe von Kustomize, Helm oder einem von Amazon EKS verwalteten Add-On bereitstellen. In diesem Beispiel wird die Add-On-Feature von Amazon EKS verwendet, um den Treiber bereitzustellen. Weitere Informationen finden Sie in der Installationsanleitung für den aws-ebs-csi-Treiber auf GitHub.

Vergewissern Sie sich, dass der EBS-CSI-Treiber erfolgreich installiert wurde:

eksctl get addon --cluster my-cluster | grep ebs

Eine erfolgreiche Installation führt zu folgender Ausgabe:

aws-ebs-csi-driver    v1.20.0-eksbuild.1    ACTIVE    0    arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/AmazonEKS_EBS_CSI_Driver

Testen des Amazon-EBS-CSI-Treibers:

Sie können Ihren Amazon-EBS-CSI-Treiber mit einer Beispielanwendung testen, die dynamische Bereitstellung für die Pods verwendet. Das Amazon-EBS-Volume wird auf Abruf bereitgestellt.

Klonen Sie das aws-ebs-csi-driver-Repository von AWS GitHub:

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

Ändern Sie Ihr Arbeitsverzeichnis in den Ordner, der die Amazon-EBS-Treibertestdateien enthält:

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

Erstellen Sie die zum Testen erforderlichen Kubernetes-Ressourcen:
```
kubectl apply -f manifests/
```
Hinweis: Der kubectl-Befehl erstellt StorageClass, PersistentVolumeClaim (PVC) und Pod. Der Pod verweist auf das PVC. Ein Amazon-EBS-Volume wird nur bereitgestellt, wenn der Pod erstellt wird. Weitere Informationen finden Sie unter Storage classes und PersistentVolumeClaims auf der Kubernetes-Website.

Beschreiben Sie die ebs-sc-Speicherklasse:

kubectl describe storageclass ebs-sc

Beobachten Sie die Pods im Standard-Namespace und warten Sie, bis sich der Status des app-Pods in Wird ausgeführt ändert. Beispiel:
```
kubectl get pods --watch
```
Sehen Sie sich das persistente Volume an, das aufgrund des Pods erstellt wurde, der auf das PVC verweist:
```
kubectl get pv
```
Zeigen Sie Informationen über das persistente Volume an:
```
kubectl describe pv your_pv_name
```
**Hinweis:**Ersetzen Sie your_pv_name durch den Namen des persistenten Volumes, der in Schritt 6 im vorherigen Abschnitt ausgegeben wurde. Der Wert der Eigenschaft Source.VolumeHandle in der Ausgabe ist die ID des physischen Amazon-EBS-Volumes, das in Ihrem Konto erstellt wurde.
Vergewissern Sie sich, dass der Pod Daten auf das Volume schreibt:
```
kubectl exec -it app -- cat /data/out.txt
```
**Hinweis:**Die Befehlsausgabe zeigt das aktuelle Datum und die aktuelle Uhrzeit an, die in der Datei /data/out.txt gespeichert sind. Die Datei enthält den Tag, den Monat, das Datum und die Uhrzeit.

Option B: Bereitstellen und Testen des Amazon-EFS-CSI-Treibers

Erstellen Sie vor der Bereitstellung des CSI-Treibers eine IAM-Rolle, die es dem Servicekonto des CSI-Treibers ermöglicht, Aufrufe an AWS-APIs für Sie zu tätigen.

Laden Sie das IAM-Richtliniendokument von GitHub herunter:

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

Erstellen Sie eine IAM-Richtlinie:

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

Führen Sie folgenden Befehl aus, um die OIDC-Anbieter-URL Ihres Clusters zu ermitteln:

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

**Hinweis:**Ersetzen Sie in Schritt 3 your_cluster_name durch Ihren Clusternamen.

Erstellen Sie die folgende IAM-Vertrauensrichtlinie und genehmigen Sie dann Ihrem Kubernetes-Servicekonto die Aktion AssumeRoleWithWebIdentity:

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

**Hinweis:**Ersetzen Sie in Schritt 4 YOUR_AWS_ACCOUNT_ID durch Ihre Konto-ID. Ersetzen Sie YOUR_AWS_REGION durch Ihre Region. Ersetzen Sie XXXXXXXXXX45D83924220DC4815XXXXX durch den in Schritt 3 ausgegebenen Wert.

Erstellen Sie eine IAM-Rolle:

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

Hängen Sie Ihre neue IAM-Richtlinie an die Rolle an:

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

Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen efs-service-account.yaml.

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

Erstellen Sie das Kubernetes-Servicekonto in Ihrem Cluster. Das Kubernetes-Servicekonto mit dem Namen efs-csi-controller-sa ist mit der IAM-Rolle versehen, die Sie erstellt haben.
```
kubectl apply -f efs-service-account.yaml
```

Installieren Sie den Treiber mithilfe von Images, die in der öffentlichen Amazon-ECR-Registrierung gespeichert sind, indem Sie das Manifest herunterladen:

kubectl kustomize "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/?ref=release-1.5" > public-ecr-driver.yaml

**Hinweis:**Sie können den EFS-CSI-Treiber mithilfe von Helm und Customize mit einer privaten oder öffentlichen AWS-Registry installieren. Weitere Informationen finden Sie in der EFS-CSI-Treiberdokumentation.

Bearbeiten Sie dann die Datei public-ecr-driver.yaml und entfernen Sie das efs-csi-controller-sa-Manifest:

apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app.kubernetes.io/name: aws-efs-csi-driver
  name: efs-csi-controller-sa
  namespace: kube-system

Bereitstellen des Amazon-EFS-CSI-Treibers

Der Amazon-EFS-CSI-Treiber ermöglicht es mehreren Pods, im Modus ReadWriteMany gleichzeitig auf ein Volume zu schreiben.

Um den Amazon-EFS-CSI-Treiber bereitzustellen, verwenden Sie das Manifest:

kubectl apply -f public-ecr-driver.yaml

Wenn Ihr Cluster nur AWS-Fargate-Pods (keine Knoten) enthält, stellen Sie den Treiber mit dem folgenden Befehl bereit (alle Regionen):

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

Erstellen eines Amazon-EFS-Dateisystems

Ermitteln Sie die VPC-ID für Ihren Amazon-EKS-Cluster:

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

**Hinweis:**Ersetzen Sie in Schritt 3 your_cluster_name durch Ihren Clusternamen.

Ermitteln Sie den CIDR-Bereich für Ihren VPC-Cluster:

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

**Hinweis:**Ersetzen Sie in Schritt 4 YOUR_VPC_ID durch die VPC-ID aus Schritt 3 im vorherigen Abschnitt.

Erstellen Sie eine Sicherheitsgruppe, die eingehenden Network File System (NFS)-Traffic für Ihre Amazon-EFS-Mount-Punkte zulässt:

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

**Hinweis:**Ersetzen Sie YOUR_VPC_ID durch die Ausgabe aus Schritt 3 im vorherigen Abschnitt. Speichern Sie die GroupId zur späteren Verwendung.

Fügen Sie eine NFS-Regel für eingehenden Datenverkehr hinzu, damit die Ressourcen in Ihrem VPC mit Ihrem Amazon-EFS-Dateisystem kommunizieren können:
```
aws ec2 authorize-security-group-ingress --group-id sg-xxx --protocol tcp --port 2049 --cidr YOUR_VPC_CIDR
```
**Hinweis:**Ersetzen Sie YOUR_VPC_CIDR durch die Ausgabe aus Schritt 4 im vorherigen Abschnitt. Ersetzen Sie sg-xxx durch die Sicherheitsgruppen-ID aus Schritt 5 im vorherigen Abschnitt.

Erstellen Sie ein Amazon-EFS-Dateisystem für Ihren Amazon-EKS-Cluster:

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

**Hinweis:**Speichern Sie die FileSystemId zur späteren Verwendung.

Führen Sie folgenden Befehl aus, um ein Mount-Ziel für Amazon EFS zu erstellen:
```
aws efs create-mount-target --file-system-id FileSystemId --subnet-id SubnetID --security-group sg-xxx
```
**Wichtig:**Stellen Sie sicher, dass Sie den Befehl für alle Availability Zones mit der SubnetID in der Availability Zone ausführen, in der Ihre Worker-Knoten ausgeführt werden. Ersetzen Sie FileSystemId durch die Ausgabe aus Schritt 7 im vorherigen Abschnitt (Erstellen des Amazon-EFS-Dateisystems). Ersetzen Sie sg-xxx durch die Ausgabe des vorherigen Schritts 5 (Erstellen der Sicherheitsgruppe). Ersetzen Sie SubnetID durch das Subnetz, das von Ihren Worker-Knoten verwendet wird. Um Mount-Ziele in mehreren Subnetzen zu erstellen, müssen Sie den Befehl aus Schritt 8 für jede Subnetz-ID separat ausführen. Es hat sich bewährt, in jeder Availability Zone ein Mount-Ziel zu erstellen, in der Ihre Worker-Knoten laufen.

Hinweis: Sie können Mount-Ziele für alle Availability Zones erstellen, in denen Worker-Knoten gestartet werden. Dann können alle Amazon Elastic Compute Cloud (Amazon EC2)-Instances in der Availability Zone mit dem Mount-Ziel das Dateisystem nutzen.

Das Amazon-EFS-Dateisystem und seine Mount-Ziele sind jetzt aktiv und können von Pods im Cluster verwendet werden.

Testen des Amazon-EFS-CSI-Treibers

Sie können den Amazon-EFS-CSI-Treiber testen, indem Sie zwei Pods bereitstellen, die in dieselbe Datei schreiben.

Klonen Sie das aws-efs-csi-driver-Repository von AWS GitHub:

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

Ändern Sie Ihr Arbeitsverzeichnis in den Ordner, der die Amazon-EFS-CSI-Treibertestdateien enthält:

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

Rufen Sie die zuvor erstellte ID Ihres Amazon-EFS-Dateisystems ab:

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

**Hinweis:**Wenn der Befehl in Schritt 3 mehr als ein Ergebnis liefert, können Sie die Amazon-EFS-Dateisystem-ID verwenden, die Sie zuvor gespeichert haben.

Ersetzen Sie in der Datei specs/pv.yaml den Wert spec.csi.volumeHandle durch Ihre Amazon-EFS-FileSystemId aus den vorherigen Schritten.
Erstellen Sie die zum Testen erforderlichen Kubernetes-Ressourcen:
```
kubectl apply -f specs/
```
**Hinweis:**Der kubectl-Befehl im obigen Schritt 5 erstellt eine Amazon-EFS-Speicherklasse, ein PVC, ein persistentes Volume und zwei Pods (app1 und app2).
Listen Sie die persistenten Volumes im Standard-Namespace auf und suchen Sie nach einem persistenten Volume mit dem Claim default/efs-claim:
```
kubectl get pv efs-pv
```

Beschreiben Sie das persistente Volume:

kubectl describe pv efs-pv

Testen Sie, ob die beiden Pods Daten in die Datei schreiben:

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

Warten Sie ungefähr eine Minute. Die Ausgabe zeigt das aktuelle Datum, das von beiden Pods in /data/out1.txt geschrieben wurde.

Ähnliche Informationen

Problembehandlung bei Amazon EFS

Themen

Behälter

Relevanter Inhalt

Wie behebe ich Probleme mit meinen Amazon EFS-Volume-Mounts in Amazon EKS?
AWS OFFICIALAktualisiert vor einem Jahr
Wie mounte ich ein verschlüsseltes Amazon EFS-Dateisystem auf einen Pod in Amazon EKS?
AWS OFFICIALAktualisiert vor 3 Jahren
Wie behebe ich „Persistent store is full“ (persistenter Speicher ist voll)-Fehler in Amazon MQ for ActiveMQ?
AWS OFFICIALAktualisiert vor 2 Jahren
Wie kann ich in Amazon EKS für die Notfallwiederherstellung einen ständigen EBS-Speicher-Snapshot wiederherstellen, seine Größe ändern oder erstellen, wenn die EBS-Änderungsrate überschritten ist?
AWS OFFICIALAktualisiert vor einem Jahr