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

# Implantação de uma workload de amostra do balanceador de carga no modo automático do EKS
<a name="auto-elb-example"></a>

Este guia orienta você na implantação de uma versão em contêiner do jogo 2048 no Amazon EKS, completa com balanceamento de carga e acessibilidade à internet.

## Pré-requisitos
<a name="_prerequisites"></a>
+ Um cluster do Modo Automático do EKS
+  `kubectl` configurado para interagir com o cluster
+ Permissões do IAM apropriadas para criar recursos do ALB

## Etapa 1: criar o namespace
<a name="_step_1_create_the_namespace"></a>

Primeiro, crie um namespace dedicado para a aplicação do jogo 2048.

Crie um arquivo chamado `01-namespace.yaml`:

```
apiVersion: v1
kind: Namespace
metadata:
  name: game-2048
```

Aplique a configuração do namespace:

```
kubectl apply -f 01-namespace.yaml
```

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

A aplicação executa várias réplicas do contêiner do jogo 2048.

Crie um arquivo chamado `02-deployment.yaml`:

```
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: game-2048
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 5
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
        - image: public.ecr.aws/l6m2t8p7/docker-2048:latest
          imagePullPolicy: Always
          name: app-2048
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: "0.5"
```

**nota**  
Se você receber um erro ao carregar a imagem `public.ecr.aws/l6m2t8p7/docker-2048:latest`, verifique se o perfil do IAM do nó tem permissões suficientes para extrair imagens do ECR. Para obter mais informações, consulte [Perfil do IAM do nó](auto-learn-iam.md#auto-learn-node-iam-role). A imagem de `docker-2048` no exemplo também é uma imagem de `x86_64` e não será executada em outras arquiteturas.

 **Principais componentes:** 
+ Implanta cinco réplicas da aplicação
+ Usa uma imagem pública do ECR
+ Solicita 0,5 núcleo de CPU por pod
+ Expõe a porta 80 para o tráfego HTTP

Aplique a implantação:

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

## Etapa 3: criar o serviço
<a name="_step_3_create_the_service"></a>

O serviço expõe a implantação à rede do cluster.

Crie um arquivo chamado `03-service.yaml`:

```
apiVersion: v1
kind: Service
metadata:
  namespace: game-2048
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    app.kubernetes.io/name: app-2048
```

 **Principais componentes:** 
+ Cria um serviço do NodePort
+ Mapeia a porta 80 para a porta 80 do contêiner
+ Usa o seletor de rótulos para encontrar pods

Aplique o serviço:

```
kubectl apply -f 03-service.yaml
```

## Etapa 4: configurar o balanceamento de carga
<a name="_step_4_configure_load_balancing"></a>

Você vai configurar uma entrada para expor a aplicação à internet.

Primeiro, crie a `IngressClass`. Crie um arquivo chamado `04-ingressclass.yaml`:

```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  labels:
    app.kubernetes.io/name: LoadBalancerController
  name: alb
spec:
  controller: eks.amazonaws.com/alb
```

**nota**  
O Modo Automático do EKS precisa de tags de sub-rede para identificar sub-redes públicas e privadas.  
Se você criou o cluster com o `eksctl`, você já tem essas tags.  
Aprenda como [Marcar sub-redes para o Modo Automático do EKS](tag-subnets-auto.md).

Em seguida, crie o recurso Ingress. Crie um arquivo chamado `05-ingress.yaml`:

```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: game-2048
  name: ingress-2048
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: service-2048
                port:
                  number: 80
```

 **Principais componentes:** 
+ Cria um ALB voltado para a internet
+ Usa o tipo de destino IP para roteamento direto de pods
+ Roteia todo o tráfego (/) para o serviço do jogo

Aplique as configurações de entrada:

```
kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml
```

## Etapa 5: verificar a implantação
<a name="_step_5_verify_the_deployment"></a>

1. Verifique se todos os pods estão em execução:

   ```
   kubectl get pods -n game-2048
   ```

1. Verifique se o serviço foi criado:

   ```
   kubectl get svc -n game-2048
   ```

1. Obtenha o endpoint do ALB:

   ```
   kubectl get ingress -n game-2048
   ```

O campo ADDRESS na saída da entrada mostrará o endpoint do ALB. Aguarde de dois a três minutos para que o ALB provisione e registre todos os destinos.

## Etapa 6: acessar o jogo
<a name="_step_6_access_the_game"></a>

Abra seu navegador da Web e navegue até o URL do endpoint do ALB da etapa anterior. Você deve ver a interface do jogo 2048.

## Etapa 7: limpeza
<a name="_step_7_cleanup"></a>

Para remover todos os recursos criados neste tutorial:

```
kubectl delete namespace game-2048
```

Isso excluirá todos os recursos no namespace, incluindo os recursos de implantação, serviço e entrada.

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

1. A implantação cria cinco pods que executam o jogo 2048

1. O serviço fornece acesso de rede estável a esses pods

1. Modo Automático do EKS:
   + Cria um Application Load Balancer na AWS 
   + Configura grupos de destino para os pods
   + Configura as regras de roteamento para direcionar o tráfego ao serviço

## Solução de problemas
<a name="auto-elb-troubleshooting"></a>

Se o jogo não carregar:
+ Certifique-se de que todos os pods estejam em execução: `kubectl get pods -n game-2048` 
+ Verifique o status de entrada: `kubectl describe ingress -n game-2048` 
+ Confira as verificações de integridade do ALB: consulte a integridade do grupo de destino no Console da AWS