

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

# Instalar o AWS Load Balancer Controller com manifestos
<a name="lbc-manifest"></a>

**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
<a name="lbc-manifest-prereqs"></a>

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
<a name="lbc-manifest-considerations"></a>

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
<a name="lbc-iam"></a>

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 <<EOF
   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
     annotations:
       eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/AmazonEKSLoadBalancerControllerRole
   EOF
   ```

1. Crie a conta de serviço do Kubernetes no cluster: Conta de serviço do Kubernetes denominada `aws-load-balancer-controller` é anotada com o perfil do IAM que você criou, chamada *AmazonEKSLoadBalancerControllerRole*..

   ```
   kubectl apply -f aws-load-balancer-controller-service-account.yaml
   ```

## Etapa 2: instalar o `cert-manager`
<a name="lbc-cert"></a>

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
<a name="lbc-install"></a>

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
<a name="lbc-verify"></a>

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