AWS re:Post Knowledge Center Feedback Survey

Help us improve the AWS re:Post Knowledge Center by sharing your feedback in a brief survey. Your input can influence how we create and update our content to better support your AWS journey.

Wie verwende ich persistenten Speicher in Amazon EKS?

Lesedauer: 7 Minute

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

Kurzbeschreibung

Um persistenten Speicher in Amazon EKS zu verwenden, führe die Schritte für eine der folgenden Optionen aus:

Amazon Elastic Block Store (Amazon EBS) Container Storage Interface (CSI)-Treiber.
Stelle den Amazon Elastic File System (Amazon EFS)-CSI-Treiber bereit und teste ihn.

Hinweis: Aus Sicherheits- und Effizienzgründen empfiehlt es sich, den CSI-Treiber über ein Amazon EKS-Add-on zu installieren. Es hat sich auch bewährt, die neueste Version der Treiber zu installieren. Installationsschritte und die neueste Treiberversion findest du unter aws-ebs-csi-driver oder aws-efs-csi-driver auf der GitHub-Website.

Lösung

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version von AWS CLI verwendest.

Voraussetzungen:

Richte eine kubectl-Version ein, die mit deiner Kubernetes-Version übereinstimmt. Informationen zu den Anforderungen an den Versionsversatz findest du unter kubectl auf der Kubernetes-Website.
Installiere oder aktualisiere eksctl. Anweisungen findest du unter Installation auf der eksctl-Website.
Richte die Berechtigungen zum Erstellen für AWS Identity and Access Management (IAM) ein. Hänge dann die Richtlinie an die CSI-Treiberrolle oder an die Amazon EKS-Worker-Knotenrolle an.
Erstelle deinen Amazon-EKS-Cluster und verbinde dann deine Worker-Knoten mit dem Cluster. Führe den folgenden Befehl aus, um zu überprüfen, ob du deine Worker-Knoten an deinen Cluster angehängt hast:
```
kubectl get nodes
```

Um zu überprüfen, ob ein IAM OpenID Connect (OIDC)-Anbieter für deinen Cluster vorhanden ist, führe den folgenden describe-cluster-AWS-CLI-Befehl aus:

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

Hinweis: Ersetze your_cluster_name durch deinen Clusternamen.

Um zu überprüfen, ob du deinen IAM-OIDC-Anbieter konfiguriert hast, führe den folgenden list-open-id-connect-providers-Befehl aus:
```
aws iam list-open-id-connect-providers | grep OIDC-ID
```
Hinweis: Ersetze OIDC-ID durch deine OIDC-Anbieter-ID. Wenn du eine -Fehlermeldung erhältst, erstelle einen IAM-OIDC-Anbieter"No OpenIDConnect provider found in your account".

Amazon-EBS-CSI-Treiber

Gehe wie folgt vor, um den Amazon EBS-CSI-Treiber bereitzustellen:

Erstelle eine IAM-Trust-Policy-Datei, die dem folgenden Beispiel ähnelt:

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

Hinweis: Ersetze YOUR_AWS_ACCOUNT_ID durch deine AWS-Konto-ID, YOUR_AWS_REGION durch deine AWS-Region und OIDC-ID durch deine OIDC-Anbieter-ID.

Führe den folgenden create-role-Befehl aus, um eine IAM-Rolle mit dem Namen AmazonEKS_EBS_CSI_DriverRole zu erstellen:

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

Um die von AWS verwaltete IAM-Richtlinie des CSI-Treibers an die IAM-Rolle anzuhängen, führe den folgenden attach-role-policy-Befehl aus:

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

Du kannst den Amazon-EBS-CSI-Treiber mithilfe von Kustomize, Helm oder einem von Amazon EKS verwalteten Add-On bereitstellen. Anweisungen zur Bereitstellung findest du unter Installation auf der GitHub-Website.
Teste deinen Amazon-EBS-CSI-Treiber mit einer Beispielanwendung, die dynamische Bereitstellung für die Pods verwendet. Der Amazon EBS-CSI-Treiber stellt EBS-Volumes bei Bedarf bereit.

Amazon-EFS-CSI-Treiber

Erstellen einer IAM-Rolle für den CSI-Treiber

Führe die folgenden Schritte für einen Cluster mit Worker-Knoten aus:

Informationen zur Verwendung der AmazonEFSCSIDriverPolicy findest du unter Bei Verwendung von IAM-Rollen für Servicekonten. Fahre dann mit Schritt 7 fort.
Oder führe den folgenden Befehl aus, um das IAM-Richtliniendokument von GitHub herunterzuladen:

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

Um eine IAM-Richtlinie zu erstellen, führe den folgenden create-policy-Befehl aus:

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

Um die OIDC-Anbieter-ID deines Clusters zu ermitteln, führe folgenden describe-cluster-Befehl aus:

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

Hinweis: Ersetze your_cluster_name durch deinen Clusternamen.

Erstelle die folgende IAM-Vertrauensrichtlinie, die deinem Kubernetes-Servicekonto die AssumeRoleWithWebIdentity-Aktion gewährt:

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

Hinweis: Ersetze YOUR_AWS_ACCOUNT_ID durch deine Konto-ID, YOUR_AWS_REGION durch deine Region und OIDC-ID durch die OIDC-Anbieter-ID deines Clusters.

Um eine IAM-Rolle zu erstellen, führe den folgenden create-role-Befehl aus:

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

Um deine neue IAM-Richtlinie an die Rolle anzuhängen, führe den folgenden attach-role-policy-Befehl aus:

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

Hinweis: Ersetze YOUR_AWS_ACCOUNT_ID durch deine Konto-ID.

Wenn du ein verwaltetes Add-on verwendest, fahre mit Bereitstellen des Amazon-EFS-CSI-Treibers fort. Führe die Schritte 7 bis 10 aus, um einen selbstverwalteten Treiber zu installieren. Speichere den folgenden Inhalt in einer YAML-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

Hinweis: Ersetze YOUR_AWS_ACCOUNT_ID durch deine Konto-ID.

Führe den folgenden Befehl aus, um das Kubernetes-Servicekonto in deinem Cluster zu erstellen:
```
kubectl apply -f efs-service-account.yaml
```
Hinweis: Das Kubernetes-Servicekonto efs-csi-controller-sa enthält die Anmerkung der IAM-Rolle, die du erstellt hast.
Führe den folgenden Befehl aus, um das Manifest aus der öffentlichen Amazon Elastic Container Registry (Amazon ECR)-Registrierung herunterzuladen:
```
kubectl kustomize "github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/?ref=release-VERSION" > public-ecr-driver.yaml
```
Hinweis: Ersetze VERSION durch deine Release-Versionsnummer. Es hat sich bewährt, die neueste veröffentlichte Version zu verwenden. Eine Liste der aktiven Zweige findest du unter Zweige auf der GitHub-Website. Du kannst Helm anstelle von Kustomize verwenden, um den Treiber zu installieren. Eine Anleitung dazu findest du unter Bereitstellen des Treibers auf der GitHub-Website.
Bearbeite die heruntergeladene Datei, um die folgenden Zeilen zu entfernen:

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

Hinweis: Du musst die vorangegangenen Zeilen nicht einschließen, da du in Schritt 7 bereits ein Dienstkonto erstellt hast.

Bereitstellen des Amazon-EFS-CSI-Treibers

Führe den folgenden Befehl aus, um das Manifest anzuwenden:

kubectl apply -f public-ecr-driver.yaml

Wenn dein Cluster keine Knoten und nur AWS Fargate Pods enthält, führe den folgenden Befehl aus, um den Treiber in allen Regionen bereitzustellen:

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

Erstellen eines EFS-Dateisystems

Führe die folgenden Schritte aus:

Führe den folgenden describe-cluster-Befehl aus, um die Virtual Private Cloud (VPC)-ID deines Amazon EKS-Clusters abzurufen:

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

Hinweis: Ersetze your_cluster_name durch deinen Clusternamen.

Führe den folgenden describe-vpcs-Befehl aus, um den CIDR-Bereich für deinen VPC-Cluster abzurufen:

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

Hinweis: Ersetze YOUR_VPC_ID durch deine VPC-ID.

Um eine Sicherheitsgruppe zu erstellen, die eingehenden NFS-Verkehr (Network File System) zu deinen Amazon EFS-Mount-Punkten zulässt, führe den folgenden create-security-group-Befehl aus:

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

Hinweis: Ersetze YOUR_VPC_ID durch deine VPC-ID. Notiere dir in der Ausgabe den GroupId-Wert.

Damit Ressourcen in deiner VPC mit deinem EFS-Dateisystem kommunizieren können, führe den folgenden authorize-security-group-ingress-Befehl aus, um eine NFS-Regel für eingehenden Datenverkehr hinzuzufügen:

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

Hinweis: Ersetze YOUR_VPC_CIDR durch deine VPC CIDR und sg-abc durch deine Sicherheitsgruppen-ID.

Um ein EFS-Dateisystem für deinen Amazon EKS-Cluster zu erstellen, führe den folgenden create-file-system-Befehl aus:

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

Hinweis: Beachte die FileSystemId.

Um ein Mount-Ziel für Amazon EFS zu erstellen, führe den folgenden create-mount-target-Befehl aus:
```
aws efs create-mount-target --file-system-id FileSystemId --subnet-id SubnetID --security-group sg-abc
```
Hinweis: Ersetze FileSystemId durch deine EFS-Dateisystem-ID, sg-abc durch deine Sicherheitsgruppen-ID und SubnetID durch deine Worker-Knoten-Subnetz-ID. Es hat sich bewährt, den vorherigen Befehl für jede Availability Zone auszuführen, in der deine Worker-Knoten ausgeführt werden. Alle Amazon Elastic Compute Cloud (Amazon EC2)-Instances in den Availability Zones können das Dateisystem nutzen. Um Mount-Ziele in mehreren Subnetzen zu erstellen, führe den Befehl für jede Subnetz-ID aus.