**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.

# Implantar uma workload com estado de exemplo no Modo Automático do EKS
<a name="sample-storage-workload"></a>

Este tutorial o orientará na implantação de uma aplicação com estado de exemplo no cluster do Modo Automático do EKS. A aplicação grava carimbos de data e hora em um volume persistente, demonstrando os recursos automáticos de provisionamento e persistência de volume do EBS do Modo Automático do EKS.

## Pré-requisitos
<a name="_prerequisites"></a>
+ Um cluster do Modo Automático do EKS
+ A AWS CLI configurada com as permissões apropriadas
+  `kubectl` instalado e configurado
  + Para ter mais informações, consulte [Configurar para usar o Amazon EKS](setting-up.md).

## Etapa 1: configurar o ambiente
<a name="_step_1_configure_your_environment"></a>

1. Defina as variáveis de ambiente:

   ```
   export CLUSTER_NAME=my-auto-cluster
   export AWS_REGION="us-west-2"
   ```

1. Atualize o kubeconfig:

   ```
   aws eks update-kubeconfig --name "${CLUSTER_NAME}"
   ```

## Etapa 2: criar a classe de armazenamento
<a name="_step_2_create_the_storage_class"></a>

A `StorageClass` define como o Modo Automático do EKS provisionará volumes do EBS.

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.

1. Crie um arquivo chamado `storage-class.yaml`:

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

1. Aplique a `StorageClass`:

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

 **Principais componentes:** 
+  `provisioner: ebs.csi.eks.amazonaws.com`: usa o Modo Automático do EKS
+  `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 usará a chave `aws/ebs` padrão para criptografar volumes criados com essa classe. Isso é opcional, mas recomendado.
+  `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. Tenha cuidado ao definir esse valor se estiver migrando de outro controlador de armazenamento. (opcional)

## Etapa 3: criar a declaração de volume persistente
<a name="_step_3_create_the_persistent_volume_claim"></a>

A PVC solicita armazenamento da `StorageClass`.

1. Crie um arquivo chamado `pvc.yaml`:

   ```
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: auto-ebs-claim
   spec:
     accessModes:
       - ReadWriteOnce
     storageClassName: auto-ebs-sc
     resources:
       requests:
         storage: 8Gi
   ```

1. Aplique a PVC:

   ```
   kubectl apply -f pvc.yaml
   ```

 **Principais componentes:** 
+  `accessModes: ReadWriteOnce`: o volume pode ser montado por um nó por vez
+  `storage: 8Gi`: solicita um volume de 8 GiB
+  `storageClassName: auto-ebs-sc`: faz referência à `StorageClass` que criamos

## Etapa 4: implantar uma aplicação
<a name="_step_4_deploy_the_application"></a>

A implantação executa um contêiner que grava carimbos de data e hora no volume persistente.

1. Crie um arquivo chamado `deployment.yaml`:

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: inflate-stateful
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: inflate-stateful
     template:
       metadata:
         labels:
           app: inflate-stateful
       spec:
         terminationGracePeriodSeconds: 0
         nodeSelector:
           eks.amazonaws.com/compute-type: auto
         containers:
           - name: bash
             image: public.ecr.aws/docker/library/bash:4.4
             command: ["/usr/local/bin/bash"]
             args: ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 60; done"]
             resources:
               requests:
                 cpu: "1"
             volumeMounts:
               - name: persistent-storage
                 mountPath: /data
         volumes:
           - name: persistent-storage
             persistentVolumeClaim:
               claimName: auto-ebs-claim
   ```

1. Aplique a implantação:

   ```
   kubectl apply -f deployment.yaml
   ```

 **Principais componentes:** 
+ Contêiner bash simples que grava carimbos de data e hora em um arquivo
+ Monta o PVC em `/data` 
+ Solicita um núcleo de CPU
+ Usa o seletor de nós para nós gerenciados pelo EKS

## Etapa 5: verificar a configuração
<a name="_step_5_verify_the_setup"></a>

1. Verifique se o pod está em execução:

   ```
   kubectl get pods -l app=inflate-stateful
   ```

1. Verifique se a PVC está vinculada:

   ```
   kubectl get pvc auto-ebs-claim
   ```

1. Verifique o volume do EBS:

   ```
   # Get the PV name
   PV_NAME=$(kubectl get pvc auto-ebs-claim -o jsonpath='{.spec.volumeName}')
   # Describe the EBS volume
   aws ec2 describe-volumes \
     --filters Name=tag:CSIVolumeName,Values=${PV_NAME}
   ```

1. Verifique se os dados estão sendo gravados:

   ```
   kubectl exec "$(kubectl get pods -l app=inflate-stateful \
     -o=jsonpath='{.items[0].metadata.name}')" -- \
     cat /data/out.txt
   ```

## Etapa 6: limpeza
<a name="_step_6_cleanup"></a>

Execute o comando a seguir para remover todos os recursos criados neste tutorial:

```
# Delete all resources in one command
kubectl delete deployment/inflate-stateful pvc/auto-ebs-claim storageclass/auto-ebs-sc
```

## O que está acontece por detrás
<a name="_whats_happening_behind_the_scenes"></a>

1. A PVC solicita armazenamento da `StorageClass` 

1. Quando o pod está programado:

   1. O Modo Automático do EKS provisiona um volume do EBS

   1. Cria um PersistentVolume

   1. Anexa o volume ao nó

1. O pod monta o volume e começa a gravar carimbos de data e hora

## Controlador de snapshots
<a name="_snapshot_controller"></a>

O Modo Automático do EKS é compatível com o Kubernetes CSI Snapshotter, também conhecido como controlador de snapshots. No entanto, o Modo Automático do EKS não inclui o controlador de snapshots. Você é responsável por instalar e configurar o controlador de snapshots. Para ter mais informações, consulte [Habilitar a funcionalidade de snapshot para volumes CSI](csi-snapshot-controller.md).

Analise a `VolumeSnapshotClass` a seguir que faz referência à capacidade de armazenamento do Modo Automático do EKS.

```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: auto-ebs-vsclass
driver: ebs.csi.eks.amazonaws.com
deletionPolicy: Delete
```

 [Saiba mais sobre o Kubernetes CSI Snapshotter.](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage)