As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Configuração de um Application Load Balancer
Quando você [ativa o balanceamento de carga](using-features-managing-env-types.md#using-features.managing.changetype), seu AWS Elastic Beanstalk ambiente é equipado com um balanceador de carga do Elastic Load Balancing para distribuir o tráfego entre as instâncias em seu ambiente. O Elastic Load Balancing é compatível com vários tipos de balanceador de carga. Para saber mais sobre eles, consulte o [Guia do usuário do Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/). O Elastic Beanstalk pode criar um balanceador de carga para você ou permitir a especificação de um balanceador de carga compartilhado que você criou.
Este tópico descreve a configuração de um [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/) que o Elastic Beanstalk cria e dedica ao seu ambiente. Consulte também [Configurar um Application Load Balancer compartilhado](environments-cfg-alb-shared.md). Para obter informações sobre como configurar todos os tipos de balanceador de carga compatíveis com o Elastic Beanstalk, consulte [Balanceador de carga do ambiente do Elastic Beanstalk](using-features.managing.elb.md).
**nota**
Você só pode escolher o tipo de load balancer que seu ambiente usará durante a criação do ambiente. Você pode alterar as configurações para gerenciar o comportamento do load balancer do ambiente em execução, mas não pode alterar seu tipo. Também não é possível alternar de um load balancer dedicado para um compartilhado ou vice-versa.
## Introdução
Um Application Load Balancer inspeciona o tráfego na camada de protocolo de rede da aplicação para identificar o caminho do pedido de modo que ele possa direcionar solicitações de caminhos diferentes para destinos diferentes.
Quando seu ambiente usa um Application Load Balancer, o Elastic Beanstalk o configura por padrão para executar a mesma função que um Classic Load Balancer. O listener padrão aceita solicitações de HTTP na porta 80 e as distribui para as instâncias no ambiente. É possível adicionar um listener seguro na porta 443 com um certificado para descriptografar o tráfego de HTTPS, configurar o comportamento de verificação de integridade e enviar os registros de acesso do balanceador de carga para um bucket do Amazon Simple Storage Service (Amazon S3).
**nota**
Diferentemente de um Classic Load Balancer ou de um Network Load Balancer, um Application Load Balancer não pode ter TCP ou ouvintes na camada de transporte (camada 4). SSL/TLS Suporta apenas listeners HTTP e HTTPS. Além disso, não é possível usar a autenticação de back-end para autenticar conexões HTTPS entre o load balancer e as instâncias de back-end.
Em um ambiente do Elastic Beanstalk, é possível usar um Application Load Balancer para direcionar o tráfego de determinados caminhos para um processo diferente em suas instâncias do servidor Web. Com um Classic Load Balancer, todo o tráfego para o listener é roteado para um único processo nas instâncias de back-end. Com um Application Load Balancer, é possível configurar várias *regras* no listener para rotear as solicitações para determinados caminhos para um processo de back-end diferente. Configure cada processo com a porta na qual o processo escuta.
Por exemplo, é possível executar um processo de login separadamente do aplicativo principal. Embora o aplicativo principal nas instâncias do seu ambiente aceite a maioria das solicitações e observe a porta 80, seu processo de login observará a porta 5000 e aceitará solicitações para o caminho `/login`. Todas as solicitações de entrada dos clientes vêm na porta 80. Com um Application Load Balancer, é possível configurar um único listener para o tráfego de entrada na porta 80, com duas regras que direcionam o tráfego para dois processos separados, dependendo do caminho na solicitação. Adicione uma regra personalizada que direcione o tráfego para `/login` para o processo de logon que escuta na porta 5000. A regra padrão encaminha todos os outros tráfegos para o processo principal do aplicativo, observando a porta 80.
Uma regra do Application Load Balancer mapeia uma solicitação para um *grupo de destino*. No Elastic Beanstalk, um grupo de destino é representado por um *processo*. Você pode configurar um processo com configurações de protocolo, porta e verificação de integridade. O processo representa a execução nas instâncias em seu ambiente. O processo padrão é um listener na porta 80 do proxy reverso (nginx ou Apache) que é executado na frente de seu aplicativo.
**nota**
Fora do Elastic Beanstalk, um grupo de destino é mapeado para um grupo de instâncias. Um listener pode usar regras e grupos de destino para rotear o tráfego para instâncias diferentes com base no caminho. Dentro do Elastic Beanstalk, todas as instâncias no ambiente são idênticas, então a distinção é feita entre os processos escutando em portas diferentes.
Um Classic Load Balancer usa um único caminho de verificação de integridade para todo o ambiente. Com um Application Load Balancer, cada processo tem um caminho de verificação de integridade separado que é monitorado pelo balanceador de carga e pelo monitoramento de integridade aprimorado do Elastic Beanstalk.
Para usar o Application Load Balancer, seu ambiente deve estar em uma VPC personalizada ou padrão e deve ter uma função de serviço com o conjunto padrão de permissões. Se você tiver uma função de serviço mais antiga, talvez seja necessário [atualizar as permissões](iam-instanceprofile.md#iam-instanceprofile-addperms) dela para incluir `elasticloadbalancing:DescribeTargetHealth` e `elasticloadbalancing:DescribeLoadBalancers`. Para obter mais informações sobre os Application Load Balancers, consulte [O que é Application Load Balancer?](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/).
**nota**
A verificação de integridade do Application Load Balancer não usa o caminho da verificação de integridade do Elastic Beanstalk. Em vez disso, ele usa o caminho específico configurado para cada processo separadamente.
## Configurar um Application Load Balancer usando o console do Elastic Beanstalk
É possível usar o console do Elastic Beanstalk para configurar os listeners, processos e regras de um Application Load Balancer durante a criação do ambiente ou posterior quando seu ambiente estiver em execução.
**Como configurar um Application Load Balancer no console do Elastic Beanstalk durante a criação do ambiente**
1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS
1. No painel de navegação, escolha **Ambientes**.
1. Escolha [Create a new environment (Criar um ambiente)](environments-create-wizard.md) para começar a criar seu ambiente.
1. Na página principal do assistente, antes de escolher **Create environment**, escolha **Configure more options**.
1. Escolha a predefinição de configuração **High availability (Alta disponibilidade)**.
Se preferir, na categoria de configuração **Capacity (Capacidade)**, configure o tipo de ambiente **Load balanced (Carga equilibrada)**. Para obter detalhes, consulte [Capacity](environments-create-wizard.md#environments-create-wizard-capacity).
1. Na categoria de configuração **Load balancer**, escolha **Edit (Editar)**.
1. Selecione as opções **Application Load Balancer** e **Dedicated (Dedicado)** se elas ainda não estiverem selecionadas.
1. Faça todas as alterações de configuração do Application Load Balancer necessárias ao seu ambiente.
1. Escolha **Save** e, em seguida, faça as outras alterações de configuração de acordo com seu ambiente.
1. Selecione **Criar ambiente**.
**Como configurar o Application Load Balancer de um ambiente em execução no console do Elastic Beanstalk**
1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS
1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.
1. No painel de navegação, escolha **Configuration (Configuração)**.
1. Na categoria de configuração **Load balancer**, escolha **Edit (Editar)**.
**nota**
Se a categoria de configuração **Load balancer** não tem um botão **Edit (Editar)**, seu ambiente não tem um load balancer. Para aprender como configurar um, consulte [Alterar tipo de ambiente](using-features-managing-env-types.md#using-features.managing.changetype).
1. Faça as alterações de configuração do Application Load Balancer necessárias ao seu ambiente.
1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.
**Topics**
+ [Listeners](#environments-cfg-alb-console-listeners)
+ [Processos](#environments-cfg-alb-console-processes)
+ [Regras](#environments-cfg-alb-console-rules)
+ [Captura de log de acesso](#environments-cfg-alb-console-logs)
### Listeners
Use esta lista para especificar listeners para seu load balancer. Cada listener direciona o tráfego de entrada do cliente em uma porta especificada usando um protocolo especificado para um ou mais processos nas suas instâncias. Inicialmente, a lista mostra o listener padrão, que encaminha o tráfego HTTP de entrada na porta 80 para um processo chamado **padrão**.
**Para configurar um listener existente**
1. Marque a caixa de seleção ao lado da entrada da tabela e, em seguida, escolha **Actions**, **Edit**.
1. Use a caixa de diálogo **Application Load Balancer listener** para editar as configurações e, em seguida, escolha **Save**.
**Para adicionar um listener**
1. Escolha **Add listener**.
1. Na caixa de diálogo **Application Load Balancer listener (Listener do Application Load Balancer)**, defina as configurações desejadas e selecione **Add (Adicionar)**.
Use as configurações da caixa de diálogo **Listener do Application Load Balancer** para escolher a porta e o protocolo nos quais o ouvinte escuta o tráfego, bem como o processo para encaminhar o tráfego. Se você escolher o protocolo HTTPS, defina as configurações de SSL.
Antes de configurar um listener HTTPS, verifique se você tem um certificado SSL válido. Execute um destes procedimentos:
+ Se AWS Certificate Manager (ACM) estiver [disponível em sua AWS região](https://docs.aws.amazon.com/general/latest/gr/acm.html), crie ou importe um certificado usando o ACM. Para obter mais informações sobre como solicitar um certificado do ACM, consulte [Solicitação de um certificado](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html) no *Manual do usuário do AWS Certificate Manager *. Para obter mais informações sobre a importação de certificados de terceiros para o ACM, consulte [Importação de certificados](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html) no *Manual do usuário do AWS Certificate Manager *.
+ Se o ACM não estiver [disponível na sua AWS região](https://docs.aws.amazon.com/general/latest/gr/acm.html), faça o upload do certificado e da chave existentes para o IAM. Para obter mais informações sobre a criação e o upload de certificados para o IAM, consulte [Trabalhar com certificados de servidor](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingServerCerts.html) no *Guia do usuário do IAM*.
Para obter mais detalhes sobre como configurar o HTTPS e trabalhar com os certificados no Elastic Beanstalk, consulte [Configurar HTTPS para o seu ambiente do Elastic Beanstalk](configuring-https.md).
### Processos
Use esta lista para especificar processos para seu load balancer. Um processo é um destino para os listeners direcionarem o tráfego. Cada listener direciona o tráfego de entrada do cliente em uma porta especificada usando um protocolo especificado para um ou mais processos nas suas instâncias. Inicialmente, a lista mostra o processo padrão, que observa o tráfego HTTP de entrada na porta 80.
Você pode editar as configurações de um processo existente ou adicionar um novo processo. Para começar a editar um processo na lista ou adicionar um processo a ele, use as mesmas etapas listadas para [lista de listener](#environments-cfg-alb-console-listeners). A caixa de diálogo **Environment process** é exibida.
**Topics**
+ [Definição](#environments-cfg-alb-console-process-definition)
+ [Verificação de saúde](#environments-cfg-alb-console-process-healthchecks)
+ [Sessões](#environments-cfg-alb-console-process-sessions)
#### Definição
Use estas configurações para definir o processo **Name**, **Port** e **Protocol** em que as solicitações são observadas.
#### Verificação de saúde
Use as configurações a seguir para configurar as verificações de integridade do processo:
+ **HTTP code (Código de HTTP)**: o código de status HTTP que designa um processo íntegro.
+ **Path (Caminho)**: o caminho da solicitação de verificação de integridade para o processo.
+ **Timeout (Tempo limite)**: a quantidade de tempo, em segundos, para aguardar uma resposta de verificação de integridade.
+ **Interval (Intervalo)**: a quantidade de tempo, em segundos, entre as verificações de integridade de uma instância individual. O intervalo deve ser maior que o tempo limite.
+ **Unhealthy threshold (Limite não íntegro)**, **Healthy threshold (Limite íntegro)**: o número de verificações de integridade que devem falhar ou passar, respectivamente, antes que o Elastic Load Balancing altere o estado de integridade de uma instância.
+ **Deregistration delay (Atraso do cancelamento de registro)**: a quantidade de tempo, em segundos, para aguardar que as solicitações ativas sejam concluídas antes de cancelar o registro de uma instância.
**nota**
A verificação de integridade do Elastic Load Balancing não afeta o comportamento da verificação de integridade do grupo de Auto Scaling de um ambiente. As instâncias que falham em uma verificação de saúde do Elastic Load Balancing não são substituídas automaticamente pelo Amazon Auto EC2 Scaling, a menos que você configure manualmente o Amazon Auto EC2 Scaling para fazer isso. Para mais detalhes, consulte [Configuração da verificação de integridade do ajuste de escala automático para o seu ambiente Elastic Beanstalk](environmentconfig-autoscaling-healthchecktype.md).
Para obter mais informações sobre verificações de integridade e como elas influenciam a integridade geral do ambiente, consulte [Relatórios de integridade básica](using-features.healthstatus.md).
#### Sessões
Selecione ou desmarque a caixa **Política de perdurabilidade habilitada** para habilitar ou desabilitar as sticky sessions. Use **Duração do cookie** para configurar a duração de uma sticky session até **604800** segundos.
### Regras
Use esta lista para especificar regras de listener para seu load balancer. Uma regra mapeia solicitações que o listener recebe em um padrão de caminho específico para um processo de destino. Cada listener pode ter várias regras, roteando solicitações em diferentes caminhos para diferentes processos nas suas instâncias.
As regras têm prioridades numéricas que determinam a precedência em que são aplicadas às solicitações recebidas. Para cada novo listener adicionado, o Elastic Beanstalk adiciona uma regra padrão que direciona todo o tráfego do listener para o processo padrão. A precedência da regra padrão é a mais baixa. Ela é aplicada se nenhuma outra regra para o mesmo listener corresponder à solicitação recebida. Inicialmente, se você não tiver adicionado regras personalizadas, a lista estará vazia. As regras padrão de todos os listeners não são exibidas.
Você pode editar as configurações de uma regra existente ou adicionar uma nova regra. Para começar a editar uma regra na lista ou adicionar uma regra a ela, use as mesmas etapas listadas para [lista de listener](#environments-cfg-alb-console-listeners). A caixa de diálogo **Listener rule** é exibida com as seguintes configurações:
+ **Name (Nome)**: o nome da regra.
+ **Listener port (Porta do listener)**: porta do listener ao qual a regra se aplica.
+ **Priority (Prioridade)**: prioridade da regra. Um número de prioridade mais baixa tem maior precedência. As prioridades das regras de um listener devem ser únicas.
+ **Match conditions (Condições de correspondência)**: uma lista de condições do URL de solicitação às quais a regra se aplica. Há dois tipos de condições: **HostHeader**(a parte do domínio do URL) e **PathPattern**(a parte do caminho do URL). É possível adicionar até cinco condições. Cada valor de condição tem até 128 caracteres de comprimento e pode incluir caracteres curinga.
+ **Process (Processo)**: o processo para o qual o balanceador de carga direciona solicitações que correspondem à regra.
Ao editar qualquer regra existente, você não pode alterar **Name** nem **Listener port**.
### Captura de log de acesso
Use essas configurações para configurar o Elastic Load Balancing para capturar logs com informações detalhadas sobre solicitações enviadas ao Application Load Balancer. A captura de log de acesso está desativada por padrão. Quando **Store logs (Armazenar logs)** está habilitado, o Elastic Load Balancing armazena os logs no **S3 bucket (Bucket do S3)** configurado. A configuração **Prefix (Prefixo)** especifica uma pasta de nível superior no bucket para os logs. O Elastic Load Balancing coloca os logs em uma pasta denominada `AWSLogs` sob seu prefixo. Se você não especificar um prefixo, o Elastic Load Balancing coloca sua pasta no nível raiz do bucket.
**nota**
Se o bucket do Amazon S3 que você configura para captura de log de acesso não for o bucket que o Elastic Beanstalk criou para sua conta, certifique-se de adicionar uma política de usuário com as permissões apropriadas para seus usuários (IAM). AWS Identity and Access Management As [políticas de usuário gerenciadas](AWSHowTo.iam.managed-policies.md) que o Elastic Beanstalk fornece apenas permissões de cobertura para recursos gerenciados pelo Elastic Beanstalk.
Para obter detalhes sobre logs de acesso, incluindo permissões e outros requisitos, consulte [Registros de acesso para o Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html).
## Exemplo: Application Load Balancer com um listener seguro e dois processos
Neste exemplo, seu aplicativo exige criptografia de end-to-end tráfego e um processo separado para lidar com solicitações administrativas.
Para configurar o Application Load Balancer do ambiente de modo a atender esses requisitos, remova o listener padrão, adicione um listener HTTPS, indique que o processo padrão escuta a porta 443 em HTTPS e adicione um processo e uma regra de listener ao tráfego administrativo em um caminho diferente.
**Para configurar o load balancer neste exemplo**
1. *Adicione um listener seguro.* Em **Porta**, digite **443**. Em **Protocolo**, selecione **HTTPS**. Em **Certificado SSL**, escolha o ARN do seu certificado SSL. Por exemplo, **arn:aws:iam::123456789012:server-certificate/abc/certs/build** ou **arn:aws:acm:us-east-2:123456789012:certificate/12345678-12ab-34cd-56ef-12345678**.
Em **Processo padrão**, mantenha **default** selecionado.
Agora você pode ver seu listener adicional na lista.
1. *Desative o listener HTTP da porta padrão 80.* Para o listener padrão, desative a opção **Habilitada**.
1. *Configure o processo padrão como HTTPS.* Selecione o processo padrão e, em seguida, para **Actions**, escolha **Edit**. Em **Porta**, digite **443**. Em **Protocolo**, selecione **HTTPS**.
1. *Adicione um processo administrativo.* Para **Name** (Nome), digite **admin**. Em **Porta**, digite **443**. Em **Protocolo**, selecione **HTTPS**. Em **Verificação de integridade**, para **Caminho**, digite **/admin**.
1. *Adicione uma regra para o tráfego de administrador.* Para **Name** (Nome), digite **admin**. Para **Listener port**, digite **443**. Para **condições de partida**, adicione um **PathPattern**com o valor**/admin/\***. Em **Processo**, selecione **admin**.
## Configurar um Application Load Balancer usando a CLI do EB
A EB CLI solicita que você escolha um tipo de load balancer ao executar o [**eb create**](eb3-create.md).
```
$ eb create
Enter Environment Name
(default is my-app): test-env
Enter DNS CNAME prefix
(default is my-app): test-env-DLW24ED23SF
Select a load balancer type
1) classic
2) application
3) network
(default is 2):
```
Você também pode especificar um tipo de load balancer com a opção `--elb-type`.
```
$ eb create {{test-env}} --elb-type application
```
## Namespaces do Application Load Balancer
É possível encontrar configurações relacionadas aos Application Load Balancers nos seguintes namespaces:
+ `aws:elasticbeanstalk:environment`: selecione o tipo de balanceador de carga para o ambiente. O valor de um Application Load Balancer é `application`.
Não é possível definir essa opção nos arquivos de configuração ([.Ebextensions](ebextensions.md)).
+ `aws:elbv2:loadbalancer`: defina logs de acesso e outras configurações que se aplicam ao Application Load Balancer como um todo.
+ `aws:elbv2:listener`: configure listeners no Application Load Balancer. Essas configurações são mapeadas para as configurações em `aws:elb:listener` para Classic Load Balancers.
+ `aws:elbv2:listenerrule`: configure as regras que roteiam o tráfego para os diferentes processos, dependendo do caminho da solicitação. As regras são exclusivas dos Application Load Balancers.
+ `aws:elasticbeanstalk:environment:process`: configure as verificações de integridade e especifique a porta e o protocolo para os processos que são executados nas instâncias de seu ambiente. A porta e as configurações de protocolo mapeiam a porta e as configurações de protocolo da instância em `aws:elb:listener` para um listener no Classic Load Balancer. As configurações de verificação de integridade são mapeadas para as configurações nos namespaces `aws:elb:healthcheck` e `aws:elasticbeanstalk:application`.
**Example .ebextensions/ .config alb-access-logs**
O arquivo de configuração a seguir permite fazer upload do log de acesso para um ambiente com um Application Load Balancer.
```
option_settings:
aws:elbv2:loadbalancer:
AccessLogsS3Bucket: amzn-s3-demo-bucket
AccessLogsS3Enabled: 'true'
AccessLogsS3Prefix: beanstalk-alb
```
**Example .ebextensions/ .config alb-default-process**
O arquivo de configuração a seguir modifica as configurações de verificação de integridade e de perdurabilidade no processo padrão.
```
option_settings:
aws:elasticbeanstalk:environment:process:default:
DeregistrationDelay: '20'
HealthCheckInterval: '15'
HealthCheckPath: /
HealthCheckTimeout: '5'
HealthyThresholdCount: '3'
UnhealthyThresholdCount: '5'
Port: '80'
Protocol: HTTP
StickinessEnabled: 'true'
StickinessLBCookieDuration: '43200'
```
**Example .ebextensions/ .config alb-secure-listener**
O arquivo de configuração a seguir adiciona um listener seguro e um processo de correspondência na porta 443.
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
Protocol: HTTPS
SSLCertificateArns: arn:aws:acm:us-east-2:123456789012:certificate/21324896-0fa4-412b-bf6f-f362d6eb6dd7
aws:elasticbeanstalk:environment:process:https:
Port: '443'
Protocol: HTTPS
```
**Example .ebextensions/ .config alb-admin-rule**
O arquivo de configuração a seguir adiciona um listener seguro com uma regra que roteia o tráfego com um caminho de solicitação de `/admin` para um processo chamado `admin` que escuta na porta 4.443.
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
Protocol: HTTPS
Rules: admin
SSLCertificateArns: {{arn:aws:acm:us-east-2:123456789012:certificate/21324896-0fa4-412b-bf6f-f362d6eb6dd7}}
aws:elasticbeanstalk:environment:process:https:
Port: '443'
Protocol: HTTPS
aws:elasticbeanstalk:environment:process:admin:
HealthCheckPath: /admin
Port: '4443'
Protocol: HTTPS
aws:elbv2:listenerrule:admin:
PathPatterns: /admin/*
Priority: 1
Process: admin
```