Como usar o armazenamento persistente no Amazon EKS?

11 minuto de leitura

Quero usar o armazenamento persistente no Amazon Elastic Kubernetes Service (Amazon EKS).

Breve descrição

Para configurar o armazenamento persistente no Amazon EKS, use uma das seguintes opções:

Driver de Interface de armazenamento de contêiner (CSI) do Amazon Elastic Block Store (Amazon EBS)
Driver de Interface de armazenamento de contêiner (CSI) do Amazon Elastic File System (Amazon EFS)

Para usar uma dessas opções, conclua as etapas em uma das seções a seguir:

Opção A: implantar e testar o driver de CSI do Amazon EBS
Opção B: implantar e testar o driver de CSI do Amazon EFS

Os comandos neste artigo exigem o kubectl versão 1.14 ou posterior. Para ver a sua versão do kubectl, execute o seguinte comando:

kubectl version --client --short

Observação: a prática recomendada é garantir a instalação da versão mais recente dos drivers. Para obter mais informações, procure o driver de CSI do Amazon EBS e o driver de CSI do Amazon EFS nos repositórios do GitHub.

Resolução

Observação: se você receber erros ao executar comandos da AWS Command Line Interface (AWS CLI), certifique-se de estar usando a versão mais recente da AWS CLI.

Antes de concluir as etapas em qualquer seção, faça o seguinte:

Instale a AWS CLI.
Defina as permissões do AWS Identity and Access Management (IAM) para criar e anexar uma política ao perfil do nó de processamento do Amazon EKS, Perfil do driver de CSI.
Observação: os comandos nas seções a seguir nem sempre usam a variável --region. Se você não usar --region, os comandos usarão o valor padrão para sua região da AWS. Para verificar o valor padrão, execute o comando configure da AWS CLI.
Crie seu cluster do Amazon EKS e ingresse seus nós de processamento nesse cluster.
Observação: execute o comando kubectl get nodes para verificar se os nós de processamento estão conectados ao cluster.

Execute o comando a seguir para verificar se o seu provedor OpenID Connect (OIDC) do AWS IAM existe para o cluster:

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

Observação: substitua your_cluster_name pelo nome do seu cluster.

Verifique se o provedor OIDC do IAM está configurado:
```
aws iam list-open-id-connect-providers | grep OIDC_PROVIDER_ID
```
Observação: substitua o ID do provedor OIDC pelo ID do seu OIDC. Se você receber um erro No OpenIDConnect provider found in your account, você deverá criar um provedor OIDC do IAM.
Instale ou atualize o eksctl.

Crie um provedor OIDC do IAM:

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

Observação: substitua my-cluster pelo nome do seu cluster.

Opção A: implantar e testar o driver de CSI do Amazon EBS

Implante o driver de CSI do Amazon EBS:

Crie um arquivo de política de confiança do IAM, semelhante ao exemplo a seguir:

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

Observação: substitua YOUR_AWS_ACCOUNT_ID pelo ID da sua conta. Substitua YOUR_AWS_REGION pela sua região. Substitua seu ID do OIDC pela saída da criação do seu provedor OIDC do IAM.

Crie um perfil do IAM chamado Amazon_EBS_CSI_Driver:

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

Anexe a política do IAM gerenciada pela AWS para o driver de CSI do EBS ao perfil do IAM que você criou:

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

Implante o driver de CSI do 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

Observação: substitua my-cluster pelo nome do seu cluster e YOUR_AWS_ACCOUNT_ID pelo ID da sua conta.

Você pode implantar o driver de CSI do EBS com o Kustomize, Helm ou um complemento gerenciado pelo Amazon EKS. Este exemplo usa o atributo complementar do Amazon EKS para implantar o driver. Para obter mais informações, consulte o guia de instalação do aws-ebs-csi-driver no GitHub.

Verifique se o driver CSI do EBS foi instalado com êxito:

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

Uma instalação bem-sucedida retorna a seguinte saída:

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

Teste o driver de CSI do Amazon EBS:

Você pode testar seu driver de CSI do Amazon EBS com uma aplicação de amostra que usa o provisionamento dinâmico para os pods. O volume do Amazon EBS é provisionado sob demanda.

Clone o repositório aws-ebs-csi-driver do GitHub da AWS:

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

Mude o diretório de trabalho para a pasta que contém os arquivos de teste do driver do Amazon EBS:

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

Crie os recursos do Kubernetes necessários para os testes:
```
kubectl apply -f manifests/
```
Observação: o comando kubectl cria StorageClass, PersistentVolumeClaim (PVC) e um pod. O pod faz referência ao PVC. Um volume do Amazon EBS é provisionado somente quando o pod é criado. Para obter mais informações, consulte Storage classes e PersistentVolumeClaims no site do Kubernetes.

Descreva a classe de armazenamento ebs-sc:

kubectl describe storageclass ebs-sc

Observe os pods no namespace padrão e aguarde até que o status do pod app mude para Em execução. Por exemplo:
```
kubectl get pods --watch
```
Visualize o volume persistente criado por causa do pod que faz referência ao PVC:
```
kubectl get pv
```
Visualize informações sobre o volume persistente:
```
kubectl describe pv your_pv_name
```
Observação: substitua your_pv_name pelo nome do volume persistente retornado na etapa 6 na seção anterior. O valor da propriedade Source.VolumeHandle na saída é o ID do volume físico do Amazon EBS criado na sua conta.
Verifique se o pod está gravando dados no volume:
```
kubectl exec -it app -- cat /data/out.txt
```
Observação: a saída do comando exibe a data e a hora atuais armazenadas no arquivo /data/out.txt. O arquivo inclui dia, mês, data e hora.

Opção B: implantar e testar o driver de CSI do Amazon EFS

Antes de implantar o driver de CSI, crie um perfil do IAM que permita que a conta de serviço do driver de CSI faça chamadas para as APIs da AWS em seu nome.

Baixe o documento de política do IAM no GitHub:

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

Crie uma política do IAM:

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

Execute o comando a seguir para determinar o URL do provedor OIDC do seu cluster:

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

Observação: na etapa 3, substitua your_cluster_name pelo nome do seu cluster.

Crie a seguinte política de confiança do IAM e, em seguida, conceda a ação AssumeRoleWithWebIdentity à sua conta de serviço do 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

Observação: na etapa 4, substitua YOUR_AWS_ACCOUNT_ID pelo ID da sua conta. Substitua YOUR_AWS_REGION pela sua região. Substitua XXXXXXXXXX45D83924220DC4815XXXXX pelo valor retornado na etapa 3.

Crie um perfil do IAM:

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

Anexe sua nova política do IAM ao perfil:

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

Salve o conteúdo a seguir em um arquivo chamado 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

Crie a conta de serviço do Kubernetes no seu cluster. A conta de serviço do Kubernetes chamada efs-csi-controller-sa é anotada com o perfil do IAM que você criou.
```
kubectl apply -f efs-service-account.yaml
```

Instale o driver usando imagens armazenadas no registro público do Amazon ECR baixando o manifesto:

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

Observação: você pode instalar o driver de CSI do EFS usando o Helm e o Kustomize com o Registro público ou privado da AWS. Para obter mais informações, consulte a documentação do driver de CSI do Amazon EFS.

Em seguida, edite o arquivo public-ecr-driver.yaml para remover o 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

Implante o driver de CSI do Amazon EFS

O driver de CSI do Amazon EFS permite que vários pods gravem em um volume ao mesmo tempo com o modo ReadWriteMany.

Para implantar o driver de CSI do Amazon EFS, aplique o manifesto:

kubectl apply -f public-ecr-driver.yaml

Se o seu cluster contiver somente pods do AWS Fargate (sem nós), implante o driver com o seguinte comando (todas as regiões):

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

Crie um sistema de arquivos do Amazon EFS

Obtenha o ID da VPC do seu cluster do Amazon EKS:

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

Observação: na etapa 3, substitua your_cluster_name pelo nome do seu cluster.

Obtenha o intervalo CIDR do seu cluster da VPC:

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

Observação: na etapa 4, substitua YOUR_VPC_ID pelo ID da VPC da etapa 3 na seção anterior.

Crie um grupo de segurança que permita o tráfego de entrada do sistema de arquivos de rede (NFS) para seus pontos de montagem do Amazon EFS:

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

Observação: substitua YOUR_VPC_ID pela saída da etapa 3 na seção anterior. Salve o GroupId para mais tarde.

Adicione uma regra de entrada do NFS para que os recursos na sua VPC possam se comunicar com seu sistema de arquivos do Amazon EFS:

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

Observação: substitua YOUR_VPC_CIDR pela saída da etapa 4 na seção anterior. Substitua sg-xxx pelo ID do grupo de segurança da etapa 5 na seção anterior.

Crie um sistema de arquivos do Amazon EFS para o seu cluster do Amazon EKS:

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

Observação: salve o FileSystemId para uso posterior.

Para criar um destino de montagem para o Amazon EFS, execute o seguinte comando:
```
aws efs create-mount-target --file-system-id FileSystemId --subnet-id SubnetID --security-group sg-xxx
```
Importante: certifique-se de executar o comando para todas as zonas de disponibilidade com o SubnetID na zona de disponibilidade em que seus nós de processamento estão sendo executados. Substitua FileSystemId pela saída da etapa 7 na seção anterior (em que você criou o sistema de arquivos do Amazon EFS). Substitua sg-xxx pela saída da etapa 5 anterior (na qual você criou o grupo de segurança). Substitua SubnetID pela sub-rede usada pelos seus nós de processamento. Para criar destinos de montagem em várias sub-redes, você deve executar o comando da etapa 8 separadamente para cada ID de sub-rede. É uma prática recomendada criar um destino de montagem em cada zona de disponibilidade na qual seus nós de processamento estão sendo executados.

Observação: você pode criar destinos de montagem para todas as zonas de disponibilidade em que os nós de processamento são executados. Dessa forma, todas as instâncias do Amazon Elastic Compute Cloud (Amazon EC2) na zona de disponibilidade com o destino de montagem poderão usar o sistema de arquivos.

O sistema de arquivos do Amazon EFS e seus destinos de montagem agora estão em execução e prontos para serem usados pelos pods no cluster.

Teste o driver de CSI do Amazon EFS

Você pode testar o driver de CSI do Amazon EFS implantando dois pods que gravam no mesmo arquivo.

Clone o repositório aws-efs-csi-driver do GitHub da AWS:

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

Mude o diretório de trabalho para a pasta que contém os arquivos de teste do driver de CSI do Amazon EFS:

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

Recupere o ID do sistema de arquivos do Amazon EFS que foi criado anteriormente:

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

Observação: se o comando da etapa 3 retornar mais de um resultado, você poderá usar o ID do sistema de arquivos do Amazon EFS que foi salvo anteriormente.

No arquivo specs/pv.yaml, substitua o valor spec.csi.volumeHandle pelo seu FileSystemId do Amazon EFS das etapas anteriores.
Crie os recursos do Kubernetes necessários para os testes:
```
kubectl apply -f specs/
```
Observação: o comando kubectl da etapa 5 anterior cria uma classe de armazenamento do Amazon EFS, um PVC, um volume persistente e dois pods (app1 e app2).
Liste os volumes persistentes no namespace padrão e procure um volume persistente com a declaração default/efs-claim:
```
kubectl get pv efs-pv
```

Descreva o volume persistente:

kubectl describe pv efs-pv

Teste se os dois pods estão gravando dados no arquivo:

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

Aguarde cerca de um minuto. A saída mostra a data atual gravada em /data/out1.txt pelos dois pods.

Informações relacionadas

Solução de problemas do Amazon EFS

Tópicos

Contêineres

Vídeos relacionados

Assista ao vídeo de Esteban para saber mais (8:37)

AWS OFICIALAtualizada há um ano

Conteúdo relevante

Como solucionar problemas ao criar dinamicamente um objeto de volume persistente do Kubernetes usando o controlador CSI do Amazon EFS?
AWS OFICIALAtualizada há um ano
Como crio e soluciono problemas de provisionamento de volume com reconhecimento de topologia que usa um driver CSI do EBS no Amazon EKS?
AWS OFICIALAtualizada há um ano
Como soluciono problemas de erros “Persistent store is Full” (O armazenamento persistente está cheio) no Amazon MQ para ActiveMQ?
AWS OFICIALAtualizada há 2 anos
Como é possível restaurar, redimensionar ou criar um snapshot de armazenamento persistente do EBS no Amazon EKS para recuperação de desastres ou quando a taxa de modificação do EBS é excedida?
AWS OFICIALAtualizada há um ano