**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 IngressClass para configurar um Application Load Balancer
O Modo automático do EKS automatiza tarefas de rotina de balanceamento de carga, incluindo a exposição de aplicações de cluster à internet.
A AWS sugere o uso de Application Load Balancers (ALB) para fornecer tráfego HTTP e HTTPS. Os Application Load Balancers podem rotear solicitações com base no conteúdo da solicitação. Para obter mais informações sobre Application Load Balancers, consulte [What is Elastic Load Balancing?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html).
O Modo automático do EKS cria e configura Application Load Balancers (ALBs). Por exemplo, o Modo automático do EKS cria um balanceador de carga quando você cria um objeto `Ingress` do Kubernetes e o configura para rotear o tráfego para a workload do cluster.
**Visão geral**
1. Crie uma workload que você deseja expor à internet.
1. Crie um recurso `IngressClassParams`, especificando valores de configuração da AWS específicos, como o certificado a ser usado para sub-redes SSL/TLS e VPC.
1. Crie um recurso `IngressClass`, especificando que o Modo automático do EKS será o controlador do recurso.
1. Crie um recurso `Ingress` que associe um caminho HTTP e uma porta a uma workload do cluster.
O Modo automático do EKS criará um Application Load Balancer que aponte para a workload específica no recurso `Ingress`, usando a configuração do balanceador de carga específica no recurso `IngressClassParams`.
## Pré-requisitos
+ Modo automático do EKS habilitado em um cluster do Amazon EKS
+ Kubectl configurado para se conectar ao cluster
+ Você pode usar `kubectl apply -f ` para aplicar os arquivos YAML de configuração de exemplo abaixo ao cluster.
**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.
Saiba como [Marcar sub-redes para o Modo Automático do EKS](tag-subnets-auto.md).
## Etapa 1: criar uma workload
Para começar, crie uma workload que você deseja expor à internet. Pode ser qualquer recurso do Kubernetes que envia tráfego HTTP, como um Deployment e um Service.
Este exemplo usa um serviço HTTP simples, chamado `service-2048`, que atua como receptor na porta `80`. Crie este serviço e a sua implantação aplicando o seguinte manifesto, `2048-deployment-service.yaml`:
```
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: deployment-2048
spec:
selector:
matchLabels:
app.kubernetes.io/name: app-2048
replicas: 2
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
---
apiVersion: v1
kind: Service
metadata:
name: service-2048
spec:
ports:
- port: 80
targetPort: 80
protocol: TCP
type: NodePort
selector:
app.kubernetes.io/name: app-2048
```
Aplicar a configuração ao cluster:
```
kubectl apply -f 2048-deployment-service.yaml
```
Os recursos listados acima serão criados no namespace padrão. Você pode verificar isso executando o seguinte comando:
```
kubectl get all -n default
```
## Etapa 2: criar IngressClassParams
Crie um objeto `IngressClassParams` para especificar as opções de configuração da AWS específicas do Application Load Balancer. Neste exemplo, criamos um recurso `IngressClassParams` denominado `alb` (que você usará na próxima etapa) que especifica o esquema do balanceador de carga como `internet-facing` em um arquivo nomeado como `alb-ingressclassparams.yaml`.
```
apiVersion: eks.amazonaws.com/v1
kind: IngressClassParams
metadata:
name: alb
spec:
scheme: internet-facing
```
Aplicar a configuração ao cluster:
```
kubectl apply -f alb-ingressclassparams.yaml
```
## Etapa 3: criar IngressClass
Crie um `IngressClass` que faça referência aos valores de configuração específicos da AWS definidos no recurso `IngressClassParams` em um arquivo nomeado como `alb-ingressclass.yaml`. Registre o nome da `IngressClass`. Neste exemplo, tanto `IngressClass` como `IngressClassParams` são denominados `alb`.
Use a anotação `is-default-class` para controlar se os recursos `Ingress` devem usar essa classe por padrão.
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
# Use this annotation to set an IngressClass as Default
# If an Ingress doesn't specify a class, it will use the Default
ingressclass.kubernetes.io/is-default-class: "true"
spec:
# Configures the IngressClass to use EKS Auto Mode
controller: eks.amazonaws.com/alb
parameters:
apiGroup: eks.amazonaws.com
kind: IngressClassParams
# Use the name of the IngressClassParams set in the previous step
name: alb
```
Para obter mais informações sobre as opções de configuração, consulte [Referência IngressClassParams](#ingress-reference).
Aplicar a configuração ao cluster:
```
kubectl apply -f alb-ingressclass.yaml
```
## Etapa 4: criar Ingress
Crie um recurso `Ingress` em um arquivo nomeado como `alb-ingress.yaml`. O objetivo desse recurso é associar caminhos e portas no Application Load Balancer às workloads no cluster. Neste exemplo, criamos um recurso `Ingress` denominado `2048-ingress` que roteia o tráfego para um serviço denominado `service-2048` na porta 80.
Para obter mais informações sobre como configurar esse recurso, consulte [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) na documentação do Kubernetes.
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: 2048-ingress
spec:
# this matches the name of IngressClass.
# this can be omitted if you have a default ingressClass in cluster: the one with ingressclass.kubernetes.io/is-default-class: "true" annotation
ingressClassName: alb
rules:
- http:
paths:
- path: /*
pathType: ImplementationSpecific
backend:
service:
name: service-2048
port:
number: 80
```
Aplicar a configuração ao cluster:
```
kubectl apply -f alb-ingress.yaml
```
## Etapa 5: verificar o status
Use `kubectl` para encontrar o status de `Ingress`. Pode levar alguns minutos para que o balanceador de carga esteja disponível.
Use o nome do recurso `Ingress` que você definiu na etapa anterior. Por exemplo:
```
kubectl get ingress 2048-ingress
```
Quando o recurso estiver pronto, recupere o nome de domínio do balanceador de carga.
```
kubectl get ingress 2048-ingress -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'
```
Para visualizar o serviço em um navegador da web, verifique a porta e o caminho especificados no recurso `Ingress`.
## Etapa 6: limpeza
Para limpar o balanceador de carga, use o seguinte comando:
```
kubectl delete ingress 2048-ingress
kubectl delete ingressclass alb
kubectl delete ingressclassparams alb
```
O Modo automático do EKS excluirá automaticamente o balanceador de carga associado na conta da AWS.
## Referência IngressClassParams
A tabela abaixo é uma referência rápida das opções de configuração mais usadas.
| Campo | Descrição | Valor de exemplo |
| --- | --- | --- |
| `scheme` | Define se o ALB é interno ou voltado para a internet | `internet-facing` |
| `namespaceSelector` | Restringe quais namespaces podem usar esta IngressClass | `environment: prod` |
| `group.name` | Agrupa várias entradas para compartilhar um único ALB | `retail-apps` |
| `ipAddressType` | Define o tipo de endereço IP para o ALB | `dualstack` |
| `subnets.ids` | Lista de IDs de sub-rede para implantação do ALB | `subnet-xxxx, subnet-yyyy` |
| `subnets.tags` | Filtros de tag para selecionar sub-redes do ALB | `Environment: prod` |
| `certificateARNs` | ARNs de certificados SSL para usar | ` arn:aws:acm:region:account:certificate/id` |
| `tags` | Tags personalizadas de recursos da AWS | `Environment: prod, Team: platform` |
| `loadBalancerAttributes` | Atributos específicos do balanceador de carga | `idle_timeout.timeout_seconds: 60` |
## Considerações
+ Você não pode usar Anotações em uma IngressClass para configurar balanceadores de carga com o Modo automático do EKS. A configuração da IngressClass deve ser feita por meio do IngressClassParams. No entanto, você pode usar anotações em recursos individuais do Ingress para configurar o comportamento do balanceador de carga (como `alb.ingress.kubernetes.io/security-group-prefix-lists` ou `alb.ingress.kubernetes.io/conditions.*`).
+ Você não pode definir [ListenerAttribute](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_ListenerAttribute.html) com o modo automático do EKS.
+ Você deve atualizar o perfil do IAM do cluster para permitir a propagação de tags do Kubernetes para os recursos do AWS Load Balancer. Para obter mais informações, consulte [Tags da AWS personalizadas para recursos do Modo Automático do EKS.](auto-cluster-iam-role.md#tag-prop).
+ Para obter informações sobre como associar recursos ao Modo automático do EKS ou ao AWS Load Balancer Controller autogerenciado, consulte [Referência de migração](migrate-auto.md#migration-reference).
+ Para obter informações sobre como corrigir problemas com balanceadores de carga, consulte [Solucionar problemas do Modo Automático do EKS](auto-troubleshoot.md).
+ Para obter mais considerações sobre o uso do recurso de balanceamento de carga do Modo automático do EKS, consulte [Balanceamento de carga](auto-networking.md#auto-lb-consider).
As tabelas a seguir fornecem uma comparação detalhada das alterações nas configurações de IngressClassParams, anotações de Ingress e TargetGroupBinding do Modo automático do EKS. Essas tabelas destacam as principais diferenças entre a capacidade de balanceamento de carga do Modo automático do EKS e o controlador de balanceador de carga de código aberto, incluindo alterações na versão da API, recursos obsoletos e nomes de parâmetros atualizados.
### IngressClassParams
| Anterior | Novo | Descrição |
| --- | --- | --- |
| `elbv2.k8s.aws/v1beta1` | `eks.amazonaws.com/v1` | Alteração de versão da API |
| `spec.certificateArn` | `spec.certificateARNs` | Compatibilidade com vários ARNs de certificados |
| `spec.subnets.tags` | `spec.subnets.matchTags` | Esquema de correspondência de sub-rede alterado |
| `spec.listeners.listenerAttributes` | Não compatível | Ainda não há suporte para o modo automático do EKS |
### Anotações de Ingress
| Anterior | Novo | Descrição |
| --- | --- | --- |
| `kubernetes.io/ingress.class` | Não compatível | Use `spec.ingressClassName` em objetos Ingress |
| `alb.ingress.kubernetes.io/group.name` | Não compatível | Especifique grupos somente em IngressClass |
| `alb.ingress.kubernetes.io/waf-acl-id` | Não compatível | Use WAF v2 em vez disso |
| `alb.ingress.kubernetes.io/web-acl-id` | Não compatível | Use WAF v2 em vez disso |
| `alb.ingress.kubernetes.io/shield-advanced-protection` | Não compatível | Integração com Shield desabilitada |
| `alb.ingress.kubernetes.io/auth-type: oidc` | Não compatível | No momento, o tipo OIDC Auth não é compatível. |
### TargetGroupBinding
| Anterior | Novo | Descrição |
| --- | --- | --- |
| `elbv2.k8s.aws/v1beta1` | `eks.amazonaws.com/v1` | Alteração de versão da API |
| `spec.targetType` opcional | `spec.targetType` obrigatório | Especificação explícita do tipo de destino |
| `spec.networking.ingress.from` | Não compatível | Não oferece mais compatibilidade com NLB sem grupos de segurança |
Para usar o recurso personalizado TargetGroupBinding, é necessário marcar o grupo de destino com a etiqueta “eks:eks-cluster-name” contendo o nome do cluster para conceder ao controlador as permissões do IAM necessárias. Esteja ciente de que o controlador excluirá o grupo de destino quando o recurso TargetGroupBinding ou o cluster for excluído.