

 **Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Criar uma classe de armazenamento
<a name="create-storage-class"></a>

Uma `StorageClass` no Modo automático do Amazon EKS define como os volumes do Amazon EBS são provisionados automaticamente quando as aplicações solicitam armazenamento persistente. Esta página explica como criar e configurar uma `StorageClass` que funcione com o Modo automático do Amazon EKS para provisionar volumes do EBS.

Ao configurar uma `StorageClass`, você pode especificar as configurações padrão para os volumes do EBS, incluindo tipo de volume, criptografia, IOPS e outros parâmetros de armazenamento. Você também pode configurar a `StorageClass` para usar chaves do AWS KMS para gerenciamento de criptografia.

O Modo automático do EKS não cria uma `StorageClass` para você. Você deve criar uma `StorageClass` referenciando `ebs.csi.eks.amazonaws.com` para usar o recurso de armazenamento do Modo automático do EKS.

Primeiro, crie um arquivo denominado `storage-class.yaml`:

```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: auto-ebs-sc
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
allowedTopologies:
- matchLabelExpressions:
  - key: eks.amazonaws.com/compute-type
    values:
    - auto
provisioner: ebs.csi.eks.amazonaws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp3
  encrypted: "true"
```

Segundo, aplique a classe de armazenamento ao cluster.

```
kubectl apply -f storage-class.yaml
```

 **Principais componentes:** 
+  `provisioner: ebs.csi.eks.amazonaws.com`: usa o modo automático do EKS
+  `allowedTopologies`: especificar `matchLabelExpressions` para combinar com `eks.amazonaws.com/compute-type:auto` garantirá que, se seus pods precisarem de um volume provisionado automaticamente usando o Modo automático, os pods não serão agendados em nós não automáticos.
+  `volumeBindingMode: WaitForFirstConsumer`: atrasa a criação do volume até que um pod precise dele
+  `type: gp3`: especifica o tipo de volume do EBS
+  `encrypted: "true"`: o EBS criptografará todos os volumes criados usando a `StorageClass`. O EBS usará o alias de chave `aws/ebs` padrão. Para obter mais informações, consulte [How Amazon EBS encryption works](https://docs.aws.amazon.com/ebs/latest/userguide/how-ebs-encryption-works.html) no Guia do usuário do Amazon EBS. Este valor é opcional, mas sugerido.
+  `storageclass.kubernetes.io/is-default-class: "true"`: o Kubernetes usará essa classe de armazenamento por padrão, a menos que você especifique uma classe de volume diferente em uma reivindicação de volume persistente. Este valor é opcional. Tenha cuidado ao definir esse valor se estiver migrando de um controlador de armazenamento diferente.

## Usar uma chave autogerenciada do KMS para criptografar volumes do EBS
<a name="_use_self_managed_kms_key_to_encrypt_ebs_volumes"></a>

Para usar uma chave autogerenciada do KMS para criptografar volumes do EBS automatizados pelo Modo automático do EKS, você precisa:

1. Criar uma chave autogerenciada do KMS.
   + Para obter mais informações, consulte [Create a symmetric encryption KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/create-symmetric-cmk.html) ou [How Amazon Elastic Block Store (Amazon EBS) uses KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services-ebs.html) no Guia do usuário do KMS.

1. Crie uma nova política que permita o acesso à chave do KMS.
   + Use o exemplo de política do IAM abaixo para criar a política. Insira o ARN da nova chave autogerenciada do KMS. Para obter mais informações, consulte a seção [Criar perfis e anexar políticas (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions_create-policies.html) do Guia do usuário do AWS IAM.

1. Anexe a política ao perfil do cluster do EKS.
   + Use o console da AWS para encontrar o ARN do perfil do cluster do EKS. As informações do perfil estão visíveis na seção **Visão geral**. Para obter mais informações, consulte [Função do IAM do cluster do Amazon EKS](cluster-iam-role.md).

1. Atualize a `StorageClass` para fazer referência ao ID da chave do KMS no campo `parameters.kmsKeyId`.

### Exemplo de política do IAM autogerenciada do KMS
<a name="_sample_self_managed_kms_iam_policy"></a>

Atualize os seguintes valores na política abaixo:
+  `<account-id>`: o ID da conta da AWS, como `111122223333` 
+  `<aws-region>`: a região da AWS do cluster, como `us-west-2` 

```
{
  "Version":"2012-10-17",		 	 	 
  "Id": "key-auto-policy-3",
  "Statement": [
      {
          "Sid": "Enable IAM User Permissions",
          "Effect": "Allow",
          "Principal": {
              "AWS": "arn:aws:iam::123456789012:root"
          },
          "Action": "kms:*",
          "Resource": "*"
      },
      {
        "Sid": "Allow access through EBS for all principals in the account that are authorized to use EBS",
        "Effect": "Allow",
        "Principal": {
            "AWS": "*"
        },
        "Action": [
            "kms:Encrypt",
            "kms:Decrypt",
            "kms:ReEncrypt*",
            "kms:GenerateDataKey*",
            "kms:CreateGrant",
            "kms:DescribeKey"
        ],
        "Resource": "*",
        "Condition": {
            "StringEquals": {
                "kms:CallerAccount": "123456789012",
                "kms:ViaService": "ec2.us-east-1.amazonaws.com"
            }
        }
    }
  ]
}
```

### Exemplo da `StorageClass` autogerenciada do KMS
<a name="_sample_self_managed_kms_storageclass"></a>

```
parameters:
  type: gp3
  encrypted: "true"
  kmsKeyId: <custom-key-arn>
```

## Referência a parâmetros da `StorageClass`
<a name="_storageclass_parameters_reference"></a>

Para obter informações gerais sobre os recursos da `StorageClass` do Kubernetes, consulte [Storage Classes](https://kubernetes.io/docs/concepts/storage/storage-classes/) na documentação do Kubernetes.

A seção `parameters` do recurso `StorageClass` é específica para a AWS. Use a tabela a seguir para analisar as opções disponíveis.


| Parâmetros | Valores | Padrão | Descrição | 
| --- | --- | --- | --- | 
|  "csi.storage.k8s.io/fstype"  |  xfs, ext2, ext3, ext4  |  ext4  |  Tipo de sistema de arquivos que será formatado durante a criação do volume. Esse parâmetro diferencia maiúsculas de minúsculas.  | 
|  "type"  |  io1, io2, gp2, gp3, sc1, st1, standard, sbp1, sbg1  |  gp3  |  Tipo de volume do EBS.  | 
|  "iopsPerGB"  |  |  |  Operações de E/S por segundo por GiB. Pode ser especificado para volumes IO1, IO2 e GP3.  | 
|  "allowAutoIOPSPerGBIncrease"  |  true, false  |  false  |  Quando `"true"`, o driver CSI aumenta o IOPS para um volume quando `iopsPerGB * <volume size>` está muito baixo para se enquadrar na faixa de IOPS compatível com a AWS. Isso permite que o provisionamento dinâmico sempre tenha êxito, mesmo quando o usuário especificar uma capacidade de PVC ou valor de `iopsPerGB` muito pequeno. Por outro lado, isso pode introduzir custos adicionais, pois esses volumes têm IOPS mais alto do que o solicitado em `iopsPerGB`.  | 
|  "iops"  |  |  |  Operações de E/S por segundo. Pode ser especificado para volumes IO1, IO2 e GP3.  | 
|  "throughput"  |  |  125  |  Throughput em MiB/s. Eficaz somente quando o tipo de volume gp3 é especificado.  | 
|  "encrypted"  |  true, false  |  false  |  Especifica se o volume deve ser criptografado ou não. Os valores válidos são "true" ou "false".  | 
|  "blockExpress"  |  true, false  |  false  |  Permite a criação de volumes io2 Block Express.  | 
|  "kmsKeyId"  |  |  |  O ARN completo da chave a ser usada ao criptografar o volume. Se não for especificado, a AWS usará a chave padrão do KMS para a região em que o volume está. Será uma chave gerada automaticamente, denominada `/aws/ebs` caso não seja alterada.  | 
|  "blockSize"  |  |  |  O tamanho do bloco a ser usado ao formatar o sistema de arquivos subjacente. Compatível apenas com nós Linux e com o fstype `ext2`, `ext3`, `ext4` ou `xfs`.  | 
|  "inodeSize"  |  |  |  O tamanho do inode a ser usado ao formatar o sistema de arquivos subjacente. Compatível apenas com nós Linux e com o fstype `ext2`, `ext3`, `ext4` ou `xfs`.  | 
|  "bytesPerInode"  |  |  |  O `bytes-per-inode` a ser usado ao formatar o sistema de arquivos subjacente. Compatível apenas com nós Linux e com o fstype `ext2`, `ext3`, `ext4`.  | 
|  "numberOfInodes"  |  |  |  O `number-of-inodes` a ser usado ao formatar o sistema de arquivos subjacente. Compatível apenas com nós Linux e com o fstype `ext2`, `ext3`, `ext4`.  | 
|  "ext4BigAlloc"  |  true, false  |  false  |  Altera o sistema de arquivos `ext4` para usar a alocação de blocos em cluster habilitando a opção de formatação `bigalloc`. Aviso: `bigalloc` pode não ser totalmente compatível com o Kernel Linux do nó.  | 
|  "ext4ClusterSize"  |  |  |  O tamanho do cluster a ser usado ao formatar um sistema de arquivos `ext4` quando o recurso `bigalloc` está habilitado. Observação: o parâmetro `ext4BigAlloc` deve ser definido como true.  | 

Para obter mais informações, consulte [AWS EBS CSI Driver](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/parameters.md) no GitHub.

## Considerações
<a name="_considerations"></a>

**nota**  
Você só pode implantar workloads que dependam das StorageClasses no Modo automático do EKS em nós do Modo automático do EKS. Se você tiver um cluster com tipos mistos de nós, precisará configurar suas workloads para serem executadas somente em nós do Modo automático do EKS. Para obter mais informações, consulte [Controlar se uma workload é implantada nos nós do Modo Automático do EKS](associate-workload.md).

A capacidade de armazenamento em blocos do Modo automático do EKS é diferente do driver CSI do EBS.
+ Provisionamento estático
  + Caso queira usar volumes do EBS criados externamente com o Modo automático do EKS, você precisará adicionar manualmente uma tag da AWS com a chave `eks:eks-cluster-name` e o valor do nome do cluster.
+ Taint de inicialização de nós
  + Você não pode usar o recurso de taint de inicialização de nós para impedir a programação de pods antes que a capacidade de armazenamento esteja pronta.
+ Tags personalizadas em volumes provisionados dinamicamente
  + Você não pode usar o sinalizador extra-tag da CLI para configurar tags personalizadas em volumes do EBS provisionados dinamicamente
  + Você pode usar a marcação de `StorageClass` para adicionar tags personalizadas. O Modo automático do EKS adicionará tags aos recursos associados da AWS. Você precisará atualizar o perfil do IAM do cluster para tags personalizadas. Para obter mais informações, consulte [Tags da AWS personalizadas para recursos do Modo Automático do EKS.](auto-learn-iam.md#tag-prop).
+ Métricas de performance detalhadas do EBS
  + Você não pode acessar as métricas do Prometheus da performance detalhada do EBS

## Instalar o complemento do Controlador de Snapshots da CSI
<a name="_install_csi_snapshot_controller_add_on"></a>

O Modo automático do EKS é compatível com o complemento do Controlador de Snapshots da CSI do Amazon EKS.

 A AWS sugere que você configure esse complemento para ser executado no grupo de nós `system` integrado.

Para obter mais informações, consulte:
+  [Executar complementos críticos em instâncias dedicadas](critical-workload.md) 
+  [Habilitar ou desabilitar NodePools integrados](set-builtin-node-pools.md) 
+  [Habilitar a funcionalidade de snapshot para volumes CSI](csi-snapshot-controller.md) 

### Para instalar o controlador de snapshots no grupo de nós do sistema
<a name="auto-install-snapshot-controller"></a>

1. Abra o cluster do EKS no console da AWS

1. Na guia **Complementos**, selecione **Obter mais complementos** 

1. Selecione **Controlador de Snapshots da CSI** e depois **Próximo** 

1. Na página **Configurar definições de complementos selecionados**, selecione **Configurações opcionais** para visualizar o **Esquema de configuração do complemento** 

   1. Insira o YAML a seguir para associar o controlador de snapshots ao grupo de nós `system`. O controlador de snapshots inclui uma tolerância ao taint `CriticalAddonsOnly`.

      ```
      {
              "nodeSelector": {
                  "karpenter.sh/nodepool": "system"
              }
      }
      ```

   1. Selecione **Próximo**. 

1. Revise a configuração do complemento e selecione **Criar** 