Come si usa l'archiviazione persistente in Amazon EKS?

11 minuti di lettura
0

Desidero utilizzare l'archiviazione persistente in Amazon Elastic Kubernetes Service (Amazon EKS).

Breve descrizione

Configura l'archiviazione persistente in Amazon EKS utilizzando una delle seguenti opzioni:

Per utilizzare una di queste opzioni, completa i passaggi in ciascuna delle seguenti sezioni:

  • Opzione A: implementa e testa il driver CSI per Amazon EBS
  • Opzione B: implementa e testa il driver CSI per Amazon EFS

I comandi riportati in questo articolo richiedono la versione 1.14 o successiva di kubectl. Per conoscere la tua versione di kubectl, esegui il comando seguente:

kubectl version --client --short

Nota: è consigliabile assicurarsi di aver installato la versione più recente dei driver. Per ulteriori informazioni, consulta i repository GitHub per il driver CSI per Amazon EBS e per il driver CSI per Amazon EFS.

Risoluzione

Nota: se ricevi messaggi di errore durante l'esecuzione dei comandi dell'Interfaccia della linea di comando AWS (AWS CLI), assicurati di utilizzare la versione più recente di AWS CLI.

Prima di completare i passaggi delle due sezioni, è necessario:

  1. Installare AWS CLI.

  2. Impostare le autorizzazioni di AWS Identity and Access Management (IAM) per creare e collegare una policy al ruolo del nodo worker di Amazon EKS Ruolo driver CSI.
    Nota: i comandi nelle sezioni seguenti non utilizzano sempre la variabile --region. Se non usi --region, i comandi utilizzeranno il valore predefinito per la tua Regione AWS. Esegui il comando AWS CLI configure per verificare il valore predefinito.

  3. Crea il tuo cluster Amazon EKS e unisci i nodi worker al cluster.
    Nota: esegui il comando get nodes di kubectl per verificare che i nodi worker siano collegati al cluster.

  4. Per verificare che il provider AWS IAM OpenID Connect (OIDC) esiste per il cluster, esegui il comando seguente:

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

    Nota: sostituisci your_cluster_name con il nome del tuo cluster.

  5. Verifica che il tuo provider IAM OIDC sia configurato:

    aws iam list-open-id-connect-providers | grep OIDC_PROVIDER_ID

    Nota: sostituisci l'ID del provider oidc con il tuo ID OIDC. Se ricevi il messaggio di errore Nessun provider OpenIDConnect trovato nel tuo account, dovrai creare un provider IAM OIDC.

  6. Installa o aggiorna eksctl.

  7. Crea un provider IAM OIDC:

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

    Nota: sostituisci my-cluster con il nome del tuo cluster.

Opzione A: implementa e testa il driver CSI per Amazon EBS

Implementa il driver CSI per Amazon EBS:

  1. Crea un file di policy di attendibilità IAM simile all'esempio seguente:

    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

    Nota: sostituisci YOUR_AWS_ACCOUNT_ID con l'ID del tuo account. Sostituisci YOUR_AWS_REGION con la tua regione. Sostituisci il tuo ID OIDC con l'output ottenuto dalla creazione del tuo provider OIDC IAM.

  2. Crea un ruolo IAM denominato Amazon_EBS_CSI_Driver:

    aws iam create-role \
     --role-name AmazonEKS_EBS_CSI_Driver \
     --assume-role-policy-document file://"trust-policy.json"
  3. Collega la policy IAM, gestita da AWS per il driver CSI di EBS, al ruolo IAM che hai creato:

    aws iam attach-role-policy \
    --policy-arn arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
    --role-name AmazonEKS_EBS_CSI_Driver
  4. Implementa il driver CSI per Amazon EBS.

    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

    Nota: sostituisci my-cluster con il nome del tuo cluster e YOUR_AWS_ACCOUNT_ID con l'ID del tuo account.

    Puoi implementare il driver CSI per EBS con Kustomize, Helm o un componente aggiuntivo gestito da Amazon EKS. Questo esempio utilizza la funzionalità aggiuntiva di Amazon EKS per implementare il driver. Per maggiori informazioni, consulta la guida all'installazione di aws-ebs-csi-driver su GitHub.

  5. Verifica che il driver CSI per EBS sia stato installato correttamente:

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

    Una corretta installazione restituirà il seguente risultato:

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

Testa il driver CSI per Amazon EBS:

È possibile testare il driver CSI per Amazon EBS con un'applicazione di esempio che utilizzi il provisioning dinamico per i pod. Il volume Amazon EBS viene assegnato su richiesta.

  1. Clona il repository aws-ebs-csi-driver da AWS GitHub:

    git clone https://github.com/kubernetes-sigs/aws-ebs-csi-driver.git
  2. Passa dalla directory corrente alla cartella contenente i file per il test del driver per Amazon EBS:

    cd aws-ebs-csi-driver/examples/kubernetes/dynamic-provisioning/
  3. Crea le risorse Kubernetes necessarie per il test:

    kubectl apply -f manifests/

    Nota: il comando kubectl crea una StorageClass, un PersistentVolumeClaim (PVC) e un pod. Il pod fa riferimento al PVC. Verrà assegnato un volume Amazon EBS solo quando verrà creato il pod. Per ulteriori informazioni, consulta la sezione Storage Classes e PersistentVolumeClaims sul sito Web di Kubernetes.

  4. Descrivi la classe di archiviazione ebs-sc:

    kubectl describe storageclass ebs-sc
  5. Visualizza i pod nello spazio dei nomi predefinito e aspetta che lo stato del pod dell'app passi a In esecuzione. Ad esempio:

    kubectl get pods --watch
  6. Visualizza il volume persistente creato grazie al pod che fa riferimento al PVC:

    kubectl get pv
  7. Visualizza le informazioni sul volume persistente:

    kubectl describe pv your_pv_name

    Nota: sostituisci your_pv_name con il nome del volume persistente restituito dal passaggio 6 nella sezione precedente. Il valore della proprietà Source.VolumeHandle nell'output è l'ID del volume fisico di Amazon EBS creato nel tuo account.

  8. Verifica che il pod stia scrivendo dati sul volume:

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

    Nota: l'output del comando mostra la data e l'ora correnti archiviate nel file /data/out.txt. Il file include il giorno, il mese, la data e l'ora.

Opzione B: implementa e testa il driver CSI per Amazon EFS

Prima di implementare il driver CSI, crea un ruolo IAM che permetta all'account di servizio del driver CSI di effettuare chiamate alle API AWS per tuo conto.

  1. Scarica il documento della policy IAM da GitHub:

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

    aws iam create-policy \
        --policy-name AmazonEKS_EFS_CSI_Driver_Policy \
        --policy-document file://iam-policy-example.json
  3. Esegui il comando seguente per determinare l'URL del provider OIDC del tuo cluster:

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

    Nota: nel passaggio 3, sostituisci your_cluster_name con il nome del tuo cluster.

  4. Crea la seguente policy di attendibilità IAM, poi assegna l'azione AssumeRoleWithWebIdentity al tuo account di servizio Kubernetes:

    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

    Nota: nel passaggio 4, sostituisci YOUR_AWS_ACCOUNT_ID con l'ID del tuo account. Sostituisci YOUR_AWS_REGION con la tua regione. Sostituisci XXXXXXXXXX45D83924220DC4815XXXXX con il valore restituito nel passaggio 3.

  5. Crea un ruolo IAM:

    aws iam create-role \
      --role-name AmazonEKS_EFS_CSI_DriverRole \
      --assume-role-policy-document file://"trust-policy.json"
  6. Collega la nuova policy IAM al ruolo:

    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. Salva i contenuti seguenti in un file denominato 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
  8. Crea l'account di servizio di Kubernetes nel tuo cluster. L'account di servizio di Kubernetes denominato efs-csi-controller-sa è annotato con il ruolo IAM che hai creato.

    kubectl apply -f efs-service-account.yaml
  9. Installa il driver con le immagini archiviate nel registro pubblico di Amazon ECR scaricando il manifesto:

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

    Nota: è possibile installare il driver CSI per EFS utilizzando Helm e un Kustomize con registro privato o pubblico AWS. Per ulteriori informazioni, consulta la documentazione relativa al driver CSI per Amazon EFS.

    Quindi, modifica il file public-ecr-driver.yaml per rimuovere il manifesto efs-csi-controller-sa:

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

Implementa il driver CSI per Amazon EFS

Il driver CSI per Amazon EFS consente a più pod di scrivere contemporaneamente su un volume con la modalità ReadWriteMany.

  1. Per implementare il driver CSI per Amazon EFS, applica il manifesto:

    kubectl apply -f public-ecr-driver.yaml
  2. Se il cluster contiene solo pod AWS Fargate (nessun nodo), implementa il driver con il seguente comando (per tutte le regioni):

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

Crea un file system Amazon EFS

  1. Ottieni l’ID VPC del cluster Amazon EKS:

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

    Nota: nel passaggio 3, sostituisci your_cluster_name con il nome del tuo cluster.

  2. Ottieni l'intervallo CIDR per il cluster VPC:

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

    Nota: nel passaggio 4, sostituisci YOUR_VPC_ID con il VPC ID del passaggio 3 nella sezione precedente.

  3. Crea un gruppo di sicurezza che consenta il traffico Network File System (NFS) in entrata per i punti di montaggio di Amazon EFS:

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

    Nota: sostituisci YOUR_VPC_ID con l'output ottenuto al passaggio 3 nella sezione precedente. Conserva il GroupId per dopo.

  4. Aggiungi una regola NFS in entrata in modo che le risorse nel VPC possano comunicare con il file system di Amazon EFS:

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

    Nota: sostituisci YOUR_VPC_CIDR con l'output ottenuto nel passaggio 4 nella sezione precedente. Sostituisci sg-xxx con l'ID del gruppo di sicurezza ottenuto al passaggio 5 nella sezione precedente.

  5. Crea un file system di Amazon EFS per il cluster Amazon EKS:

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

    Nota: conserva il FileSystemId per dopo.

  6. Per creare un target di montaggio per Amazon EFS, esegui il comando seguente:

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

    Importante: assicurati di eseguire il comando per tutte le zone di disponibilità con il SubnetID nella zona di disponibilità in cui sono in esecuzione i nodi worker. Sostituisci FileSystemId con l'output ottenuto al passaggio 7 nella sezione precedente (dove hai creato il file system di Amazon EFS). Sostituisci sg-xxx con l'output ottenuto al precedente passaggio 5 (in cui hai creato il gruppo di sicurezza). Sostituisci SubnetID con la sottorete utilizzata dai nodi worker. Per creare target di montaggio in più sottoreti è necessario eseguire il comando di cui al passaggio 8 separatamente per ogni ID della sottorete. È consigliabile creare un target di montaggio in ogni zona di disponibilità in cui sono in esecuzione i nodi worker.

    Nota: è possibile creare target di montaggio per tutte le zone di disponibilità in cui vengono avviati i nodi worker. A questo punto, tutte le istanze Amazon Elastic Compute Cloud (Amazon EC2) nella zona di disponibilità con il target di montaggio possono utilizzare il file system.

Il file system di Amazon EFS e i relativi target di montaggio sono ora in esecuzione e sono pronti per essere utilizzati dai pod nel cluster.

Testa il driver CSI per Amazon EFS

È possibile testare il driver CSI per Amazon EFS implementando due pod che scrivono nello stesso file.

  1. Clona il repository aws-efs-csi-driver da AWS GitHub:

    git clone https://github.com/kubernetes-sigs/aws-efs-csi-driver.git
  2. Passa dalla directory corrente alla cartella contenente i file per il test del driver CSI per Amazon EFS:

    cd aws-efs-csi-driver/examples/kubernetes/multiple_pods/
  3. Recupera l'ID del file system di Amazon EFS creato in precedenza:

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

    Nota: se il comando di cui al passaggio 3 restituisce più di un risultato, è possibile utilizzare l'ID del file system di Amazon EFS che hai conservato in precedenza.

  4. Nel file specs/pv.yaml, sostituisci il valore spec.csi.volumeHandle con il FileSystemId di Amazon EFS dei passaggi precedenti.

  5. Crea le risorse Kubernetes necessarie per il test:

    kubectl apply -f specs/

    Nota: il comando kubectl di cui al precedente passaggio 5 creerà una classe di archiviazione Amazon EFS, un PVC, un volume persistente e due pod (app1 e app2).

  6. Elenca i volumi persistenti nello spazio dei nomi predefinito e cerca un volume persistente con l'attestazione default/efs-claim:

    kubectl get pv efs-pv
  7. Descrivi il volume persistente:

    kubectl describe pv efs-pv
  8. Verifica che i due pod stiano scrivendo dati nel file:

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

    Attendi circa un minuto. L'output mostra la data corrente scritta nel file /data/out1.txt da entrambi i pod.

    Informazioni correlate

    Risoluzione dei problemi di Amazon EFS

AWS UFFICIALE
AWS UFFICIALEAggiornata un anno fa