**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.
# Início rápido: implantar uma aplicação Web e armazenar dados
Este tutorial de início rápido orienta como implantar a aplicação de amostra do jogo 2048 e manter seus dados em um cluster do modo automático do Amazon EKS, usando o [eksctl](https://eksctl.io/).
Com o [modo automático do Amazon EKS](automode.md), o gerenciamento de clusters se torna mais simples, pois tarefas rotineiras como armazenamento em bloco, rede, balanceamento de carga e ajuste de escala automático de computação são automatizadas. Durante a configuração, ele gerencia a criação de nós com instâncias gerenciadas do EC2, balanceadores de carga de aplicações e volumes do EBS.
Em resumo, você implantará uma workload de amostra, incluindo as anotações personalizadas exigidas para que a integração com os serviços da AWS ocorra de forma perfeita.
## Neste tutorial
Usando o modelo de cluster do `eksctl` a seguir, você criará um cluster com o Modo Automático do EKS para provisionamento automatizado de nós.
+ **Configuração da VPC**: ao usar o modelo de cluster do eksctl apresentado a seguir, o eksctl cria automaticamente uma nuvem privada virtual (VPC) IPv4 para o cluster. Por padrão, o eksctl configura uma VPC que atende a todos os requisitos de rede, além de criar endpoints públicos e privados.
+ **Gerenciamento de instâncias** O modo automático do EKS adiciona ou remove nós dinamicamente no cluster do EKS com base nas demandas das aplicações do Kubernetes.
+ **Persistência de dados** use a funcionalidade de armazenamento em blocos do modo automático do EKS para garantir a persistência dos dados da aplicação, mesmo em cenários que envolvam reinicializações ou falhas de pods.
+ **Acesso externo à aplicação** use a funcionalidade de balanceamento de carga do modo automático do EKS para provisionar dinamicamente um Application Load Balancer (ALB).
## Pré-requisitos
Antes de começar, certifique-se de ter realizado as seguintes tarefas:
+ [Configuração do seu ambiente para o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Instalação da versão mais recente do eksctl](https://eksctl.io/installation/)
## Configurar o cluster
Nesta seção, você criará um cluster usando o Modo Automático do EKS para o provisionamento dinâmico de nós.
Crie um arquivo `cluster-config.yaml` e cole o conteúdo a seguir nele. Substitua `region-code` por uma região válida (por exemplo, `us-east-1`).
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: web-quickstart
region:
autoModeConfig:
enabled: true
```
Agora, estamos prontos para criar o cluster.
Crie o cluster EKS usando o `cluster-config.yaml``:
```
eksctl create cluster -f cluster-config.yaml
```
**Importante**
Caso não use o eksctl para criar o cluster, você precisará marcar manualmente as sub-redes da VPC.
## Criar IngressClass
Crie uma `IngressClass` do Kubernetes para o Modo Automático do EKS. A IngressClass define como o Modo Automático do EKS lida com os recursos de entrada. Esta etapa configura a capacidade de balanceamento de carga do Modo Automático do EKS. Quando você cria recursos de entrada para as aplicações, o Modo Automático do EKS usa essa IngressClass para provisionar e gerenciar automaticamente balanceadores de carga, integrando as aplicações do Kubernetes aos serviços de balanceamento de carga da AWS.
Salve o seguinte arquivo yaml como `ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
ingressclass.kubernetes.io/is-default-class: "true"
spec:
controller: eks.amazonaws.com/alb
```
Aplique a IngressClass ao cluster:
```
kubectl apply -f ingressclass.yaml
```
## Implantar a aplicação de exemplo do jogo 2048
Nesta seção, mostraremos as etapas para implantar o popular “jogo 2048” como uma aplicação de amostra no cluster. O manifesto fornecido inclui anotações personalizadas para o Application Load Balancer (ALB). Essas anotações se integram ao EKS e instruem o serviço a tratar o tráfego HTTP recebido como “exposto à internet” e direcioná-lo para o serviço apropriado no namespace `game-2048`, usando o tipo de destino “ip”.
**nota**
A imagem `docker-2048` no exemplo é uma imagem de contêiner `x86_64` e não será executada em outras arquiteturas.
1. Crie um namespace do Kubernetes denominado `game-2048` com o sinalizador `--save-config`.
```
kubectl create namespace game-2048 --save-config
```
Você verá a seguinte saída de resposta:
```
namespace/game-2048 created
```
1. Implante a [aplicação de amostra do jogo 2048](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml).
```
kubectl apply -n game-2048 -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml
```
Esse manifesto configura uma implantação, um serviço e uma entrada do Kubernetes para o namespace `game-2048`, criando os recursos necessários para implantar e expor a aplicação `game-2048` no cluster. Isso inclui a criação de um serviço denominado `service-2048` que expõe a implantação na porta `80` e um recurso de entrada denominado `ingress-2048` que define regras de roteamento para tráfego HTTP de entrada e anotações para um Application Load Balancer (ALB) voltado para a internet. Você verá a seguinte saída de resposta:
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```
1. Execute o comando a seguir para obter o recurso de entrada para o namespace `game-2048`.
```
kubectl get ingress -n game-2048
```
Você verá a seguinte saída de resposta:
```
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress-2048 alb * k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com 80 31s
```
Você precisará esperar alguns minutos para que o Application Load Balancer (ALB) seja provisionado antes de começar as etapas a seguir.
1. Abra o navegador da Web e digite o `ADDRESS` da etapa anterior para acessar a aplicação Web. Por exemplo:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Você deve ver o jogo 2048 no seu navegador. Reproduza.
![\[Jogar o jogo 2048\]](http://docs.aws.amazon.com/pt_br/eks/latest/userguide/images/quick2048.png)
## Persistir dados usando o Modo Automático do Amazon EKS
Agora que o jogo 2048 está instalado e em execução no cluster do Amazon EKS, é hora de garantir que os dados do jogo sejam persistidos com segurança usando o recurso de armazenamento em blocos do Modo Automático do Amazon 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
```
1. Crie uma solicitação de volume persistente (PVC) para solicitar armazenamento para os dados do seu jogo. Crie um arquivo denominado `ebs-pvc.yaml` e adicione o seguinte conteúdo a ele:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: game-data-pvc
namespace: game-2048
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
storageClassName: auto-ebs-sc
```
1. Aplique a PVC ao cluster:
```
kubectl apply -f ebs-pvc.yaml
```
Você verá a seguinte saída de resposta:
```
persistentvolumeclaim/game-data-pvc created
```
1. Você agora precisa atualizar a implantação do jogo 2048 para usar essa PVC para armazenar dados. A implantação a seguir está configurada para usar a PVC para armazenar dados do jogo. Crie um arquivo denominado `ebs-deployment.yaml` e adicione o seguinte conteúdo a ele:
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
replicas: 3 # Adjust the number of replicas as needed
selector:
matchLabels:
app.kubernetes.io/name: app-2048
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- name: app-2048
image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
ports:
- containerPort: 80
volumeMounts:
- name: game-data
mountPath: /var/lib/2048
volumes:
- name: game-data
persistentVolumeClaim:
claimName: game-data-pvc
```
1. Aplique a implantação atualizada:
```
kubectl apply -f ebs-deployment.yaml
```
Você verá a seguinte saída de resposta:
```
deployment.apps/deployment-2048 configured
```
Com essas etapas, o jogo 2048 no cluster agora está configurado para persistir os dados usando o recurso de armazenamento em blocos do Modo Automático do Amazon EKS. Isso garante que o progresso e os dados do jogo estejam seguros mesmo no caso de falhas nos pods ou nós.
Caso tenha gostado deste tutorial, deixe seu feedback para que possamos fornecer mais tutoriais de início rápido específicos para casos de uso, como este.
## Limpeza
Para evitar cobranças futuras, você precisará excluir manualmente a pilha associada do CloudFormation para excluir todos os recursos criados durante este guia, incluindo a rede VPC.
Exclua a pilha do CloudFormation:
```
eksctl delete cluster -f ./cluster-config.yaml
```