**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.
# Direcionar o tráfego da Internet com o AWS Load Balancer Controller
**dica**
[Registre-se](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) para os próximos workshops do Amazon EKS.
O AWS Load Balancer Controller gerencia o AWS Elastic Load Balancers para um cluster do Kubernetes. É possível usar o controlador para expor as aplicações no cluster para a Internet. O controlador provisiona balanceadores de carga da AWS que realizam o direcionamento para os recursos Service ou Ingress do cluster. Em outras palavras, o controlador cria um único endereço IP ou nome DNS que realiza o direcionamento para múltiplos pods em seu cluster.
![\[Diagrama de arquitetura. Ilustração do tráfego proveniente de usuários da Internet para o Amazon Load Balancer. O Amazon Load Balancer distribui o tráfego para os pods no cluster.\]](http://docs.aws.amazon.com/pt_br/eks/latest/userguide/images/lbc-overview.png)
O controlador observa os recursos Service e Ingress do Kubernetes. Em resposta, ele cria os recursos apropriados do AWS Elastic Load Balancing. É possível configurar um comportamento específico de balanceadores de carga ao aplicar anotações aos recursos do Kubernetes. Por exemplo, você pode anexar grupos de segurança da AWS a balanceadores de carga ao usar anotações.
O controlador fornece os seguintes recursos:
**Kubernetes `Ingress` **
O LBC cria um [AWS Application Load Balancer (ALB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html) quando você cria um Kubernetes `Ingress`. [Faça uma análise das anotações que você pode aplicar a um recurso Ingress.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/)
**Serviço do Kubernetes do tipo `LoadBalancer`**
O LBC cria um [AWS Network Load Balancer (NLB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html) quando você cria um serviço do Kubernetes do tipo `LoadBalancer`. [Faça uma análise das anotações que você pode aplicar a um recurso Service.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/)
Antigamente, o Network Load Balancer do Kubernetes era usado para destinos de *instâncias*, mas usava o LBC para destinos de *IPs*. Com o AWS Load Balancer Controller versão `2.3.0` ou mais recente, você pode criar NLBs usando qualquer tipo de destino. Para obter mais informações sobre os tipos de destino do NLB consulte [Tipo de destino](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-type) no Guia do usuário do Network Load Balancer.
O controlador é um [projeto de código aberto](https://github.com/kubernetes-sigs/aws-load-balancer-controller) gerenciado no GitHub.
Antes de implantar o controlador, recomendamos que você analise os pré-requisitos e as considerações em [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) e [Roteamento de tráfego TCP e UDP com Network Load Balancers](network-load-balancing.md). Nesses tópicos, você implantará uma aplicação de amostra que inclui um balanceador de carga da AWS.
**API `Gateway` do Kubernetes**
Com o AWS Load Balancer Controller na versão `2.14.0` ou em versões posteriores, o LBC cria um [Application Load Balancer (ALB) da AWS](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html) quando você cria um `Gateway` do Kubernetes. O gateway do Kubernetes oferece um nível maior de padronização de configuração em comparação à entrada, que precisava de anotações personalizadas para diversas opções comuns. [Analise as configurações que podem ser aplicadas a um recurso de gateway.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/gateway/gateway/) Para obter mais informações sobre a API `Gateway`, consulte a [API Gateway](https://kubernetes.io/docs/concepts/services-networking/gateway/) na documentação do Kubernetes.
## Instalar o controlador
É possível usar um dos seguintes procedimentos para instalar o AWS Load Balancer Controller:
+ Se ainda não conhece o Amazon EKS, recomendamos usar o Helm para simplificar a instalação do AWS Load Balancer Controller. Para obter mais informações, consulte [Instale o AWS Load Balancer Controller com o Helm](lbc-helm.md).
+ Para configurações avançadas, como clusters com acesso restrito à rede em registros de contêineres públicos, use manifestos do Kubernetes. Para obter mais informações, consulte [Instalar o AWS Load Balancer Controller com manifestos](lbc-manifest.md).
## Migração de versões descontinuadas do controlador
+ Se você tiver versões obsoletas do AWS Load Balancer Controller instaladas, consulte [Migrar aplicações do ALB Ingress Controller descontinuado](lbc-remove.md).
+ Não é possível atualizar versões descontinuadas. Essas versões devem ser removidas e uma versão atual do AWS Load Balancer Controller deve ser instalada.
+ As versões descontinuadas incluem:
+ AWS ALB Ingress Controller para Kubernetes ("Ingress Controller"), um antecessor do AWS Load Balancer Controller.
+ Qualquer versão `0.1.x ` do AWS Load Balancer Controller
## Provedor de nuvem herdado
O Kubernetes inclui um provedor de nuvem legado para a AWS. O provedor de nuvem legado é capaz de provisionar balanceadores de carga da AWS, que são semelhantes ao AWS Load Balancer Controller. O provedor de nuvem herdado cria Classic Load Balancers. Se você não instalar o AWS Load Balancer Controller, o Kubernetes usará o provedor de nuvem legado como padrão. É necessário instalar o AWS Load Balancer Controller e evitar o uso do provedor de nuvem legado.
**Importante**
Nas versões 2.5 e mais recentes, o AWS Load Balancer Controller passa a ser o controlador padrão para os recursos de *serviços* com o `type: LoadBalancer` e cria um AWS Network Load Balancer (NLB) para cada serviço. Ele faz isso criando um webhook mutante para serviços, que define o campo `spec.loadBalancerClass` como `service.k8s.aws/nlb` para novos serviços `type: LoadBalancer`. É possível desativar esse recurso e voltar a usar o [provedor de nuvem antigo](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/#legacy-cloud-provider) como o controlador padrão, definindo o valor `enableServiceMutatorWebhook` do chart do Helm para `false`. A menos que você desative esse recurso, o cluster não provisionará novos Classic Load Balancers para seus serviços. Os Classic Load Balancers existentes continuarão funcionando.
# Instale o AWS Load Balancer Controller com o Helm
**dica**
[Registre-se](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) para os próximos workshops do Amazon EKS.
**dica**
Com o Modo automático do Amazon EKS, você não precisa instalar ou atualizar complementos de rede. O Modo automático inclui recursos de rede de pods e balanceamento de carga.
Para obter mais informações, consulte [Automatizar a infraestrutura de clusters com o Modo Automático do EKS](automode.md).
Este tópico descreve como instalar o AWS Load Balancer Controller usando o Helm, um gerenciador de pacotes para o Kubernetes, e o `eksctl`. O controlador é instalado com as opções padrão. Para obter mais informações sobre o controlador, incluindo detalhes sobre como configurá-lo com anotações, consulte a [documentação do AWS Load Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) no GitHub.
Nas etapas a seguir, substitua os valores de exemplo pelos seus próprios valores.
## Pré-requisitos
Antes de começar este tutorial, conclua as seguintes etapas:
+ Crie um cluster do Amazon EKS. Para criar uma, consulte [Começar a usar o Amazon EKS](getting-started.md).
+ Instale o [Helm](https://helm.sh/docs/helm/helm_install/) na máquina local.
+ Certifique-se de que os complementos `kube-proxy`, CoreDNS e plug-in CNI da Amazon VPC para Kubernetes estejam nas versões mínimas listadas em [Tokens de contas de serviços](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Saiba mais sobre os conceitos do AWS Elastic Load Balancing. Para obter mais informações, consulte o [Manual do usuário do Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Saiba mais sobre os recursos de [entrada](https://kubernetes.io/docs/concepts/services-networking/service/) e [serviço](https://kubernetes.io/docs/concepts/services-networking/ingress/) do Kubernetes.
### Considerações
Antes de prosseguir com as etapas de configuração nesta página, considere o seguinte:
+ A política e o perfil (`AmazonEKSLoadBalancerControllerRole`) do IAM podem ser reutilizados em vários clusters de EKS na mesma conta da AWS.
+ Se você estiver instalando o controlador no mesmo cluster em que o perfil (`AmazonEKSLoadBalancerControllerRole`) foi criado originalmente, vá para a [Etapa 2: instalar o Load Balancer Controller](#lbc-helm-install) depois de verificar se o perfil existe.
+ Se você estiver usando perfis do IAM para contas de serviço (IRSA, da sigla em inglês), o IRSA deverá ser configurado para cada cluster, e o ARN do provedor OpenID Connect (OIDC) na política de confiança do perfil será específico para cada cluster de EKS. Além disso, se você estiver instalando o controlador em um novo cluster com um `AmazonEKSLoadBalancerControllerRole` existente, atualize a política de confiança do perfil para incluir o provedor OIDC do novo cluster e crie uma conta de serviço com a anotação de perfil apropriada. Para determinar se você já tem um provedor OIDC, ou para criar um, consulte [Criar um provedor de identidade OIDC do IAM para o cluster](enable-iam-roles-for-service-accounts.md).
## Etapa 1: criar um perfil do IAM usando a ferramenta `eksctl`
As etapas a seguir referem-se à versão de lançamento **v2.14.1** do AWS Load Balancer Controller. Para obter mais informações sobre todas as versões, consulte a [página de versões do AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) no GitHub.
1. Baixe uma política do IAM para o AWS Load Balancer Controller que permita que ele faça chamadas para APIs da AWS em seu nome.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy.json
```
+ Se você for uma partição da AWS não padrão, como um governo ou região da China, [consulte as políticas no GitHub](https://github.com/kubernetes-sigs/aws-load-balancer-controller/tree/main/docs/install) e baixe a política apropriada para sua região.
1. Crie uma política do IAM usando a política obtida por download na etapa anterior.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerIAMPolicy \
--policy-document file://iam_policy.json
```
**nota**
Se você visualizar a política no Console de gerenciamento da AWS, ele mostrará os avisos para o serviço **ELB**, mas não para o serviço **ELB v2**. Isso acontece porque algumas das ações da política existem para o **ELB v2**, mas não para o **ELB**. É possível ignorar esses avisos para o **ELB**..
1. Substitua os valores do nome do cluster, código da região e ID da conta.
```
eksctl create iamserviceaccount \
--cluster= \
--namespace=kube-system \
--name=aws-load-balancer-controller \
--attach-policy-arn=arn:aws:iam:::policy/AWSLoadBalancerControllerIAMPolicy \
--override-existing-serviceaccounts \
--region \
--approve
```
## Etapa 2: instalar o AWS Load Balancer Controller
1. Adicione o repositório de chart do Helm `eks-charts`. A AWS mantém [esse repositório](https://github.com/aws/eks-charts) no GitHub.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Atualize o repositório local para confirmar que você tem os gráficos mais recentes.
```
helm repo update eks
```
1. Instale o AWS Load Balancer Controller.
Se você estiver implantando o controlador nos nós do Amazon EC2 aos quais você tem [acesso restrito ao serviço de metadados de instância (IMDS) do Amazon EC2](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node), ou se você estiver implantando no Fargate ou no Amazon EKS Hybrid Nodes, adicione os seguintes sinalizadores ao comando do `helm`:
+ `--set region=region-code `
+ `--set vpcId=vpc-xxxxxxxx `
Substitua *my-cluster* pelo nome do cluster. No comando a seguir, `aws-load-balancer-controller` é a conta de serviço do Kubernetes que você criou em uma etapa anterior.
Para obter mais informações sobre a configuração do gráfico de leme, consulte [values.yaml](https://github.com/aws/eks-charts/blob/master/stable/aws-load-balancer-controller/values.yaml) no GitHub.
```
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
-n kube-system \
--set clusterName=my-cluster \
--set serviceAccount.create=false \
--set serviceAccount.name=aws-load-balancer-controller \
--version 1.14.0
```
**Importante**
O gráfico implantado não recebe atualizações de segurança automaticamente. Você precisa atualizar manualmente para um gráfico mais recente quando ele estiver disponível. Ao fazer o upgrade, altere *install* para `upgrade` no comando anterior.
O comando `helm install` instala automaticamente as definições de recursos personalizados (CRDs) do controlador. O comando `helm upgrade` não realiza essa instalação. Caso use `helm upgrade,`, será necessário instalar manualmente as CRDs. Execute o seguinte comando para instalar as CRDs:
```
wget https://raw.githubusercontent.com/aws/eks-charts/master/stable/aws-load-balancer-controller/crds/crds.yaml
kubectl apply -f crds.yaml
```
## Etapa 3: verificar se o controlador está instalado
1. Verifique se o controlador está instalado.
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
Veja um exemplo de saída abaixo.
```
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 84s
```
Você recebe a saída anterior se tiver implantado usando o Helm. Se você implantou usando o manifesto do Kubernetes, só tem uma réplica.
1. Antes de usar o controlador para provisionar os recursos da AWS, o cluster doverá cumprir requisitos específicos. Para obter mais informações, consulte [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) e [Roteamento de tráfego TCP e UDP com Network Load Balancers](network-load-balancing.md).
# Instalar o AWS Load Balancer Controller com manifestos
**dica**
Com o Modo Automático do Amazon EKS, você não precisa instalar ou atualizar complementos de rede. O Modo automático inclui recursos de rede de pods e balanceamento de carga.
Para obter mais informações, consulte [Automatizar a infraestrutura de clusters com o Modo Automático do EKS](automode.md).
Este tópico descreve como instalar o controlador ao fazer download e aplicar os manifestos do Kubernetes. Você pode visualizar a [documentação](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/) para o controlador no GitHub.
Nas etapas a seguir, substitua os valores de exemplo pelos seus próprios valores.
## Pré-requisitos
Antes de começar este tutorial, conclua as seguintes etapas:
+ Crie um cluster do Amazon EKS. Para criar uma, consulte [Começar a usar o Amazon EKS](getting-started.md).
+ Instale o [Helm](https://helm.sh/docs/helm/helm_install/) na máquina local.
+ Certifique-se de que os complementos `kube-proxy`, CoreDNS e plug-in CNI da Amazon VPC para Kubernetes estejam nas versões mínimas listadas em [Tokens de contas de serviços](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Saiba mais sobre os conceitos do AWS Elastic Load Balancing. Para obter mais informações, consulte o [Manual do usuário do Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Saiba mais sobre os recursos de [entrada](https://kubernetes.io/docs/concepts/services-networking/service/) e [serviço](https://kubernetes.io/docs/concepts/services-networking/ingress/) do Kubernetes.
### Considerações
Antes de prosseguir com as etapas de configuração nesta página, considere o seguinte:
+ A política e o perfil (`AmazonEKSLoadBalancerControllerRole`) do IAM podem ser reutilizados em vários clusters do EKS na mesma conta da AWS.
+ Se você estiver instalando o controlador no mesmo cluster em que o perfil (`AmazonEKSLoadBalancerControllerRole`) foi criado originalmente, vá para a [Etapa 2: instalar o cert-manager](#lbc-cert) depois de verificar se o perfil existe.
+ Se você estiver usando perfis do IAM para contas de serviço (IRSA, da sigla em inglês), o IRSA deverá ser configurado para cada cluster, e o ARN do provedor OpenID Connect (OIDC) na política de confiança do perfil será específico para cada cluster do EKS. Além disso, se você estiver instalando o controlador em um novo cluster com um `AmazonEKSLoadBalancerControllerRole` existente, atualize a política de confiança do perfil para incluir o provedor OIDC do novo cluster e crie uma conta de serviço com a anotação de perfil apropriada. Para determinar se você já tem um provedor OIDC, ou para criar um, consulte [Criar um provedor de identidade OIDC do IAM para o cluster](enable-iam-roles-for-service-accounts.md).
## Etapa 1: configurar o IAM
As etapas a seguir referem-se à versão de lançamento **v2.14.1** do AWS Load Balancer Controller. Para obter mais informações sobre todas as versões, consulte a [página de versões do AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) no GitHub.
1. Baixe uma política do IAM para o AWS Load Balancer Controller que permita que ele faça chamadas para APIs da AWS em seu nome.
**Example**
------
#### [ AWS ]
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy.json
```
------
#### [ AWS GovCloud (US) ]
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy_us-gov.json
```
```
mv iam_policy_us-gov.json iam_policy.json
```
------
1. Crie uma política do IAM usando a política obtida por download na etapa anterior.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerIAMPolicy \
--policy-document file://iam_policy.json
```
**nota**
Se você visualizar a política no Console de gerenciamento da AWS, ele mostrará os avisos para o serviço **ELB**, mas não para o serviço **ELB v2**. Isso acontece porque algumas das ações da política existem para o **ELB v2**, mas não para o **ELB**. Você pode ignorar esses avisos para o **ELB**..
**Example**
1. Substitua *my-cluster* pelo nome do seu cluster e *111122223333* pelo ID da conta e, então, execute o comando.
```
eksctl create iamserviceaccount \
--cluster=my-cluster \
--namespace=kube-system \
--name=aws-load-balancer-controller \
--role-name AmazonEKSLoadBalancerControllerRole \
--attach-policy-arn=arn:aws:iam::111122223333:policy/AWSLoadBalancerControllerIAMPolicy \
--approve
```
1. Recupere o ID do provedor OIDC do cluster e armazene-o em uma variável.
```
oidc_id=$(aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
```
1. Determine se um provedor OIDC do IAM com o ID do cluster já está em sua conta. Você precisa do OIDC configurado para o cluster e o IAM.
```
aws iam list-open-id-connect-providers | grep $oidc_id | cut -d "/" -f4
```
Se um resultado for retornado, isso significa que você já tem um provedor OIDC do IAM para o cluster. Se nenhum resultado for retornado, você deverá criar um provedor OIDC do IAM do seu cluster. Para obter mais informações, consulte [Criar um provedor de identidade OIDC do IAM para o cluster](enable-iam-roles-for-service-accounts.md).
1. Copie o conteúdo a seguir para o seu dispositivo. Substitua *111122223333* pelo ID da sua conta. Substitua *region-code* pela região da AWS em que seu cluster se encontra. Substitua *EXAMPLED539D4633E53DE1B71EXAMPLE* pela saída retornada na etapa anterior.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:aws-load-balancer-controller"
}
}
}
]
}
```
1. Crie o perfil do IAM.
```
aws iam create-role \
--role-name AmazonEKSLoadBalancerControllerRole \
--assume-role-policy-document file://"load-balancer-role-trust-policy.json"
```
1. Anexe a política de IAM gerenciada pelo Amazon EKS ao perfil do IAM. Substitua *111122223333* pelo ID da sua conta.
```
aws iam attach-role-policy \
--policy-arn arn:aws:iam::111122223333:policy/AWSLoadBalancerControllerIAMPolicy \
--role-name AmazonEKSLoadBalancerControllerRole
```
1. Copie o conteúdo a seguir para o seu dispositivo. Substitua *111122223333* pelo ID da sua conta. Após substituir o texto, execute o comando modificado para criar o arquivo `aws-load-balancer-controller-service-account.yaml`.
```
cat >aws-load-balancer-controller-service-account.yaml <
Instale `cert-manager` usando um dos métodos a seguir para injetar a configuração do certificado nos webhooks. Para obter mais informações, consulte [Conceitos básicos](https://cert-manager.io/docs/installation/#getting-started) na *Documentação do cert-manager*.
Recomendamos usar o registro de contêiner `quay.io` para instalar `cert-manager`. Se os nós não tiverem acesso ao registro de contêiner `quay.io`, instale `cert-manager` usando o Amazon ECR (veja abaixo).
**Example**
1. Se os nós tiverem acesso ao registro do contêiner `quay.io`, instale `cert-manager` para injetar a configuração do certificado nos webhooks.
```
kubectl apply \
--validate=false \
-f https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
```
1. Instale `cert-manager` usando um dos métodos a seguir para injetar a configuração do certificado nos webhooks. Para obter mais informações, consulte [Conceitos básicos](https://cert-manager.io/docs/installation/#getting-started) na *Documentação do cert-manager*.
1. Faça download do manifesto.
```
curl -Lo cert-manager.yaml https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
```
1. Extraia as imagens a seguir e envie-as para um repositório ao qual seus nós têm acesso. Para obter mais informações sobre como extrair, etiquetar e enviar as imagens para seu próprio repositório, consulte [Copiar uma imagem de contêiner de um repositório para outro](copy-image-to-repository.md).
```
quay.io/jetstack/cert-manager-cainjector:v1.13.5
quay.io/jetstack/cert-manager-controller:v1.13.5
quay.io/jetstack/cert-manager-webhook:v1.13.5
```
1. Substitua `quay.io` no manifesto nas três imagens pelo seu próprio nome de registro. O comando a seguir pressupõe que o nome do repositório privado seja o mesmo que o repositório de origem. Substitua *111122223333.dkr.ecr.region-code.amazonaws.com* pelo seu registro privado.
```
sed -i.bak -e 's|quay.io|111122223333.dkr.ecr.region-code.amazonaws.com|' ./cert-manager.yaml
```
1. Aplique o manifesto.
```
kubectl apply \
--validate=false \
-f ./cert-manager.yaml
```
## Etapa 3: instalar o AWS Load Balancer Controller
1. Faça download da especificação do controlador. Para obter mais informações sobre o controlador, consulte a [documentação](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) do GitHub.
```
curl -Lo v2_14_1_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.14.1/v2_14_1_full.yaml
```
1. Faça as edições a seguir ao arquivo.
1. Se você tiver baixado o arquivo `v2_14_1_full.yaml`, execute o seguinte comando para remover a seção `ServiceAccount` no manifesto. Se você não remover essa seção, a anotação necessária que você fez na conta de serviço em uma etapa anterior será substituída. A remoção dessa seção também preservará a conta de serviço criada em uma etapa anterior se você excluir o controlador.
```
sed -i.bak -e '764,772d' ./v2_14_1_full.yaml
```
Se você tiver baixado uma versão de arquivo diferente, abra o arquivo em um editor e remova as linhas a seguir.
```
apiVersion: v1
kind: ServiceAccount
metadata:
labels:
app.kubernetes.io/component: controller
app.kubernetes.io/name: aws-load-balancer-controller
name: aws-load-balancer-controller
namespace: kube-system
---
```
1. Substitua `your-cluster-name` na seção `Deployment` `spec` do arquivo pelo nome do cluster substituindo *my-cluster* pelo nome do seu cluster.
```
sed -i.bak -e 's|your-cluster-name|my-cluster|' ./v2_14_1_full.yaml
```
1. Se seus nós não tiverem acesso aos repositórios de imagens do Amazon ECR do Amazon EKS, você precisará extrair a image a seguir e enviá-la a um repositório ao qual seus nós tenham acesso. Para obter mais informações sobre como extrair, etiquetar e enviar uma imagem para seu próprio repositório, consulte [Copiar uma imagem de contêiner de um repositório para outro](copy-image-to-repository.md).
```
public.ecr.aws/eks/aws-load-balancer-controller:v2.14.1
```
Adicione o nome do registro ao manifesto. O comando a seguir pressupõe que o nome do repositório privado seja o mesmo que o repositório de origem e adicione o nome do seu registro privado para o arquivo. Substitua *111122223333.dkr.ecr.region-code.amazonaws.com* pelo seu registro. Essa linha pressupõe que você nomeou seu repositório privado da mesma forma que o repositório de origem. Caso contrário, altere o texto de `eks/aws-load-balancer-controller` após o nome do registro privado para o nome do repositório.
```
sed -i.bak -e 's|public.ecr.aws/eks/aws-load-balancer-controller|111122223333.dkr.ecr.region-code.amazonaws.com/eks/aws-load-balancer-controller|' ./v2_14_1_full.yaml
```
1. (Obrigatório somente para o Fargate ou para um IMDS restrito)
Se você estiver implantando o controlador nos nós do Amazon EC2 que têm [acesso restrito ao serviço de metadados de instância (IMDS) do Amazon EC2](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node), ou se você estiver implantando no Fargate ou no Amazon EKS Hybrid Nodes, adicione os `following parameters` em `- args:`.
```
[...]
spec:
containers:
- args:
- --cluster-name=your-cluster-name
- --ingress-class=alb
- --aws-vpc-id=vpc-xxxxxxxx
- --aws-region=region-code
[...]
```
1. Aplique o arquivo.
```
kubectl apply -f v2_14_1_full.yaml
```
1. Baixe os manifestos `IngressClass` e `IngressClassParams` para seu cluster.
```
curl -Lo v2.14.1_ingclass.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.14.1/v2_14_1_ingclass.yaml
```
1. Aplique o manifesto ao cluster.
```
kubectl apply -f v2_14_1_ingclass.yaml
```
## Etapa 4: verificar se o controlador está instalado
1. Verifique se o controlador está instalado.
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
Veja um exemplo de saída abaixo.
```
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 84s
```
Você recebe a saída anterior se tiver implantado usando o Helm. Se você implantou usando o manifesto do Kubernetes, só tem uma réplica.
1. Antes de usar o controlador para provisionar os recursos da AWS, o cluster doverá cumprir requisitos específicos. Para obter mais informações, consulte [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) e [Roteamento de tráfego TCP e UDP com Network Load Balancers](network-load-balancing.md).
# Migrar aplicações do ALB Ingress Controller descontinuado
Este tópico descreve como migrar de versões descontinuadas do controlador. Mais especificamente, ele descreve como remover versões descontinuadas do AWS Load Balancer Controller.
+ Não é possível atualizar versões descontinuadas. Você deve removê-las primeiro e depois instalar uma versão atual.
+ As versões descontinuadas incluem:
+ AWS ALB Ingress Controller para Kubernetes ("Ingress Controller"), um antecessor do AWS Load Balancer Controller.
+ Qualquer versão `0.1.x ` do AWS Load Balancer Controller
## Remover a versão obsoleta do controlador
**nota**
É possível que você tenha instalado a versão descontinuada usando o Helm ou de forma manual com manifestos do Kubernetes. Conclua o procedimento utilizando a ferramenta com a qual ele foi originalmente instalado.
1. Se você instalou o chart do Helm `incubator/aws-alb-ingress-controller`, desinstale-o.
```
helm delete aws-alb-ingress-controller -n kube-system
```
1. Se tiver a versão `0.1.x ` do chart `eks-charts/aws-load-balancer-controller` instalado, desinstale-a. O upgrade de `0.1.x ` para a versão `1.0.0` não funciona por causa de uma incompatibilidade com a versão da API do webhook.
```
helm delete aws-load-balancer-controller -n kube-system
```
1. Verifique se o controlador está instalado no momento.
```
kubectl get deployment -n kube-system alb-ingress-controller
```
Esta é a saída se o controlador não estiver instalado.
```
Error from server (NotFound): deployments.apps "alb-ingress-controller" not found
```
Esta é a saída se o controlador estiver instalado.
```
NAME READY UP-TO-DATE AVAILABLE AGE
alb-ingress-controller 1/1 1 1 122d
```
1. Insira o comando a seguir para executar o controlador.
```
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/aws-alb-ingress-controller/v1.1.8/docs/examples/alb-ingress-controller.yaml
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/aws-alb-ingress-controller/v1.1.8/docs/examples/rbac-role.yaml
```
## Migrar para o AWS Load Balancer Controller
Para migrar do ALB Ingress Controller para Kubernetes para o AWS Load Balancer Controller, você precisa:
1. Remover o ALB Ingress Controller (veja as etapas anteriores).
1. [Instale o AWS Load Balancer Controller.](aws-load-balancer-controller.md#lbc-overview)
1. Adicionar mais uma política ao perfil do IAM usado pelo AWS Load Balancer Controller. Esta política permite que o LBC gerencie recursos criados pelo ALB Ingress Controller para Kubernetes.
1. Faça download da política do IAM. Esta política permite que o AWS Load Balancer Controller gerencie recursos criados pelo ALB Ingress Controller para Kubernetes. Você também pode [visualizar a política ](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy_v1_to_v2_additional.json).
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy_v1_to_v2_additional.json
```
1. Se o seu cluster estiver nas regiões AWS GovCloud (US-East) ou AWS GovCloud (US-West) AWS, substitua ` arn:aws: ` por `arn:aws-us-gov:`.
```
sed -i.bak -e 's|arn:aws:|arn:aws-us-gov:|' iam_policy_v1_to_v2_additional.json
```
1. Crie a política do IAM e observe o ARN retornado.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerAdditionalIAMPolicy \
--policy-document file://iam_policy_v1_to_v2_additional.json
```
1. Anexe a política do IAM ao perfil do IAM usado pelo AWS Load Balancer Controller. Substitua *your-role-name* pelo nome do perfil, como `AmazonEKSLoadBalancerControllerRole`.
Se você criou o perfil usando o `eksctl`, para localizar o nome do perfil criado, abra o [console do AWS CloudFormation](https://console.aws.amazon.com/cloudformation) e selecione a pilha **eksctl-*my-cluster*-addon-iamserviceaccount-kube-system-aws-load-balancer-controller**. Selecione a guia **Recursos**. O nome da função está na coluna **ID físico**.
```
aws iam attach-role-policy \
--role-name your-role-name \
--policy-arn arn:aws:iam::111122223333:policy/AWSLoadBalancerControllerAdditionalIAMPolicy
```